@akanjs/document 0.0.28 → 0.0.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/document",
-  "version": "0.0.28",
+  "version": "0.0.29",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -10,5 +10,54 @@
     "url": "https://github.com/akan-team/akanjs.git",
     "directory": "pkgs/@akanjs/document"
   },
+  "dependencies": {
+    "@apollo/server": "^4.11.2",
+    "@inquirer/prompts": "^7.2.1",
+    "@nestjs/apollo": "^12.2.2",
+    "@nestjs/common": "^10.4.15",
+    "@nestjs/core": "^10.4.15",
+    "@nestjs/graphql": "^12.2.2",
+    "@nestjs/mongoose": "^10.1.0",
+    "@nestjs/passport": "^10.0.3",
+    "@nestjs/platform-express": "^10.4.15",
+    "@nestjs/platform-socket.io": "^10.4.15",
+    "@nestjs/schedule": "^4.1.2",
+    "@nestjs/websockets": "^10.4.15",
+    "@socket.io/redis-adapter": "^8.3.0",
+    "@urql/core": "^5.1.0",
+    "apple-signin": "^1.0.9",
+    "bull": "^4.16.5",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
+    "dataloader": "^2.2.3",
+    "dayjs": "^1.11.13",
+    "express": "^4.21.2",
+    "graphql": "^16.10.0",
+    "iap": "^1.1.1",
+    "immer": "^10.1.1",
+    "jsonwebtoken": "^9.0.2",
+    "lodash": "^4.17.21",
+    "meilisearch": "^0.47.0",
+    "mongoose": "^8.9.3",
+    "next": "^15.3.0",
+    "passport": "^0.7.0",
+    "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",
+    "picocolors": "^1.1.1",
+    "pluralize": "^8.0.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "redis": "^4.7.0",
+    "reflect-metadata": "^0.2.2",
+    "rxjs": "^7.8.1",
+    "socket.io": "^4.8.1",
+    "socket.io-client": "^4.8.1",
+    "tunnel-ssh": "^5.2.0",
+    "ua-parser-js": "^1.0.40"
+  },
   "main": "./index.js"
 }

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/dataLoader.js

