@akanjs/document 0.0.39 → 0.0.41

package/index.d.ts

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/document",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"

package/src/dataLoader.d.ts

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

package/src/database.d.ts

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,67 @@
+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

@@ -0,0 +1,5 @@
+export * from "./dbDecorators";
+export * from "./schema";
+export * from "./types";
+export * from "./database";
+export * from "./dataLoader";

package/src/schema.d.ts

@@ -0,0 +1,29 @@
+import { FilterQuery, PipelineStage, type ProjectionType } from "mongoose";
+export declare const getDefaultSchemaOptions: <TSchema, TDocument>() => {
+    toJSON: {
+        getters: boolean;
+        virtuals: boolean;
+    };
+    toObject: {
+        getters: boolean;
+        virtuals: boolean;
+    };
+    _id: boolean;
+    id: boolean;
+    timestamps: boolean;
+    methods: {
+        refresh: () => Promise<any>;
+    };
+    statics: {
+        pickOne: (query: FilterQuery<TSchema>, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+        pickById: (docId: string | undefined, projection?: ProjectionType<TSchema>) => Promise<TDocument>;
+        sample: (query: FilterQuery<TSchema>, size?: number, aggregations?: PipelineStage[]) => Promise<TDocument[]>;
+        sampleOne: (query: FilterQuery<TSchema>, aggregations?: PipelineStage[]) => Promise<TDocument | null>;
+        addSummary: (prefix?: string, num?: number) => Promise<void>;
+        moveSummary: (prev: string, next: string, num?: number) => Promise<void>;
+        subSummary: (prefix?: string, num?: number) => Promise<void>;
+    };
+};
+export declare const convertAggregateMatch: (query: any) => {
+    [k: string]: any;
+};

package/src/types.d.ts

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