145 lines
3.6 KiB
TypeScript
145 lines
3.6 KiB
TypeScript
import type { ReadStream } from 'node:fs'
|
|
import type { Readable } from 'node:stream'
|
|
import {
|
|
countImages as countImagesFromIndex,
|
|
deleteImageIndex,
|
|
getFolderStorageStats as getFolderStorageStatsFromIndex,
|
|
getImageIndexAsStored,
|
|
getUserScopedStorageStats as getUserScopedStorageStatsFromIndex,
|
|
insertImageIndex,
|
|
listFolders as listFoldersFromIndex,
|
|
listFoldersForUser as listFoldersForUserFromIndex,
|
|
listImageKeysForAutoDelete,
|
|
listImages as listImagesFromIndex,
|
|
searchImages as searchImagesFromIndex
|
|
} from './image-index'
|
|
import {
|
|
getActiveBackend,
|
|
getBackendForKey
|
|
} from './storage/resolver'
|
|
import type {
|
|
FolderStorageStat,
|
|
PaginatedResult,
|
|
StoredImage,
|
|
StoredImageMeta
|
|
} from './storage/types'
|
|
|
|
export type {
|
|
FolderStorageStat,
|
|
PaginatedResult,
|
|
StoredImage,
|
|
StoredImageMeta
|
|
} from './storage/types'
|
|
|
|
export { getDataDir } from './data-dir'
|
|
|
|
export async function putImage(
|
|
key: string,
|
|
bytes: Uint8Array,
|
|
meta: StoredImageMeta
|
|
): Promise<void> {
|
|
const backend = await getActiveBackend()
|
|
await backend.put(key, bytes, meta)
|
|
insertImageIndex({
|
|
key,
|
|
backendId: backend.id,
|
|
userId: meta.userId,
|
|
originalName: meta.originalName,
|
|
contentType: meta.contentType,
|
|
size: meta.size,
|
|
uploadedAt: meta.uploadedAt
|
|
})
|
|
}
|
|
|
|
export async function headImage(key: string): Promise<StoredImage | null> {
|
|
const indexed = getImageIndexAsStored(key)
|
|
if (indexed) return indexed
|
|
|
|
const backend = await getBackendForKey(key)
|
|
const stored = await backend.head(key)
|
|
if (!stored) return null
|
|
|
|
insertImageIndex({
|
|
key: stored.key,
|
|
backendId: backend.id,
|
|
userId: stored.userId,
|
|
originalName: stored.originalName,
|
|
contentType: stored.contentType,
|
|
size: stored.size,
|
|
uploadedAt: stored.uploadedAt
|
|
})
|
|
|
|
return { ...stored, backendId: backend.id }
|
|
}
|
|
|
|
export async function createImageStream(
|
|
key: string,
|
|
range?: { start: number, end: number }
|
|
): Promise<ReadStream | Readable> {
|
|
const backend = await getBackendForKey(key)
|
|
return backend.createStream(key, range)
|
|
}
|
|
|
|
export async function deleteImage(key: string): Promise<void> {
|
|
const backend = await getBackendForKey(key)
|
|
await backend.delete(key)
|
|
deleteImageIndex(key)
|
|
}
|
|
|
|
export async function listFolders(): Promise<string[]> {
|
|
return listFoldersFromIndex()
|
|
}
|
|
|
|
export async function listImageKeys(): Promise<string[]> {
|
|
const images = await listImageKeysForAutoDelete()
|
|
return images.map(image => image.key)
|
|
}
|
|
|
|
export async function countImages(
|
|
folder?: string,
|
|
userFilter?: number | 'admin'
|
|
): Promise<number> {
|
|
return countImagesFromIndex(folder, userFilter)
|
|
}
|
|
|
|
export async function getFolderStorageStats(
|
|
userFilter?: number | 'admin'
|
|
): Promise<FolderStorageStat[]> {
|
|
return getFolderStorageStatsFromIndex(userFilter)
|
|
}
|
|
|
|
export async function listFoldersForUser(
|
|
userFilter?: number | 'admin'
|
|
): Promise<string[]> {
|
|
return listFoldersForUserFromIndex(userFilter)
|
|
}
|
|
|
|
export async function getUserScopedStorageStats(userId: number): Promise<{
|
|
storedCount: number
|
|
uploadBytesTotal: number
|
|
uploadToday: number
|
|
uploadMonth: number
|
|
byFolder: FolderStorageStat[]
|
|
}> {
|
|
return getUserScopedStorageStatsFromIndex(userId)
|
|
}
|
|
|
|
export async function listImages(options: {
|
|
limit: number
|
|
page?: number
|
|
folder?: string
|
|
userFilter?: number | 'admin'
|
|
}): Promise<PaginatedResult<StoredImage>> {
|
|
return listImagesFromIndex(options)
|
|
}
|
|
|
|
export async function searchImages(options: {
|
|
query: string
|
|
limit: number
|
|
page?: number
|
|
folder?: string
|
|
userFilter?: number | 'admin'
|
|
}): Promise<PaginatedResult<StoredImage>> {
|
|
return searchImagesFromIndex(options)
|
|
}
|