@@ -0,0 +1,152 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dataLoader_exports = {};
+__export(dataLoader_exports, {
+  DataLoader: () => import_dataloader.default,
+  Id: () => Id,
+  Loader: () => Loader,
+  Mixed: () => Mixed,
+  ObjectId: () => ObjectId,
+  createArrayElementLoader: () => createArrayElementLoader,
+  createArrayLoader: () => createArrayLoader,
+  createLoader: () => createLoader,
+  createQueryLoader: () => createQueryLoader,
+  getLoaderMetas: () => getLoaderMetas
+});
+module.exports = __toCommonJS(dataLoader_exports);
+var import_dataloader = __toESM(require("dataloader"));
+var import_lodash = require("lodash");
+var import_mongoose = require("mongoose");
+const Id = import_mongoose.Types.ObjectId;
+const ObjectId = import_mongoose.Schema.Types.ObjectId;
+const Mixed = import_mongoose.Schema.Types.Mixed;
+const createLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+  return new import_dataloader.default(
+    (fields) => {
+      const query = { ...defaultQuery };
+      query[fieldName] = { $in: fields };
+      const data = model.find(query).then((list) => {
+        const listByKey = (0, import_lodash.keyBy)(list, fieldName);
+        return fields.map((id) => (0, import_lodash.get)(listByKey, id, null));
+      });
+      return data;
+    },
+    { name: "dataloader", cache: false }
+  );
+};
+const createArrayLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+  return new import_dataloader.default((fields) => {
+    const query = { ...defaultQuery };
+    query[fieldName] = { $in: fields };
+    const data = model.find(query).then((list) => {
+      return fields.map((field) => list.filter((item) => field === item[fieldName]));
+    });
+    return data;
+  });
+};
+const createArrayElementLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+  return new import_dataloader.default(
+    (fields) => {
+      const query = { ...defaultQuery };
+      query[fieldName] = { $in: fields };
+      const data = model.find(query).then((list) => {
+        const flat = (0, import_lodash.flatMap)(
+          list,
+          (dat) => dat[fieldName].map((datField) => ({
+            ...dat.toObject(),
+            key: datField
+          }))
+        );
+        const listByKey = (0, import_lodash.groupBy)(flat, (dat) => dat.key);
+        return fields.map((id) => (0, import_lodash.get)(listByKey, id, null));
+      });
+      return data;
+    },
+    { name: "dataloader", cache: false }
+  );
+};
+const createQueryLoader = (model, queryKeys, defaultQuery = {}) => {
+  return new import_dataloader.default(
+    (queries) => {
+      const query = {
+        $and: [{ $or: queries }, defaultQuery]
+      };
+      const getQueryKey = (query2) => queryKeys.map((key) => query2[key].toString()).join("");
+      const data = model.find(query).then((list) => {
+        const listByKey = (0, import_lodash.keyBy)(list, getQueryKey);
+        return queries.map((query2) => (0, import_lodash.get)(listByKey, getQueryKey(query2), null));
+      });
+      return data;
+    },
+    { name: "dataloader", cache: false }
+  );
+};
+const getLoaderMetaMapByPrototype = (prototype) => {
+  const loaderMetaMap = Reflect.getOwnMetadata("loaders", prototype) ?? /* @__PURE__ */ new Map();
+  return loaderMetaMap;
+};
+const getLoaderMetas = (target) => {
+  const metas = [...getLoaderMetaMapByPrototype(target.prototype).values()];
+  return metas;
+};
+const Loader = {
+  ByField: (fieldName, defaultQuery = {}) => {
+    return function(target, key) {
+      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
+      loaderMetaMap.set(key, { key, type: "Field", fieldName, defaultQuery });
+      Reflect.defineMetadata("loaders", loaderMetaMap, target);
+    };
+  },
+  ByArrayField: (fieldName, defaultQuery = {}) => {
+    return function(target, key) {
+      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
+      loaderMetaMap.set(key, { key, type: "ArrayField", fieldName, defaultQuery });
+      Reflect.defineMetadata("loaders", loaderMetaMap, target);
+    };
+  },
+  ByQuery: (queryKeys, defaultQuery = {}) => {
+    return function(target, key) {
+      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
+      loaderMetaMap.set(key, { key, type: "Query", queryKeys, defaultQuery });
+      Reflect.defineMetadata("loaders", loaderMetaMap, target);
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataLoader,
+  Id,
+  Loader,
+  Mixed,
+  ObjectId,
+  createArrayElementLoader,
+  createArrayLoader,
+  createLoader,
+  createQueryLoader,
+  getLoaderMetas
+});

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/database.js

@@ -0,0 +1,312 @@
+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_nest = require("@akanjs/nest");
+var import_dataLoader = require("./dataLoader");
+var import_schema = require("./schema");
+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_nest.Transaction)()(DatabaseModel.prototype, `create${className}`, createDescriptor);
+  const updateDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `update${className}`);
+  if (updateDescriptor)
+    (0, import_nest.Transaction)()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
+  const removeDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `remove${className}`);
+  if (removeDescriptor)
+    (0, import_nest.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

@@ -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/dbDecorators.js

@@ -0,0 +1,122 @@
+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, {
+  Database: () => Database,
+  DocumentDatabaseStorage: () => DocumentDatabaseStorage,
+  InputDatabaseStorage: () => InputDatabaseStorage,
+  MiddlewareDatabaseStorage: () => MiddlewareDatabaseStorage,
+  ModelDatabaseStorage: () => ModelDatabaseStorage,
+  beyond: () => beyond,
+  by: () => by,
+  dbOf: () => dbOf,
+  getAllDatabaseModelNames: () => getAllDatabaseModelNames,
+  inside: () => inside,
+  into: () => into
+});
+module.exports = __toCommonJS(dbDecorators_exports);
+var import_constant = require("@akanjs/constant");
+const dbOf = (refName, Input, Doc, Model2, Middleware, Obj, Insight, Filter, Summary) => {
+  return { refName, Input, Doc, Model: Model2, Middleware, 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 into = Model;
+const AddModel = (modelRef, cnst) => {
+  return modelRef;
+};
+const inside = AddModel;
+const by = (modelRef, addRef) => {
+  if (!addRef)
+    return InputOrDocument(modelRef);
+  return AddInputOrDocument(modelRef, addRef);
+};
+const InputOrDocument = (inputRef) => {
+  return inputRef;
+};
+const AddInputOrDocument = (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 beyond = (model, doc) => {
+  return class Middleware {
+    onSchema(schema) {
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Database,
+  DocumentDatabaseStorage,
+  InputDatabaseStorage,
+  MiddlewareDatabaseStorage,
+  ModelDatabaseStorage,
+  beyond,
+  by,
+  dbOf,
+  getAllDatabaseModelNames,
+  inside,
+  into
+});

package/src/index.d.ts

@@ -1 +1,5 @@
-export declare const a = 1;
+export * from "./dbDecorators";
+export * from "./schema";
+export * from "./types";
+export * from "./database";
+export * from "./dataLoader";

package/src/index.js

@@ -2,10 +2,6 @@ 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))
@@ -14,14 +10,20 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
-__export(src_exports, {
-  a: () => a
-});
 module.exports = __toCommonJS(src_exports);
-const a = 1;
+__reExport(src_exports, require("./dbDecorators"), module.exports);
+__reExport(src_exports, require("./schema"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./database"), module.exports);
+__reExport(src_exports, require("./dataLoader"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  a
+  ...require("./dbDecorators"),
+  ...require("./schema"),
+  ...require("./types"),
+  ...require("./database"),
+  ...require("./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/schema.js

@@ -0,0 +1,128 @@
+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 schema_exports = {};
+__export(schema_exports, {
+  convertAggregateMatch: () => convertAggregateMatch,
+  getDefaultSchemaOptions: () => getDefaultSchemaOptions
+});
+module.exports = __toCommonJS(schema_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_mongoose = require("mongoose");
+const getDefaultSchemaOptions = () => ({
+  toJSON: { getters: false, virtuals: true },
+  toObject: { getters: false, virtuals: true },
+  _id: true,
+  id: true,
+  timestamps: true,
+  methods: {
+    refresh: async function() {
+      Object.assign(this, await this.constructor.findById(this._id));
+      return this;
+    }
+  },
+  statics: {
+    pickOne: async function(query, projection) {
+      const doc = await this.findOne(query, projection);
+      if (!doc)
+        throw new Error("No Document");
+      return doc;
+    },
+    pickById: async function(docId, projection) {
+      if (!docId)
+        throw new Error("No Document ID");
+      const doc = await this.findById(docId, projection);
+      if (!doc)
+        throw new Error("No Document");
+      return doc;
+    },
+    sample: async function(query, size = 1, aggregations = []) {
+      const objs = await this.aggregate([
+        { $match: convertAggregateMatch(query) },
+        { $sample: { size } },
+        ...aggregations
+      ]);
+      return objs.map((obj) => new this(obj));
+    },
+    sampleOne: async function(query, aggregations = []) {
+      const obj = await this.aggregate([
+        { $match: convertAggregateMatch(query) },
+        { $sample: { size: 1 } },
+        ...aggregations
+      ]);
+      return obj.length ? new this(obj[0]) : null;
+    },
+    addSummary: async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: num }), {})
+        }
+      } : { $inc: { [`${prefix}${this.modelName}`]: num } };
+      await this.db.collection("summaries").updateOne({ status: "active" }, update);
+    },
+    moveSummary: async function(prev, next, num = 1) {
+      await this.db.collection("summaries").updateOne(
+        { status: "active" },
+        {
+          $inc: {
+            [`${prev}${this.modelName}`]: -num,
+            [`${next}${this.modelName}`]: num
+          }
+        }
+      );
+    },
+    subSummary: async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: -num }), {})
+        }
+      } : { $inc: { [`${prefix}${this.modelName}`]: -num } };
+      await this.db.collection("summaries").updateOne({ status: "active" }, update);
+    }
+  }
+});
+const convertOperatorValue = (value) => {
+  if (Array.isArray(value))
+    return value.map((v) => convertOperatorValue(v));
+  else if (!value)
+    return value;
+  else if ((0, import_mongoose.isValidObjectId)(value))
+    return new import_mongoose.Types.ObjectId(value);
+  else if ((0, import_common.isValidDate)(value))
+    return (0, import_base.dayjs)(value).toDate();
+  else if (value.constructor !== Object)
+    return value;
+  else if (typeof value !== "object")
+    return value;
+  else
+    return Object.fromEntries(
+      Object.entries(value).map(([key, value2]) => [key, convertOperatorValue(value2)])
+    );
+};
+const convertAggregateMatch = (query) => {
+  return Object.fromEntries(
+    Object.entries(query).map(([key, value]) => {
+      return [key, convertOperatorValue(value)];
+    })
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  convertAggregateMatch,
+  getDefaultSchemaOptions
+});

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>;

package/src/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 types_exports = {};
+module.exports = __toCommonJS(types_exports);