@akanjs/server 0.0.28 → 0.0.30

package/src/database.d.ts

@@ -1,114 +0,0 @@
-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";
-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>;
-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/database.js

@@ -1,312 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var database_exports = {};
-__export(database_exports, {
-  databaseModelOf: () => databaseModelOf
-});
-module.exports = __toCommonJS(database_exports);
-var import_base = require("@akanjs/base");
-var import_common = require("@akanjs/common");
-var import_constant = require("@akanjs/constant");
-var import_dataLoader = require("./dataLoader");
-var import_schema = require("./schema");
-var import_serviceDecorators = require("./serviceDecorators");
-class CacheDatabase {
-  constructor(refName, redis) {
-    this.refName = refName;
-    this.redis = redis;
-    this.logger = new import_common.Logger(`${refName}Cache`);
-  }
-  logger;
-  async set(topic, key, value, option = {}) {
-    const setOption = { PXAT: option.expireAt?.toDate().getTime() };
-    await this.redis.set(`${this.refName}:${topic}:${key}`, value, setOption);
-  }
-  async get(topic, key) {
-    const value = await this.redis.get(`${this.refName}:${topic}:${key}`);
-    return value;
-  }
-  async delete(topic, key) {
-    await this.redis.del(`${this.refName}:${topic}:${key}`);
-  }
-}
-class SearchDatabase {
-  constructor(refName, meili) {
-    this.refName = refName;
-    this.meili = meili;
-    this.logger = new import_common.Logger(`${refName}Search`);
-    this.index = meili.index((0, import_common.lowerlize)(refName));
-  }
-  logger;
-  index;
-  async searchIds(searchText, option = {}) {
-    const { skip = 0, limit = import_constant.DEFAULT_PAGE_SIZE, sort } = option;
-    if (!searchText) {
-      const { results, total } = await this.index.getDocuments({ offset: skip ?? 0, limit: limit ?? 0 });
-      return { ids: results.map((result) => result.id), total };
-    }
-    const { hits, estimatedTotalHits } = await this.index.search(searchText, {
-      offset: skip ?? 0,
-      limit: limit ?? 0,
-      sort: sort ?? [],
-      filter: option.filter,
-      attributesToRetrieve: ["id"]
-    });
-    return { ids: hits.map((hit) => hit.id), total: estimatedTotalHits };
-  }
-  async count(searchText, option = {}) {
-    const { skip = 0, limit = import_constant.DEFAULT_PAGE_SIZE, sort = "" } = option;
-    if (!searchText) {
-      const { results, total } = await this.index.getDocuments({ offset: skip ?? 0, limit: limit ?? 0 });
-      return total;
-    }
-    const { hits, estimatedTotalHits } = await this.index.search(searchText, {
-      offset: skip ?? 0,
-      limit: limit ?? 0,
-      filter: option.filter,
-      attributesToRetrieve: ["id"]
-    });
-    return estimatedTotalHits;
-  }
-}
-class DatabaseModelStorage {
-  __ModelType__ = "DatabaseModelStorage";
-}
-const databaseModelOf = (database, model, redis, meili) => {
-  //! 잘되는지 확인 필요
-  const [modelName, className] = [database.refName, (0, import_common.capitalize)(database.refName)];
-  const insightFieldMetas = (0, import_constant.getFieldMetas)(database.Insight);
-  const accumulator = Object.fromEntries(insightFieldMetas.map((fieldMeta) => [fieldMeta.key, fieldMeta.accumulate]));
-  const defaultInsight = Object.fromEntries(insightFieldMetas.map((fieldMeta) => [fieldMeta.key, fieldMeta.default]));
-  const makeSafeQuery = (query) => ({ removedAt: { $exists: false }, ...query ?? {} });
-  const makeSafeMatchStage = (query) => ({
-    $match: { removedAt: { $exists: false }, ...(0, import_schema.convertAggregateMatch)(query) }
-  });
-  const getListQuery = (query, queryOption) => {
-    const find = makeSafeQuery(query);
-    const sort = (0, import_constant.getFilterSort)(database.Filter, queryOption?.sort ?? "latest");
-    const skip = queryOption?.skip ?? 0;
-    const limit = queryOption?.limit === null ? import_constant.DEFAULT_PAGE_SIZE : queryOption?.limit ?? 0;
-    const select = queryOption?.select;
-    const sample = queryOption?.sample;
-    return { find, sort, skip, limit, select, sample };
-  };
-  const getFindQuery = (query, queryOption) => {
-    const find = makeSafeQuery(query);
-    const sort = (0, import_constant.getFilterSort)(database.Filter, queryOption?.sort ?? "latest");
-    const skip = queryOption?.skip ?? 0;
-    const select = queryOption?.select;
-    const sample = queryOption?.sample ?? false;
-    return { find, sort, skip, select, sample };
-  };
-  const getSearchSort = (sortKey) => {
-    const sort = (0, import_constant.getFilterSort)(database.Filter, sortKey ?? "latest");
-    return Object.entries(sort).map(([key, value]) => `${key}:${value === 1 ? "asc" : "desc"}`);
-  };
-  const loader = (0, import_dataLoader.createLoader)(model);
-  const cacheDatabase = new CacheDatabase(database.refName, redis);
-  const searchDatabase = new SearchDatabase(database.refName, meili);
-  const DatabaseModel = Reflect.getMetadata(database.refName, DatabaseModelStorage.prototype) ?? class DatabaseModel {
-    logger = new import_common.Logger(`${modelName}Model`);
-    __model = model;
-    __cache = cacheDatabase;
-    __search = searchDatabase;
-    __loader = loader;
-    async __list(query, queryOption) {
-      const { find, sort, skip, limit, select, sample } = getListQuery(query, queryOption);
-      return sample ? await this.__model.sample(find, limit) : await this.__model.find(find, select).sort(sort).skip(skip).limit(limit);
-    }
-    async __listIds(query, queryOption) {
-      const { find, sort, skip, limit, sample } = getListQuery(query, queryOption);
-      return (sample ? await this.__model.sample(find, limit, [{ $project: { _id: 1 } }]) : await this.__model.find(find).sort(sort).skip(skip).limit(limit).select("_id")).map(({ _id }) => _id.toString());
-    }
-    async __find(query, queryOption) {
-      const { find, sort, skip, select, sample } = getFindQuery(query, queryOption);
-      const doc = sample ? await this.__model.sampleOne(find) : await this.__model.findOne(find, select).sort(sort).skip(skip);
-      if (!doc)
-        return null;
-      return doc;
-    }
-    async __findId(query, queryOption) {
-      const { find, sort, skip, sample } = getFindQuery(query, queryOption);
-      const doc = sample ? await this.__model.sampleOne(find, [{ $project: { _id: 1 } }]) : await this.__model.findOne(find).sort(sort).skip(skip).select("_id");
-      if (!doc)
-        return null;
-      return doc._id.toString();
-    }
-    async __pick(query, queryOption) {
-      const { find, sort, skip, select, sample } = getFindQuery(query, queryOption);
-      const doc = sample ? await this.__model.sampleOne(find) : await this.__model.findOne(find, select).sort(sort).skip(skip);
-      if (!doc)
-        throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
-      return doc;
-    }
-    async __pickId(query, queryOption) {
-      const { find, sort, skip, sample } = getFindQuery(query, queryOption);
-      const doc = sample ? await this.__model.sampleOne(find, [{ $project: { _id: 1 } }]) : await this.__model.findOne(find).sort(sort).skip(skip).select("_id");
-      if (!doc)
-        throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
-      return doc._id.toString();
-    }
-    async __exists(query) {
-      const find = makeSafeQuery(query);
-      const existingId = await this.__model.exists(find);
-      return existingId?.toString() ?? null;
-    }
-    async __count(query) {
-      const find = makeSafeQuery(query);
-      return await this.__model.countDocuments(find);
-    }
-    async __insight(query) {
-      if (!accumulator)
-        throw new Error(`No Insight (${database.refName})`);
-      const res = await this.__model.aggregate([
-        makeSafeMatchStage(query),
-        { $group: { _id: null, ...accumulator } }
-      ]);
-      const data = res[0];
-      return data ?? defaultInsight;
-    }
-    async getDefaultSummary(addQuery = {}) {
-      if (!database.Summary)
-        return {};
-      const fieldMetas = (0, import_constant.getFieldMetas)(database.Summary);
-      const summary = {};
-      await Promise.all(
-        fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map(async (fieldMeta) => {
-          const query = typeof fieldMeta.query === "function" ? fieldMeta.query() : fieldMeta.query;
-          summary[fieldMeta.key] = query ? await model.countDocuments({ ...query, ...addQuery }) : fieldMeta.default;
-        })
-      );
-      return summary;
-    }
-    async [`get${className}`](id) {
-      const doc = await this.__loader.load(id);
-      if (!doc)
-        throw new Error(`No Document (${database.refName}): ${id}`);
-      return doc;
-    }
-    async [`load${className}`](id) {
-      return id ? await this.__loader.load(id) : null;
-    }
-    async [`load${className}Many`](ids) {
-      return await this.__loader.loadMany(ids);
-    }
-    async [`create${className}`](data) {
-      return await new this.__model(data).save();
-    }
-    async [`update${className}`](id, data) {
-      const doc = await this.__model.pickById(id);
-      return await doc.set(data).save();
-    }
-    async [`remove${className}`](id) {
-      const doc = await this.__model.pickById(id);
-      return await doc.set({ removedAt: (0, import_base.dayjs)() }).save();
-    }
-    async [`search${className}`](searchText, queryOption = {}) {
-      const { skip, limit, sort } = queryOption;
-      const { ids, total } = await this.__search.searchIds(searchText, { skip, limit, sort: getSearchSort(sort) });
-      const docs = await this.__loader.loadMany(ids);
-      return { docs, count: total };
-    }
-    async [`searchDocs${className}`](searchText, queryOption = {}) {
-      const { skip, limit, sort } = queryOption;
-      const { ids } = await this.__search.searchIds(searchText, { skip, limit, sort: getSearchSort(sort) });
-      return await this.__loader.loadMany(ids);
-    }
-    async [`searchCount${className}`](searchText) {
-      return await this.__search.count(searchText);
-    }
-  };
-  DatabaseModel.prototype[className] = model;
-  DatabaseModel.prototype[`${modelName}Loader`] = loader;
-  DatabaseModel.prototype[`${modelName}Cache`] = cacheDatabase;
-  DatabaseModel.prototype[`${modelName}Search`] = searchDatabase;
-  const getQueryDataFromKey = (queryKey, args) => {
-    const lastArg = args.at(-1);
-    const hasQueryOption = lastArg && typeof lastArg === "object" && (typeof lastArg.select === "object" || typeof lastArg.skip === "number" || typeof lastArg.limit === "number" || typeof lastArg.sort === "string");
-    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
-    const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
-    const queryOption = hasQueryOption ? lastArg : {};
-    return { query, queryOption };
-  };
-  const filterKeyMetaMap = (0, import_constant.getFilterKeyMetaMapOnPrototype)(database.Filter.prototype);
-  const queryKeys = [...filterKeyMetaMap.keys()];
-  queryKeys.forEach((queryKey) => {
-    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
-    DatabaseModel.prototype[`list${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__list(query, queryOption);
-    };
-    DatabaseModel.prototype[`listIds${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__listIds(query, queryOption);
-    };
-    DatabaseModel.prototype[`find${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__find(query, queryOption);
-    };
-    DatabaseModel.prototype[`findId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__findId(query, queryOption);
-    };
-    DatabaseModel.prototype[`pick${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__pick(query, queryOption);
-    };
-    DatabaseModel.prototype[`pickId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__pickId(query, queryOption);
-    };
-    DatabaseModel.prototype[`exists${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const query = queryFn(...args);
-      return this.__exists(query);
-    };
-    DatabaseModel.prototype[`count${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const query = queryFn(...args);
-      return this.__count(query);
-    };
-    DatabaseModel.prototype[`insight${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const query = queryFn(...args);
-      return this.__insight(query);
-    };
-  });
-  const loaderMetas = (0, import_dataLoader.getLoaderMetas)(database.Model);
-  loaderMetas.forEach((loaderMeta) => {
-    const loader2 = loaderMeta.type === "Field" ? (0, import_dataLoader.createLoader)(model, loaderMeta.fieldName) : loaderMeta.type === "ArrayField" ? (0, import_dataLoader.createArrayLoader)(model, loaderMeta.fieldName) : loaderMeta.type === "Query" ? (0, import_dataLoader.createQueryLoader)(model, loaderMeta.queryKeys ?? []) : null;
-    DatabaseModel.prototype[loaderMeta.key] = loader2;
-  });
-  Object.getOwnPropertyNames(database.Model.prototype).forEach((key) => {
-    DatabaseModel.prototype[key] = database.Model.prototype[key];
-  });
-  const createDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `create${className}`);
-  if (createDescriptor)
-    (0, import_serviceDecorators.Transaction)()(DatabaseModel.prototype, `create${className}`, createDescriptor);
-  const updateDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `update${className}`);
-  if (updateDescriptor)
-    (0, import_serviceDecorators.Transaction)()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
-  const removeDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `remove${className}`);
-  if (removeDescriptor)
-    (0, import_serviceDecorators.Transaction)()(DatabaseModel.prototype, `remove${className}`, removeDescriptor);
-  Reflect.defineMetadata(database.refName, DatabaseModel, DatabaseModelStorage.prototype);
-  return new DatabaseModel();
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  databaseModelOf
-});

package/src/dbDecorators.d.ts

@@ -1,68 +0,0 @@
-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 Model: <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 AddModel: <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 Input: <InputModel>(inputRef: Type<InputModel>) => Type<DocumentModel<InputModel>>;
-export declare const AddInput: <A, B>(modelRef: Type<A>, addRef: Type<B>) => Type<A & DocumentModel<B>>;
-export declare const Document: <ObjectModel>(objectRef: Type<ObjectModel>) => Type<ObjectModel extends BaseObject ? Doc<ObjectModel> : DocumentModel<ObjectModel>>;
-export declare const AddDocument: <A, B>(modelRef: Type<A>, addRef: Type<B>) => Type<A & Doc<B>>;
-export declare const Middleware: <DbModel, Doc>(model: Type<DbModel>, doc: Type<Doc>) => {
-    new (): {
-        onSchema(schema: SchemaOf<DbModel, Doc>): void;
-    };
-};

package/src/dbDecorators.js

@@ -1,130 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dbDecorators_exports = {};
-__export(dbDecorators_exports, {
-  AddDocument: () => AddDocument,
-  AddInput: () => AddInput,
-  AddModel: () => AddModel,
-  Database: () => Database,
-  Document: () => Document,
-  DocumentDatabaseStorage: () => DocumentDatabaseStorage,
-  Input: () => Input,
-  InputDatabaseStorage: () => InputDatabaseStorage,
-  Middleware: () => Middleware,
-  MiddlewareDatabaseStorage: () => MiddlewareDatabaseStorage,
-  Model: () => Model,
-  ModelDatabaseStorage: () => ModelDatabaseStorage,
-  dbOf: () => dbOf,
-  getAllDatabaseModelNames: () => getAllDatabaseModelNames
-});
-module.exports = __toCommonJS(dbDecorators_exports);
-var import_constant = require("@akanjs/constant");
-const dbOf = (refName, Input2, Doc, Model2, Middleware2, Obj, Insight, Filter, Summary) => {
-  return { refName, Input: Input2, Doc, Model: Model2, Middleware: Middleware2, Obj, Insight, Filter, Summary };
-};
-class InputDatabaseStorage {
-}
-class DocumentDatabaseStorage {
-}
-class ModelDatabaseStorage {
-}
-class MiddlewareDatabaseStorage {
-}
-const getAllDatabaseModelNames = () => {
-  const modelNames = Reflect.getMetadataKeys(ModelDatabaseStorage.prototype) ?? [];
-  return modelNames;
-};
-const Database = {
-  Input: (returns) => {
-    return function(target) {
-      const modelRef = returns();
-      const classMeta = (0, import_constant.getClassMeta)(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, InputDatabaseStorage.prototype);
-    };
-  },
-  Document: (returns) => {
-    return function(target) {
-      const modelRef = returns();
-      const classMeta = (0, import_constant.getClassMeta)(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, DocumentDatabaseStorage.prototype);
-    };
-  },
-  Model: (returns) => {
-    return function(target) {
-      const modelRef = returns();
-      const classMeta = (0, import_constant.getClassMeta)(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, ModelDatabaseStorage.prototype);
-    };
-  },
-  Middleware: (returns) => {
-    return function(target) {
-      const modelRef = returns();
-      const classMeta = (0, import_constant.getClassMeta)(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, MiddlewareDatabaseStorage.prototype);
-    };
-  }
-};
-const Model = (docRef, cnst) => {
-  class DefaultModel {
-  }
-  return DefaultModel;
-};
-const AddModel = (modelRef, cnst) => {
-  return modelRef;
-};
-const Input = (inputRef) => {
-  return inputRef;
-};
-const AddInput = (modelRef, addRef) => {
-  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
-  const addFieldMetas = (0, import_constant.getFieldMetaMap)(addRef);
-  (0, import_constant.setFieldMetaMap)(modelRef, new Map([...fieldMetaMap, ...addFieldMetas]));
-  return modelRef;
-};
-const Document = (objectRef) => {
-  return objectRef;
-};
-const AddDocument = (modelRef, addRef) => {
-  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
-  const addFieldMetas = (0, import_constant.getFieldMetaMap)(addRef);
-  (0, import_constant.setFieldMetaMap)(modelRef, new Map([...fieldMetaMap, ...addFieldMetas]));
-  return modelRef;
-};
-const Middleware = (model, doc) => {
-  return class Middleware {
-    onSchema(schema) {
-    }
-  };
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AddDocument,
-  AddInput,
-  AddModel,
-  Database,
-  Document,
-  DocumentDatabaseStorage,
-  Input,
-  InputDatabaseStorage,
-  Middleware,
-  MiddlewareDatabaseStorage,
-  Model,
-  ModelDatabaseStorage,
-  dbOf,
-  getAllDatabaseModelNames
-});