@akanjs/document 0.0.40 → 0.0.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/document",
-  "version": "0.0.40",
+  "version": "0.0.41",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -14,5 +14,37 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {}
+  "dependencies": {
+    "@nestjs/apollo": "^12.2.2",
+    "@nestjs/common": "^10.4.15",
+    "@nestjs/graphql": "^12.2.2",
+    "@nestjs/mongoose": "^10.1.0",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-socket.io": "^10.4.15",
+    "@nestjs/schedule": "^4.1.2",
+    "@socket.io/redis-adapter": "^8.3.0",
+    "@urql/core": "^5.1.0",
+    "apple-signin": "^1.0.9",
+    "dataloader": "^2.2.3",
+    "dayjs": "^1.11.13",
+    "iap": "^1.1.1",
+    "immer": "^10.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.21",
+    "mongoose": "^8.9.3",
+    "next": "^15.3.2",
+    "passport-apple": "^2.0.2",
+    "passport-facebook": "^3.0.0",
+    "passport-github": "^1.1.0",
+    "passport-google-oauth20": "^2.0.0",
+    "passport-kakao": "^1.0.1",
+    "passport-naver": "^1.0.6",
+    "pluralize": "^8.0.0",
+    "redis": "^4.7.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "socket.io-client": "^4.8.1",
+    "tunnel-ssh": "^5.2.0",
+    "ua-parser-js": "^1.0.40"
+  }
 }

package/src/dataLoader.d.ts

