@akanjs/document 0.0.38 → 0.0.40

package/dbDecorators-B-tzSGvi.d.ts

@@ -0,0 +1,252 @@
+import { Dayjs } from 'dayjs';
+import { T as Type } from './types-H2HI4YUe.js';
+import { ProjectionType, FilterQuery, HydratedDocument, Model, PipelineStage, Schema } from 'mongoose';
+import DataLoader from 'dataloader';
+import { MeiliSearch, Filter as Filter$1 } from 'meilisearch';
+import { RedisClientType } from 'redis';
+import { DataInputOf } from './src/types.js';
+
+declare class BaseObject {
+    id: string;
+    createdAt: Dayjs;
+    updatedAt: Dayjs;
+    removedAt: Dayjs | null;
+}
+
+type Optional<T, K extends keyof T> = Pick<Partial<T>, K> & Omit<T, K>;
+type OptionalKeys<T> = T extends {
+    [key: string]: any;
+} ? {
+    [K in keyof T]-?: null extends T[K] ? K : never;
+}[keyof T] : never;
+type ObjectToId<O, D = Dayjs> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? D : O extends {
+    [key: string]: any;
+} ? DocumentModel<O> : O;
+type SortOf<Filter> = keyof GetStateObject<Filter>;
+type FilterType = Record<string, any>;
+interface ListQueryOption<Sort, Obj> {
+    skip?: number | null;
+    limit?: number | null;
+    sort?: Sort | null;
+    sample?: number;
+    select?: ProjectionType<Obj>;
+}
+interface FindQueryOption<Sort, Obj> {
+    skip?: number | null;
+    sort?: Sort | null;
+    sample?: boolean;
+    select?: ProjectionType<Obj>;
+}
+type DocumentModel<T, D = Dayjs> = T extends (infer S)[] ? DocumentModel<S>[] : T extends string ? T : T extends number ? T : T extends boolean ? T : T extends Dayjs ? T : T extends Map<infer K, infer V> ? Map<K, DocumentModel<V, D>> : Optional<{
+    [K in keyof GetStateObject<T>]: T[K] extends infer S ? S extends null ? undefined : ObjectToId<T[K], D> : never;
+}, OptionalKeys<GetStateObject<T>>>;
+type GetStateObject<T> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? never : K]: T[K];
+}, "prototype">;
+type GetActionObject<T> = Omit<{
+    [K in keyof T as T[K] extends (...args: any) => any ? K : never]: T[K];
+}, "prototype">;
+
+interface ConstantModel<T extends string, Input, Full, Light, Insight, Filter extends FilterType, Summary = any> {
+    refName: T;
+    Input: Type<Input>;
+    Full: Type<Full>;
+    Light: Type<Light>;
+    Insight: Type<Insight>;
+    Filter: Type<Filter>;
+    Summary?: Type<Summary>;
+}
+
+declare const logLevels: readonly ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+type LogLevel = (typeof logLevels)[number];
+declare class Logger {
+    #private;
+    static level: LogLevel;
+    static setLevel(level: LogLevel): void;
+    name?: string;
+    constructor(name?: string);
+    trace(msg: string, context?: string): void;
+    verbose(msg: string, context?: string): void;
+    debug(msg: string, context?: string): void;
+    log(msg: string, context?: string): void;
+    info(msg: string, context?: string): void;
+    warn(msg: string, context?: string): void;
+    error(msg: string, context?: string): void;
+    raw(msg: string, method?: "console" | "process"): void;
+    rawLog(msg: string, method?: "console" | "process"): void;
+    static trace(msg: string, context?: string): void;
+    static verbose(msg: string, context?: string): void;
+    static debug(msg: string, context?: string): void;
+    static log(msg: string, context?: string): void;
+    static info(msg: string, context?: string): void;
+    static warn(msg: string, context?: string): void;
+    static error(msg: string, context?: string): void;
+    static rawLog(msg: string, method?: "console" | "process"): void;
+    static raw(msg: string, method?: "console" | "process"): void;
+}
+
+interface RedisSetOptions {
+    expireAt?: Dayjs;
+}
+declare class CacheDatabase<T = any> {
+    private readonly refName;
+    private readonly redis;
+    private logger;
+    constructor(refName: string, redis: RedisClientType);
+    set(topic: string, key: string, value: string | number | Buffer, option?: RedisSetOptions): Promise<void>;
+    get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined>;
+    delete(topic: string, key: string): Promise<void>;
+}
+declare class SearchDatabase<T = any> {
+    readonly refName: string;
+    readonly meili: MeiliSearch;
+    private logger;
+    private index;
+    constructor(refName: string, meili: MeiliSearch);
+    searchIds(searchText: string | undefined | null, option?: {
+        filter?: Filter$1;
+        skip?: number | null;
+        limit?: number | null;
+        sort?: string[] | null;
+    }): Promise<{
+        ids: string[];
+        total: number;
+    }>;
+    count(searchText: string | undefined | null, option?: {
+        filter?: Filter$1;
+        skip?: number | null;
+        limit?: number | null;
+        sort?: string | null;
+    }): Promise<number>;
+}
+type DatabaseModel<T extends string, Input, Doc, Obj, Insight, Filter, Summary = any> = DatabaseModelWithQuerySort<T, Input, Doc, Obj, Insight, GetActionObject<Filter>, SortOf<Filter>, Summary>;
+type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Query, Sort, Summary = any> = {
+    logger: Logger;
+    __model: Mdl<Doc, Obj>;
+    __cache: CacheDatabase<T>;
+    __search: SearchDatabase<T>;
+    __loader: DataLoader<string, Doc, string>;
+    __list(query?: FilterQuery<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<Doc[]>;
+    __listIds(query?: FilterQuery<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<string[]>;
+    __find(query?: FilterQuery<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc | null>;
+    __findId(query?: FilterQuery<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string | null>;
+    __pick(query?: FilterQuery<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc>;
+    __pickId(query?: FilterQuery<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string>;
+    __exists(query?: FilterQuery<Doc>): Promise<string | null>;
+    __count(query?: FilterQuery<Doc>): Promise<number>;
+    __insight(query?: FilterQuery<Doc>): Promise<Insight>;
+    getDefaultSummary(addQuery?: FilterQuery<Doc>): Promise<Summary>;
+} & {
+    [key in Capitalize<T>]: Mdl<Doc, Obj>;
+} & {
+    [key in `${T}Loader`]: DataLoader<string, Doc, string>;
+} & {
+    [key in `${T}Cache`]: CacheDatabase<T>;
+} & {
+    [key in `${T}Search`]: SearchDatabase<T>;
+} & {
+    [K in `get${Capitalize<T>}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `load${Capitalize<T>}`]: (id?: string) => Promise<Doc | null>;
+} & {
+    [K in `load${Capitalize<T>}Many`]: (ids: string) => Promise<Doc[]>;
+} & {
+    [K in `create${Capitalize<T>}`]: (data: DataInputOf<Input, DocumentModel<Obj>>) => Promise<Doc>;
+} & {
+    [K in `update${Capitalize<T>}`]: (id: string, data: DataInputOf<Input, DocumentModel<Obj>>) => Promise<Doc>;
+} & {
+    [K in `remove${Capitalize<T>}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `search${Capitalize<T>}`]: (searchText: string, queryOption?: ListQueryOption<Sort, Obj>) => Promise<{
+        docs: Doc[];
+        count: number;
+    }>;
+} & {
+    [K in `searchDocs${Capitalize<T>}`]: (searchText: string, queryOption?: ListQueryOption<Sort, Obj>) => Promise<Doc[]>;
+} & {
+    [K in `searchCount${Capitalize<T>}`]: (searchText: string) => Promise<number>;
+} & {
+    [K in keyof Query as K extends string ? `list${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: ListQueryOption<Sort, Obj>]) => Promise<Doc[]> : never;
+} & {
+    [K in keyof Query as K extends string ? `listIds${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: ListQueryOption<Sort, Obj>]) => Promise<string[]> : never;
+} & {
+    [K in keyof Query as K extends string ? `find${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<Doc | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `findId${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<string | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `pick${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<Doc> : never;
+} & {
+    [K in keyof Query as K extends string ? `pickId${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args, queryOption?: FindQueryOption<Sort, Obj>]) => Promise<string> : never;
+} & {
+    [K in keyof Query as K extends string ? `exists${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<string | null> : never;
+} & {
+    [K in keyof Query as K extends string ? `count${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<number> : never;
+} & {
+    [K in keyof Query as K extends string ? `insight${Capitalize<K>}` : never]: Query[K] extends (...args: infer Args) => any ? (...args: [...Args]) => Promise<Insight> : never;
+};
+declare const databaseModelOf: <T extends string, Input, Doc extends HydratedDocument<any>, Model extends Mdl<any, any>, Middleware extends BaseMiddleware, Insight, Obj, Filter extends FilterType, Summary>(database: Database<T, Input, Doc, Model, Middleware, Insight, Obj, Filter, Summary>, model: Mdl<any, any>, redis: RedisClientType, meili: MeiliSearch) => DatabaseModel<T, Input, Doc, Model, Insight, Filter, Summary>;
+
+interface DefaultDocMtds<TDocument> {
+    refresh(): Promise<this>;
+    set(data: Partial<TDocument>): this;
+    save(): Promise<this>;
+}
+type HydratedDocumentWithId<TDocument> = Omit<HydratedDocument<TDocument, DefaultDocMtds<TDocument>>, "id" | "set" | "save"> & {
+    id: string;
+} & DefaultDocMtds<TDocument>;
+type Doc<M> = HydratedDocumentWithId<DocumentModel<M>>;
+interface DefaultMdlStats<TDocument, TSchema> {
+    pickOneAndWrite: (query: FilterQuery<TSchema>, rawData: Partial<TSchema>) => Promise<TDocument>;
+    pickAndWrite: (docId: string, rawData: Partial<TSchema>) => Promise<TDocument>;
+    pickOne: (query: FilterQuery<TSchema>, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+    pickById: (docId: string | undefined, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+    addSummary: (prefix?: string | string[], num?: number) => Promise<void>;
+    moveSummary: (prev: string, next: string, num?: number) => Promise<void>;
+    subSummary: (prefix?: string | string[], num?: number) => Promise<void>;
+    sample: (query: FilterQuery<TSchema>, size?: number, aggregations?: PipelineStage[]) => Promise<TDocument[]>;
+    sampleOne: (query: FilterQuery<TSchema>, aggregations?: PipelineStage[]) => Promise<TDocument | null>;
+}
+type Mdl<Doc extends HydratedDocument<any>, Raw> = Model<Raw, unknown, unknown, unknown, Doc> & DefaultMdlStats<Doc, DocumentModel<Raw>>;
+type SchemaOf<Mdl, Doc> = Schema<null, Mdl, Doc, undefined, null, Mdl>;
+interface BaseMiddleware {
+    onSchema: (schema: SchemaOf<any, any>) => void;
+}
+declare const dbOf: <T extends string, Input, Doc extends HydratedDocument<any>, Model extends DatabaseModel<T, Input, any, Obj, Insight, Filter>, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary>(refName: T, Input: Type<Input>, Doc: Type<Doc>, Model: Type<Model>, Middleware: Type<Middleware>, Obj: Type<Obj>, Insight: Type<Insight>, Filter: Type<Filter>, Summary?: Type<Summary>) => Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter, Summary>;
+declare class InputDatabaseStorage {
+}
+declare class DocumentDatabaseStorage {
+}
+declare class ModelDatabaseStorage {
+}
+declare class MiddlewareDatabaseStorage {
+}
+declare const getAllDatabaseModelNames: () => string[];
+interface Database<T extends string, Input, Doc extends HydratedDocument<any>, Model, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType, Summary> {
+    refName: T;
+    Input: Type<Input>;
+    Doc: Type<Doc>;
+    Model: Type<Model>;
+    Middleware: Type<Middleware>;
+    Obj: Type<Obj>;
+    Insight: Type<Insight>;
+    Filter: Type<Filter>;
+    Summary?: Type<Summary>;
+}
+declare const Database: {
+    Input: (returns: () => Type) => (target: any) => void;
+    Document: (returns: () => Type) => (target: any) => void;
+    Model: (returns: () => Type) => (target: any) => void;
+    Middleware: (returns: () => Type) => (target: any) => void;
+};
+declare const into: <Doc, T extends string, Input, Full, Light, Insight, Summary, Filter extends FilterType>(docRef: Type<Doc>, cnst: ConstantModel<T, Input, Full, Light, Insight, Filter, Summary>) => Type<DatabaseModel<T, DocumentModel<Input>, Doc, Full, Insight, Filter, Summary>>;
+declare const inside: <Doc, T extends string, Input, Full, Light, Insight, Filter extends FilterType, Summary>(modelRef: Type, cnst: ConstantModel<T, Input, Full, Light, Insight, Filter, Summary>) => Type<DatabaseModel<T, DocumentModel<Input>, Doc, Full, Insight, Filter, Summary>>;
+declare const by: <Model, AddModel>(modelRef: Type<Model>, addRef?: Type<AddModel>) => AddModel extends {
+    [key: string]: any;
+} ? Type<Model & (AddModel extends BaseObject ? Doc<AddModel> : DocumentModel<AddModel>)> : Type<Model extends BaseObject ? Doc<Model> : DocumentModel<Model>>;
+declare const beyond: <DbModel, Doc>(model: Type<DbModel>, doc: Type<Doc>) => {
+    new (): {
+        onSchema(schema: SchemaOf<DbModel, Doc>): void;
+    };
+};
+
+export { type BaseMiddleware as B, type Doc as D, InputDatabaseStorage as I, type Mdl as M, type SchemaOf as S, Database as a, DocumentDatabaseStorage as b, ModelDatabaseStorage as c, dbOf as d, MiddlewareDatabaseStorage as e, inside as f, getAllDatabaseModelNames as g, by as h, into as i, beyond as j, type DatabaseModel as k, databaseModelOf as l };

package/index.d.ts

@@ -0,0 +1,10 @@
+export { B as BaseMiddleware, a as Database, k as DatabaseModel, D as Doc, b as DocumentDatabaseStorage, I as InputDatabaseStorage, M as Mdl, e as MiddlewareDatabaseStorage, c as ModelDatabaseStorage, S as SchemaOf, j as beyond, h as by, l as databaseModelOf, d as dbOf, g as getAllDatabaseModelNames, f as inside, i as into } from './dbDecorators-B-tzSGvi.js';
+export { convertAggregateMatch, getDefaultSchemaOptions } from './src/schema.js';
+export { DataInputOf } from './src/types.js';
+export { Id, Loader, LoaderMeta, Mixed, ObjectId, createArrayElementLoader, createArrayLoader, createLoader, createQueryLoader, getLoaderMetas } from './src/dataLoader.js';
+export { FilterQuery as QueryOf } from 'mongoose';
+export { default as DataLoader } from 'dataloader';
+import 'dayjs';
+import './types-H2HI4YUe.js';
+import 'meilisearch';
+import 'redis';