@jsonkit/db 3.0.1 → 3.0.2

package/dist/index.d.ts

@@ -0,0 +1,154 @@
+type Identifiable = {
+    id: Id;
+};
+type Id = string;
+type Promisable<T> = T | Promise<T>;
+type PaginationInput = {
+    take: number;
+    page: number;
+    skip?: number | undefined | null;
+};
+type DeleteManyOutput = {
+    deletedIds: Id[];
+    ignoredIds: Id[];
+};
+type PredicateFn<T extends Identifiable> = (entry: T) => boolean;
+type JsonEntryParser<T> = {
+    parse: (text: string) => T;
+};
+type MultiEntryFileDbOptions<T> = {
+    noPathlikeIds?: boolean;
+    parser?: JsonEntryParser<T>;
+};
+type FileMeta = {
+    path: string;
+    size: number;
+    created: Date;
+    modified: Date;
+    accessed: Date;
+} & ({
+    type: FileType.File;
+} | {
+    type: FileType.Directory;
+    children: FileMeta[];
+});
+declare enum FileType {
+    File = "file",
+    Directory = "directory"
+}
+
+declare abstract class MultiEntryDb<T extends Identifiable> {
+    abstract create(entry: T): Promise<T>;
+    abstract getById(id: T['id']): Promise<T | null>;
+    abstract update(id: T['id'], updater: (entry: T) => Promisable<Partial<T>>): Promise<T>;
+    abstract deleteById(id: T['id']): Promise<boolean>;
+    abstract destroy(): Promise<void>;
+    protected abstract iterEntries(): AsyncIterable<T>;
+    protected abstract iterIds(): AsyncIterable<T['id']>;
+    getByIdOrThrow(id: T['id']): Promise<T>;
+    getWhere(predicate: PredicateFn<T>, pagination?: PaginationInput): Promise<T[]>;
+    getAll(): Promise<T[]>;
+    getAllIds(): Promise<T['id'][]>;
+    deleteByIds(ids: T['id'][]): Promise<DeleteManyOutput>;
+    deleteWhere(predicate: PredicateFn<T>): Promise<DeleteManyOutput>;
+    exists(id: T['id']): Promise<boolean>;
+    countAll(): Promise<number>;
+    countWhere(predicate: PredicateFn<T>, pagination?: PaginationInput): Promise<number>;
+}
+
+type ListOptions = {
+    depth?: number;
+    stripBasepath?: string;
+};
+type DeleteOptions = {
+    force?: boolean;
+    recursive?: boolean;
+};
+type WriteOptions = {
+    encoding?: BufferEncoding;
+};
+type ReadOptions = {
+    encoding?: BufferEncoding;
+    lines?: number;
+};
+type CopyOptions = {
+    recursive?: boolean;
+    overwrite?: boolean;
+};
+declare class Files {
+    move(oldPath: string, newPath: string): Promise<void>;
+    copy(sourcePath: string, destinationPath: string, options?: CopyOptions): Promise<void>;
+    copyRecursive(sourcePath: string, destinationPath: string): Promise<void>;
+    mkdir(filepath: string): Promise<void>;
+    protected mkdirUnsafe(filepath: string): Promise<void>;
+    write(filepath: string, content: string, options?: WriteOptions): Promise<void>;
+    touch(filepath: string): Promise<void>;
+    read(filepath: string, options?: ReadOptions): Promise<string>;
+    delete(filepath: string, options?: DeleteOptions): Promise<void>;
+    exists(filepath: string): Promise<boolean>;
+    isDir(filepath: string): Promise<boolean>;
+    isFile(filepath: string): Promise<boolean>;
+    isSymlink(filepath: string): Promise<boolean>;
+    getMeta(filepath: string, options?: ListOptions): Promise<FileMeta>;
+    list(dirpath: string, options?: ListOptions): Promise<string[]>;
+    listRead(dirpath: string, options?: ListOptions): AsyncGenerator<{
+        filepath: string;
+        content: string;
+    }, void, unknown>;
+    protected listRecursive(dirpath: string, maxDepth: number, currentDepth: number, stripBasepath: string | undefined): Promise<string[]>;
+    protected stripBasepath(original: string, pathToStrip: string | undefined): string;
+}
+
+declare class MultiEntryFileDb<T extends Identifiable> extends MultiEntryDb<T> {
+    protected readonly dirpath: string;
+    protected readonly files: Files;
+    protected readonly parser: JsonEntryParser<T>;
+    readonly noPathlikeIds: boolean;
+    constructor(dirpath: string, options?: MultiEntryFileDbOptions<T>);
+    create(entry: T): Promise<T>;
+    getById(id: T['id']): Promise<T | null>;
+    update(id: T['id'], updater: (entry: T) => Promisable<Partial<T>>): Promise<T>;
+    deleteById(id: T['id']): Promise<boolean>;
+    deleteByIds(ids: T['id'][]): Promise<DeleteManyOutput>;
+    destroy(): Promise<void>;
+    protected getFilePath(id: T['id']): string;
+    protected writeEntry(entry: T): Promise<void>;
+    isIdValid(id: T['id']): boolean;
+    protected iterEntries(): AsyncGenerator<T, void, unknown>;
+    protected iterIds(): AsyncGenerator<string, void, unknown>;
+}
+
+declare class SingleEntryFileDb<T> {
+    protected readonly filepath: string;
+    protected readonly parser: JsonEntryParser<T>;
+    protected readonly files: Files;
+    constructor(filepath: string, parser?: JsonEntryParser<T>);
+    path(): string;
+    isInited(): Promise<boolean>;
+    read(): Promise<T>;
+    write(updaterOrEntry: T | ((entry: T) => Promisable<Partial<T>>)): Promise<T>;
+    delete(): Promise<void>;
+}
+
+declare class MultiEntryMemDb<T extends Identifiable> extends MultiEntryDb<T> {
+    protected entries: Map<T['id'], T>;
+    create(entry: T): Promise<T>;
+    getById(id: T['id']): Promise<T | null>;
+    update(id: T['id'], updater: (entry: T) => Promisable<Partial<T>>): Promise<T>;
+    deleteById(id: T['id']): Promise<boolean>;
+    destroy(): Promise<void>;
+    protected iterEntries(): AsyncGenerator<T, void, unknown>;
+    protected iterIds(): AsyncGenerator<T["id"], void, unknown>;
+}
+
+declare class SingleEntryMemDb<T> {
+    protected entry: T | null;
+    constructor(initialEntry?: T | null);
+    isInited(): boolean;
+    read(): T;
+    write(updaterOrEntry: T | ((entry: T) => Partial<T>)): T;
+    delete(): void;
+}
+
+export { FileType, MultiEntryFileDb, MultiEntryMemDb, SingleEntryFileDb, SingleEntryMemDb };
+export type { DeleteManyOutput, FileMeta, Id, Identifiable, JsonEntryParser, MultiEntryFileDbOptions, PaginationInput, PredicateFn, Promisable };