@@ -1,29 +1,26 @@
-import { T as Type } from '../types-H2HI4YUe.js';
-import DataLoader from 'dataloader';
-export { default as DataLoader } from 'dataloader';
-import { Types, Schema, Model, FilterQuery } from 'mongoose';
-
-declare const Id: typeof Types.ObjectId;
-declare const ObjectId: typeof Schema.Types.ObjectId;
-declare const Mixed: typeof Schema.Types.Mixed;
-
-declare const createLoader: <Key, Value>(model: Model<any>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<Key, Value, Key>;
-declare const createArrayLoader: <K, V>(model: Model<unknown, unknown, unknown, unknown>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<K, V, K>;
-declare const createArrayElementLoader: <K, V>(model: Model<unknown>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<K, V, K>;
-declare const createQueryLoader: <Key, Value>(model: Model<any>, queryKeys: string[], defaultQuery?: FilterQuery<unknown>) => DataLoader<Key, Value, Key>;
-interface LoaderMeta {
+import type { Type } from "@akanjs/base";
+import DataLoader from "dataloader";
+import type { FilterQuery, Model } from "mongoose";
+import { Schema, Types } from "mongoose";
+export declare const Id: typeof Types.ObjectId;
+export declare const ObjectId: typeof Schema.Types.ObjectId;
+export declare const Mixed: typeof Schema.Types.Mixed;
+export { DataLoader };
+export declare const createLoader: <Key, Value>(model: Model<any>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<Key, Value, Key>;
+export declare const createArrayLoader: <K, V>(model: Model<unknown, unknown, unknown, unknown>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<K, V, K>;
+export declare const createArrayElementLoader: <K, V>(model: Model<unknown>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<K, V, K>;
+export declare const createQueryLoader: <Key, Value>(model: Model<any>, queryKeys: string[], defaultQuery?: FilterQuery<unknown>) => DataLoader<Key, Value, Key>;
+export interface LoaderMeta {
     key: string;
     type: "Field" | "ArrayField" | "Query";
     fieldName?: string;
     queryKeys?: string[];
     defaultQuery: FilterQuery<unknown>;
 }
-declare const getLoaderMetas: (target: Type) => LoaderMeta[];
-type Loader<Field, Value> = DataLoader<Field, Value | null>;
-declare const Loader: {
+export declare const getLoaderMetas: (target: Type) => LoaderMeta[];
+export type Loader<Field, Value> = DataLoader<Field, Value | null>;
+export declare const Loader: {
     ByField: (fieldName: string, defaultQuery?: FilterQuery<unknown>) => (target: object, key: string) => void;
     ByArrayField: (fieldName: string, defaultQuery?: FilterQuery<unknown>) => (target: object, key: string) => void;
     ByQuery: (queryKeys: string[], defaultQuery?: FilterQuery<unknown>) => (target: object, key: string) => void;
 };
-
-export { Id, Loader, type LoaderMeta, Mixed, ObjectId, createArrayElementLoader, createArrayLoader, createLoader, createQueryLoader, getLoaderMetas };

package/src/database.d.ts

@@ -1,8 +1,110 @@
-import 'dayjs';
-export { k as DatabaseModel, l as databaseModelOf } from '../dbDecorators-B-tzSGvi.js';
-import 'mongoose';
-import 'dataloader';
-import 'meilisearch';
-import 'redis';
-import './types.js';
-import '../types-H2HI4YUe.js';
+import { type Dayjs } from "@akanjs/base";
+import { Logger } from "@akanjs/common";
+import { type DocumentModel, type FilterType, type FindQueryOption, type GetActionObject, type ListQueryOption, type QueryOf, type SortOf } from "@akanjs/constant";
+import type DataLoader from "dataloader";
+import type { Filter, MeiliSearch } from "meilisearch";
+import type { HydratedDocument } from "mongoose";
+import type { RedisClientType } from "redis";
+import type { BaseMiddleware, Database, Mdl } from "./dbDecorators";
+import type { DataInputOf } from "./types";
+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;
+        skip?: number | null;
+        limit?: number | null;
+        sort?: string[] | null;
+    }): Promise<{
+        ids: string[];
+        total: number;
+    }>;
+    count(searchText: string | undefined | null, option?: {
+        filter?: Filter;
+        skip?: number | null;
+        limit?: number | null;
+        sort?: string | null;
+    }): Promise<number>;
+}
+export 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?: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<Doc[]>;
+    __listIds(query?: QueryOf<Doc>, queryOption?: ListQueryOption<Sort, Obj>): Promise<string[]>;
+    __find(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc | null>;
+    __findId(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string | null>;
+    __pick(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<Doc>;
+    __pickId(query?: QueryOf<Doc>, queryOption?: FindQueryOption<Sort, Obj>): Promise<string>;
+    __exists(query?: QueryOf<Doc>): Promise<string | null>;
+    __count(query?: QueryOf<Doc>): Promise<number>;
+    __insight(query?: QueryOf<Doc>): Promise<Insight>;
+    getDefaultSummary(addQuery?: QueryOf<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;
+};
+export 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>;
+export {};

package/src/dbDecorators.d.ts

@@ -1,8 +1,67 @@
-export { B as BaseMiddleware, a as Database, 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, d as dbOf, g as getAllDatabaseModelNames, f as inside, i as into } from '../dbDecorators-B-tzSGvi.js';
-import '../types-H2HI4YUe.js';
-export { FilterQuery as QueryOf } from 'mongoose';
-import 'dayjs';
-import 'dataloader';
-import 'meilisearch';
-import 'redis';
-import './types.js';
+import { BaseObject, Type } from "@akanjs/base";
+import { type ConstantModel, type DocumentModel, type FilterType } from "@akanjs/constant";
+import type { FilterQuery, HydratedDocument, Model as MongooseModel, PipelineStage, ProjectionType, Schema } from "mongoose";
+import type { DatabaseModel } from "./database";
+export type { FilterQuery as QueryOf };
+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>;
+export 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>;
+}
+export type Mdl<Doc extends HydratedDocument<any>, Raw> = MongooseModel<Raw, unknown, unknown, unknown, Doc> & DefaultMdlStats<Doc, DocumentModel<Raw>>;
+export type SchemaOf<Mdl, Doc> = Schema<null, Mdl, Doc, undefined, null, Mdl>;
+export interface BaseMiddleware {
+    onSchema: (schema: SchemaOf<any, any>) => void;
+}
+export 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>;
+}
+export 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>;
+export declare class InputDatabaseStorage {
+}
+export declare class DocumentDatabaseStorage {
+}
+export declare class ModelDatabaseStorage {
+}
+export declare class MiddlewareDatabaseStorage {
+}
+export declare const getAllDatabaseModelNames: () => string[];
+export 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;
+};
+export 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>>;
+export 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>>;
+export 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>>;
+export declare const beyond: <DbModel, Doc>(model: Type<DbModel>, doc: Type<Doc>) => {
+    new (): {
+        onSchema(schema: SchemaOf<DbModel, Doc>): void;
+    };
+};

package/src/index.d.ts

@@ -1,10 +1,5 @@
-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 './schema.js';
-export { DataInputOf } from './types.js';
-export { Id, Loader, LoaderMeta, Mixed, ObjectId, createArrayElementLoader, createArrayLoader, createLoader, createQueryLoader, getLoaderMetas } from './dataLoader.js';
-export { FilterQuery as QueryOf } from 'mongoose';
-export { default as DataLoader } from 'dataloader';
-import 'dayjs';
-import '../types-H2HI4YUe.js';
-import 'meilisearch';
-import 'redis';
+export * from "./dbDecorators";
+export * from "./schema";
+export * from "./types";
+export * from "./database";
+export * from "./dataLoader";

package/src/schema.d.ts

@@ -1,6 +1,5 @@
-import { FilterQuery, ProjectionType, PipelineStage } from 'mongoose';
-
-declare const getDefaultSchemaOptions: <TSchema, TDocument>() => {
+import { FilterQuery, PipelineStage, type ProjectionType } from "mongoose";
+export declare const getDefaultSchemaOptions: <TSchema, TDocument>() => {
     toJSON: {
         getters: boolean;
         virtuals: boolean;
@@ -25,8 +24,6 @@ declare const getDefaultSchemaOptions: <TSchema, TDocument>() => {
         subSummary: (prefix?: string, num?: number) => Promise<void>;
     };
 };
-declare const convertAggregateMatch: (query: any) => {
+export declare const convertAggregateMatch: (query: any) => {
     [k: string]: any;
 };
-
-export { convertAggregateMatch, getDefaultSchemaOptions };

package/src/types.d.ts

@@ -1,7 +1,5 @@
-type DataInputOf<Input, Obj> = {
+export type DataInputOf<Input, Obj> = {
     [K in keyof Input as Input[K] extends any[] ? never : K]: Input[K];
 } & {
     [K in keyof Input as Input[K] extends any[] ? K : never]?: Input[K];
 } & Partial<Obj>;
-
-export type { DataInputOf };

package/dbDecorators-B-tzSGvi.d.ts

@@ -1,252 +0,0 @@
-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 };