@akanjs/document 0.9.48 → 0.9.49

package/cjs/src/database.js

@@ -23,8 +23,8 @@ 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_filterMeta = require("./filterMeta");
 var import_schema = require("./schema");
 class CacheDatabase {
   constructor(refName, redis) {
@@ -85,20 +85,21 @@ class SearchDatabase {
   }
 }
 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 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 sort = (0, import_filterMeta.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;
@@ -107,14 +108,14 @@ const databaseModelOf = (database, model, redis, meili) => {
   };
   const getFindQuery = (query, queryOption) => {
     const find = makeSafeQuery(query);
-    const sort = (0, import_constant.getFilterSort)(database.Filter, queryOption?.sort ?? "latest");
+    const sort = (0, import_filterMeta.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");
+    const sort = (0, import_filterMeta.getFilterSort)(database.Filter, sortKey ?? "latest");
     return Object.entries(sort).map(([key, value]) => `${key}:${value === 1 ? "asc" : "desc"}`);
   };
   const loader = (0, import_dataLoader.createLoader)(model);
@@ -232,15 +233,15 @@ const databaseModelOf = (database, model, redis, meili) => {
   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 queryFn = (0, import_filterMeta.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 filterKeyMetaMap = (0, import_filterMeta.getFilterKeyMetaMapOnPrototype)(database.Filter.prototype);
   const queryKeys = [...filterKeyMetaMap.keys()];
   queryKeys.forEach((queryKey) => {
-    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
+    const queryFn = (0, import_filterMeta.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);
@@ -277,6 +278,9 @@ const databaseModelOf = (database, model, redis, meili) => {
       const query = queryFn(...args);
       return this.__insight(query);
     };
+    DatabaseModel.prototype[`query${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      return queryFn(...args);
+    };
   });
   const loaderMetas = (0, import_dataLoader.getLoaderMetas)(database.Model);
   loaderMetas.forEach((loaderMeta) => {
@@ -286,15 +290,6 @@ const databaseModelOf = (database, model, redis, meili) => {
   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();
 };

package/cjs/src/dbDecorators.js

@@ -17,65 +17,13 @@ var __copyProps = (to, from, except, desc) => {
 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,
   into: () => into
 });
 module.exports = __toCommonJS(dbDecorators_exports);
 var import_constant = require("@akanjs/constant");
-const dbOf = (refName, Input, Doc, Model2, Middleware, Obj, Insight, Filter) => {
-  return { refName, Input, Doc, Model: Model2, Middleware, Obj, Insight, Filter };
-};
-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, ...addMdls) => {
+const Model = (docRef, filterRef, cnst, ...addMdls) => {
   class DefaultModel {
   }
   return DefaultModel;
@@ -101,14 +49,7 @@ const beyond = (model, doc) => {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  Database,
-  DocumentDatabaseStorage,
-  InputDatabaseStorage,
-  MiddlewareDatabaseStorage,
-  ModelDatabaseStorage,
   beyond,
   by,
-  dbOf,
-  getAllDatabaseModelNames,
   into
 });

package/cjs/src/documentInfo.js

@@ -0,0 +1,105 @@
+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 documentInfo_exports = {};
+__export(documentInfo_exports, {
+  dbOf: () => dbOf,
+  documentInfo: () => documentInfo,
+  scalarDbOf: () => scalarDbOf
+});
+module.exports = __toCommonJS(documentInfo_exports);
+const documentInfo = {
+  database: /* @__PURE__ */ new Map(),
+  scalar: /* @__PURE__ */ new Map(),
+  modelSets: {
+    input: /* @__PURE__ */ new Set(),
+    doc: /* @__PURE__ */ new Set(),
+    model: /* @__PURE__ */ new Set(),
+    filter: /* @__PURE__ */ new Set(),
+    middleware: /* @__PURE__ */ new Set(),
+    scalar: /* @__PURE__ */ new Set()
+  },
+  modelRefNameMap: /* @__PURE__ */ new Map(),
+  getRefName(modelRef, { allowEmpty } = {}) {
+    const refName = documentInfo.modelRefNameMap.get(modelRef);
+    if (!refName && !allowEmpty)
+      throw new Error(`No ref name for modelRef: ${modelRef}`);
+    return refName;
+  },
+  isInput(modelRef) {
+    return documentInfo.modelSets.input.has(modelRef);
+  },
+  isDoc(modelRef) {
+    return documentInfo.modelSets.doc.has(modelRef);
+  },
+  isModel(modelRef) {
+    return documentInfo.modelSets.model.has(modelRef);
+  },
+  isMiddleware(modelRef) {
+    return documentInfo.modelSets.middleware.has(modelRef);
+  },
+  isScalar(modelRef) {
+    return documentInfo.modelSets.scalar.has(modelRef);
+  },
+  setDatabase(refName, { Input, Doc, Model, Middleware, Filter }) {
+    if (!documentInfo.database.has(refName))
+      documentInfo.database.set(refName, {
+        input: Input,
+        doc: Doc,
+        model: Model,
+        middleware: Middleware,
+        filter: Filter
+      });
+    [Input, Doc, Model, Middleware].forEach((modelRef) => {
+      documentInfo.modelRefNameMap.set(modelRef, refName);
+    });
+  },
+  getDatabase(refName, { allowEmpty } = {}) {
+    const info = documentInfo.database.get(refName);
+    if (!info && !allowEmpty)
+      throw new Error(`No database document model info for ${refName}`);
+    return info;
+  },
+  setScalar(refName, Model) {
+    if (documentInfo.scalar.has(refName))
+      return;
+    documentInfo.scalar.set(refName, Model);
+    documentInfo.modelRefNameMap.set(Model, refName);
+  },
+  getScalar(refName, { allowEmpty } = {}) {
+    const model = documentInfo.scalar.get(refName);
+    if (!model && !allowEmpty)
+      throw new Error(`No scalar model for ${refName}`);
+    return model;
+  }
+};
+const dbOf = (refName, Input, Doc, Model, Middleware, Obj, Insight, Filter) => {
+  const dbInfo = { refName, Input, Doc, Model, Middleware, Obj, Insight, Filter };
+  documentInfo.setDatabase(refName, dbInfo);
+  return dbInfo;
+};
+const scalarDbOf = (refName, Model) => {
+  const scalarInfo = { refName, Model };
+  documentInfo.setScalar(refName, Model);
+  return scalarInfo;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dbOf,
+  documentInfo,
+  scalarDbOf
+});

package/cjs/src/filterMeta.js

@@ -0,0 +1,182 @@
+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, from2, except, desc) => {
+  if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+    for (let key of __getOwnPropNames(from2))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from2[key], enumerable: !(desc = __getOwnPropDesc(from2, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var filterMeta_exports = {};
+__export(filterMeta_exports, {
+  FilterInfo: () => FilterInfo,
+  filter: () => filter,
+  from: () => from,
+  getFilterArgMetas: () => getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype: () => getFilterKeyMetaMapOnPrototype,
+  getFilterMeta: () => getFilterMeta,
+  getFilterQuery: () => getFilterQuery,
+  getFilterQueryMap: () => getFilterQueryMap,
+  getFilterSort: () => getFilterSort,
+  getFilterSortMap: () => getFilterSortMap,
+  isFilterModel: () => isFilterModel,
+  setFilterArgMetasOnPrototype: () => setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype: () => setFilterKeyMetaMapOnPrototype,
+  setFilterMeta: () => setFilterMeta
+});
+module.exports = __toCommonJS(filterMeta_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+const isFilterModel = (filterRef) => {
+  return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
+};
+const getFilterMeta = (filterRef) => {
+  const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+  if (!filterMeta)
+    throw new Error("filterMeta is not defined");
+  return filterMeta;
+};
+const setFilterMeta = (filterRef, filterMeta) => {
+  const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+  if (existingFilterMeta)
+    Object.assign(existingFilterMeta, { ...filterMeta, sort: { ...existingFilterMeta.sort, ...filterMeta.sort } });
+  else
+    Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+};
+const getFilterKeyMetaMapOnPrototype = (prototype) => {
+  const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+};
+const setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
+  Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
+};
+const getFilterArgMetasOnPrototype = (prototype, key) => {
+  const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
+  return filterArgMetas;
+};
+const setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
+  Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
+};
+const getFilterArgMetas = (filterRef, key) => {
+  const filterArgMetas = getFilterArgMetasOnPrototype(filterRef.prototype, key);
+  return filterArgMetas;
+};
+const getFilterQuery = (filterRef, key) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+  const filterKeyMeta = filterKeyMetaMap.get(key);
+  if (!filterKeyMeta?.descriptor.value)
+    throw new Error(`filterKeyMeta is not defined for key: ${key}`);
+  return filterKeyMeta.descriptor.value;
+};
+const getFilterQueryMap = (filterRef) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+  return filterKeyMetaMap;
+};
+const getFilterSort = (filterRef, key) => {
+  const filterMeta = getFilterMeta(filterRef);
+  const sort = filterMeta.sort[key];
+  return sort;
+};
+const getFilterSortMap = (filterRef) => {
+  const filterMeta = getFilterMeta(filterRef);
+  return filterMeta.sort;
+};
+const from = (modelRef, filterSort, ...libFilterRefs) => {
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(modelRef);
+  const statusFieldMeta = fieldMetaMap.get("status");
+  if (!statusFieldMeta)
+    throw new Error(`No status field meta fount in ${modelRef.name}`);
+  class Base {
+  }
+  const querySort = filterSort(filter);
+  Object.assign(Base.prototype, { latest: { createdAt: -1 }, oldest: { createdAt: 1 }, ...querySort.sort });
+  Object.entries({
+    byStatuses: filter().opt("statuses", [statusFieldMeta.enum]).query((statuses) => statuses?.length ? { status: { $in: statuses } } : {}),
+    any: filter().query(() => ({ removedAt: { $exists: false } })),
+    ...querySort.query
+  }).forEach(([key, filterInfo]) => {
+    filterInfo.applyFilterMeta(Base, key);
+  });
+  setFilterMeta(Base, {
+    refName: "Base",
+    sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, querySort.sort)
+  });
+  (0, import_common.applyMixins)(Base, libFilterRefs);
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(Base.prototype);
+  libFilterRefs.forEach((libFilterRef) => {
+    const libFilterKeyMetaMap = getFilterKeyMetaMapOnPrototype(libFilterRef.prototype);
+    libFilterKeyMetaMap.forEach((value, key) => {
+      const libFilterArgMetas = getFilterArgMetas(libFilterRef, key);
+      filterKeyMetaMap.set(key, value);
+      setFilterArgMetasOnPrototype(Base.prototype, key, libFilterArgMetas);
+    });
+  });
+  return Base;
+};
+class FilterInfo {
+  args;
+  queryFn = null;
+  constructor() {
+    this.args = [];
+  }
+  arg(name, argRef, option) {
+    if (this.queryFn)
+      throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable)
+      throw new Error("Last argument is nullable");
+    this.args.push({ name, argRef, option });
+    return this;
+  }
+  opt(name, argRef, option) {
+    if (this.queryFn)
+      throw new Error("Query function is already set");
+    this.args.push({ name, argRef, option: { ...option, nullable: true } });
+    return this;
+  }
+  query(query) {
+    if (this.queryFn)
+      throw new Error("Query function is already set");
+    this.queryFn = query;
+    return this;
+  }
+  applyFilterMeta(filterRef, key) {
+    const metadata = { key, type: "mongo", descriptor: { value: this.queryFn } };
+    const metadataMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+    metadataMap.set(key, metadata);
+    filterRef.prototype[key] = this.queryFn;
+    setFilterKeyMetaMapOnPrototype(filterRef.prototype, metadataMap);
+    const filterArgMetas = this.args.map((argInfo) => {
+      const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(argInfo.argRef);
+      const [opt, optArrDepth] = (0, import_base.getNonArrayModel)(argInfo.option ?? {});
+      return { name: argInfo.name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
+    });
+    setFilterArgMetasOnPrototype(filterRef.prototype, key, filterArgMetas);
+  }
+}
+const filter = () => new FilterInfo();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FilterInfo,
+  filter,
+  from,
+  getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype,
+  getFilterMeta,
+  getFilterQuery,
+  getFilterQueryMap,
+  getFilterSort,
+  getFilterSortMap,
+  isFilterModel,
+  setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype,
+  setFilterMeta
+});

package/cjs/src/index.js

@@ -19,11 +19,15 @@ __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);
+__reExport(src_exports, require("./documentInfo"), module.exports);
+__reExport(src_exports, require("./filterMeta"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./dbDecorators"),
   ...require("./schema"),
   ...require("./types"),
   ...require("./database"),
-  ...require("./dataLoader")
+  ...require("./dataLoader"),
+  ...require("./documentInfo"),
+  ...require("./filterMeta")
 });

package/esm/src/database.js

@@ -1,14 +1,8 @@
 import { dayjs } from "@akanjs/base";
 import { capitalize, Logger, lowerlize } from "@akanjs/common";
-import {
-  DEFAULT_PAGE_SIZE,
-  getFieldMetas,
-  getFilterKeyMetaMapOnPrototype,
-  getFilterQuery,
-  getFilterSort
-} from "@akanjs/constant";
-import { Transaction } from "@akanjs/nest";
+import { DEFAULT_PAGE_SIZE, getFieldMetas } from "@akanjs/constant";
 import { createArrayLoader, createLoader, createQueryLoader, getLoaderMetas } from "./dataLoader";
+import { getFilterKeyMetaMapOnPrototype, getFilterQuery, getFilterSort } from "./filterMeta";
 import { convertAggregateMatch } from "./schema";
 class CacheDatabase {
   constructor(refName, redis) {
@@ -69,13 +63,14 @@ class SearchDatabase {
   }
 }
 class DatabaseModelStorage {
-  __ModelType__ = "DatabaseModelStorage";
 }
 const databaseModelOf = (database, model, redis, meili) => {
   const [modelName, className] = [database.refName, capitalize(database.refName)];
   const insightFieldMetas = 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 defaultInsight = Object.fromEntries(
+    insightFieldMetas.map((fieldMeta) => [fieldMeta.key, fieldMeta.default])
+  );
   const makeSafeQuery = (query) => ({ removedAt: { $exists: false }, ...query ?? {} });
   const makeSafeMatchStage = (query) => ({
     $match: { removedAt: { $exists: false }, ...convertAggregateMatch(query) }
@@ -261,6 +256,9 @@ const databaseModelOf = (database, model, redis, meili) => {
       const query = queryFn(...args);
       return this.__insight(query);
     };
+    DatabaseModel.prototype[`query${capitalize(queryKey)}`] = async function(...args) {
+      return queryFn(...args);
+    };
   });
   const loaderMetas = getLoaderMetas(database.Model);
   loaderMetas.forEach((loaderMeta) => {
@@ -270,15 +268,6 @@ const databaseModelOf = (database, model, redis, meili) => {
   Object.getOwnPropertyNames(database.Model.prototype).forEach((key) => {
     DatabaseModel.prototype[key] = database.Model.prototype[key];
   });
-  const createDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `create${className}`);
-  if (createDescriptor)
-    Transaction()(DatabaseModel.prototype, `create${className}`, createDescriptor);
-  const updateDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `update${className}`);
-  if (updateDescriptor)
-    Transaction()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
-  const removeDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `remove${className}`);
-  if (removeDescriptor)
-    Transaction()(DatabaseModel.prototype, `remove${className}`, removeDescriptor);
   Reflect.defineMetadata(database.refName, DatabaseModel, DatabaseModelStorage.prototype);
   return new DatabaseModel();
 };

package/esm/src/dbDecorators.js

@@ -1,54 +1,5 @@
-import {
-  getClassMeta,
-  getFieldMetaMap,
-  setFieldMetaMap
-} from "@akanjs/constant";
-const dbOf = (refName, Input, Doc, Model2, Middleware, Obj, Insight, Filter) => {
-  return { refName, Input, Doc, Model: Model2, Middleware, Obj, Insight, Filter };
-};
-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 = getClassMeta(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, InputDatabaseStorage.prototype);
-    };
-  },
-  Document: (returns) => {
-    return function(target) {
-      const modelRef = returns();
-      const classMeta = getClassMeta(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, DocumentDatabaseStorage.prototype);
-    };
-  },
-  Model: (returns) => {
-    return function(target) {
-      const modelRef = returns();
-      const classMeta = getClassMeta(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, ModelDatabaseStorage.prototype);
-    };
-  },
-  Middleware: (returns) => {
-    return function(target) {
-      const modelRef = returns();
-      const classMeta = getClassMeta(modelRef);
-      Reflect.defineMetadata(classMeta.refName, target, MiddlewareDatabaseStorage.prototype);
-    };
-  }
-};
-const Model = (docRef, cnst, ...addMdls) => {
+import { getFieldMetaMap, setFieldMetaMap } from "@akanjs/constant";
+const Model = (docRef, filterRef, cnst, ...addMdls) => {
   class DefaultModel {
   }
   return DefaultModel;
@@ -73,14 +24,7 @@ const beyond = (model, doc) => {
   };
 };
 export {
-  Database,
-  DocumentDatabaseStorage,
-  InputDatabaseStorage,
-  MiddlewareDatabaseStorage,
-  ModelDatabaseStorage,
   beyond,
   by,
-  dbOf,
-  getAllDatabaseModelNames,
   into
 };

package/esm/src/documentInfo.js

@@ -0,0 +1,80 @@
+const documentInfo = {
+  database: /* @__PURE__ */ new Map(),
+  scalar: /* @__PURE__ */ new Map(),
+  modelSets: {
+    input: /* @__PURE__ */ new Set(),
+    doc: /* @__PURE__ */ new Set(),
+    model: /* @__PURE__ */ new Set(),
+    filter: /* @__PURE__ */ new Set(),
+    middleware: /* @__PURE__ */ new Set(),
+    scalar: /* @__PURE__ */ new Set()
+  },
+  modelRefNameMap: /* @__PURE__ */ new Map(),
+  getRefName(modelRef, { allowEmpty } = {}) {
+    const refName = documentInfo.modelRefNameMap.get(modelRef);
+    if (!refName && !allowEmpty)
+      throw new Error(`No ref name for modelRef: ${modelRef}`);
+    return refName;
+  },
+  isInput(modelRef) {
+    return documentInfo.modelSets.input.has(modelRef);
+  },
+  isDoc(modelRef) {
+    return documentInfo.modelSets.doc.has(modelRef);
+  },
+  isModel(modelRef) {
+    return documentInfo.modelSets.model.has(modelRef);
+  },
+  isMiddleware(modelRef) {
+    return documentInfo.modelSets.middleware.has(modelRef);
+  },
+  isScalar(modelRef) {
+    return documentInfo.modelSets.scalar.has(modelRef);
+  },
+  setDatabase(refName, { Input, Doc, Model, Middleware, Filter }) {
+    if (!documentInfo.database.has(refName))
+      documentInfo.database.set(refName, {
+        input: Input,
+        doc: Doc,
+        model: Model,
+        middleware: Middleware,
+        filter: Filter
+      });
+    [Input, Doc, Model, Middleware].forEach((modelRef) => {
+      documentInfo.modelRefNameMap.set(modelRef, refName);
+    });
+  },
+  getDatabase(refName, { allowEmpty } = {}) {
+    const info = documentInfo.database.get(refName);
+    if (!info && !allowEmpty)
+      throw new Error(`No database document model info for ${refName}`);
+    return info;
+  },
+  setScalar(refName, Model) {
+    if (documentInfo.scalar.has(refName))
+      return;
+    documentInfo.scalar.set(refName, Model);
+    documentInfo.modelRefNameMap.set(Model, refName);
+  },
+  getScalar(refName, { allowEmpty } = {}) {
+    const model = documentInfo.scalar.get(refName);
+    if (!model && !allowEmpty)
+      throw new Error(`No scalar model for ${refName}`);
+    return model;
+  }
+};
+const dbOf = (refName, Input, Doc, Model, Middleware, Obj, Insight, Filter) => {
+  const dbInfo = { refName, Input, Doc, Model, Middleware, Obj, Insight, Filter };
+  documentInfo.setDatabase(refName, dbInfo);
+  return dbInfo;
+};
+const scalarDbOf = (refName, Model) => {
+  const scalarInfo = { refName, Model };
+  documentInfo.setScalar(refName, Model);
+  return scalarInfo;
+};
+export {
+  dbOf,
+  documentInfo,
+  scalarDbOf
+};

package/esm/src/filterMeta.js

@@ -0,0 +1,148 @@
+import {
+  getNonArrayModel
+} from "@akanjs/base";
+import { applyMixins } from "@akanjs/common";
+import { getFieldMetaMap } from "@akanjs/constant";
+const isFilterModel = (filterRef) => {
+  return Reflect.getMetadata("filter", filterRef.prototype) !== void 0;
+};
+const getFilterMeta = (filterRef) => {
+  const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+  if (!filterMeta)
+    throw new Error("filterMeta is not defined");
+  return filterMeta;
+};
+const setFilterMeta = (filterRef, filterMeta) => {
+  const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+  if (existingFilterMeta)
+    Object.assign(existingFilterMeta, { ...filterMeta, sort: { ...existingFilterMeta.sort, ...filterMeta.sort } });
+  else
+    Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+};
+const getFilterKeyMetaMapOnPrototype = (prototype) => {
+  const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
+  return new Map(metadataMap);
+};
+const setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
+  Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
+};
+const getFilterArgMetasOnPrototype = (prototype, key) => {
+  const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
+  return filterArgMetas;
+};
+const setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
+  Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
+};
+const getFilterArgMetas = (filterRef, key) => {
+  const filterArgMetas = getFilterArgMetasOnPrototype(filterRef.prototype, key);
+  return filterArgMetas;
+};
+const getFilterQuery = (filterRef, key) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+  const filterKeyMeta = filterKeyMetaMap.get(key);
+  if (!filterKeyMeta?.descriptor.value)
+    throw new Error(`filterKeyMeta is not defined for key: ${key}`);
+  return filterKeyMeta.descriptor.value;
+};
+const getFilterQueryMap = (filterRef) => {
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+  return filterKeyMetaMap;
+};
+const getFilterSort = (filterRef, key) => {
+  const filterMeta = getFilterMeta(filterRef);
+  const sort = filterMeta.sort[key];
+  return sort;
+};
+const getFilterSortMap = (filterRef) => {
+  const filterMeta = getFilterMeta(filterRef);
+  return filterMeta.sort;
+};
+const from = (modelRef, filterSort, ...libFilterRefs) => {
+  const fieldMetaMap = getFieldMetaMap(modelRef);
+  const statusFieldMeta = fieldMetaMap.get("status");
+  if (!statusFieldMeta)
+    throw new Error(`No status field meta fount in ${modelRef.name}`);
+  class Base {
+  }
+  const querySort = filterSort(filter);
+  Object.assign(Base.prototype, { latest: { createdAt: -1 }, oldest: { createdAt: 1 }, ...querySort.sort });
+  Object.entries({
+    byStatuses: filter().opt("statuses", [statusFieldMeta.enum]).query((statuses) => statuses?.length ? { status: { $in: statuses } } : {}),
+    any: filter().query(() => ({ removedAt: { $exists: false } })),
+    ...querySort.query
+  }).forEach(([key, filterInfo]) => {
+    filterInfo.applyFilterMeta(Base, key);
+  });
+  setFilterMeta(Base, {
+    refName: "Base",
+    sort: Object.assign({ latest: { createdAt: -1 }, oldest: { createdAt: 1 } }, querySort.sort)
+  });
+  applyMixins(Base, libFilterRefs);
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(Base.prototype);
+  libFilterRefs.forEach((libFilterRef) => {
+    const libFilterKeyMetaMap = getFilterKeyMetaMapOnPrototype(libFilterRef.prototype);
+    libFilterKeyMetaMap.forEach((value, key) => {
+      const libFilterArgMetas = getFilterArgMetas(libFilterRef, key);
+      filterKeyMetaMap.set(key, value);
+      setFilterArgMetasOnPrototype(Base.prototype, key, libFilterArgMetas);
+    });
+  });
+  return Base;
+};
+class FilterInfo {
+  args;
+  queryFn = null;
+  constructor() {
+    this.args = [];
+  }
+  arg(name, argRef, option) {
+    if (this.queryFn)
+      throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable)
+      throw new Error("Last argument is nullable");
+    this.args.push({ name, argRef, option });
+    return this;
+  }
+  opt(name, argRef, option) {
+    if (this.queryFn)
+      throw new Error("Query function is already set");
+    this.args.push({ name, argRef, option: { ...option, nullable: true } });
+    return this;
+  }
+  query(query) {
+    if (this.queryFn)
+      throw new Error("Query function is already set");
+    this.queryFn = query;
+    return this;
+  }
+  applyFilterMeta(filterRef, key) {
+    const metadata = { key, type: "mongo", descriptor: { value: this.queryFn } };
+    const metadataMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+    metadataMap.set(key, metadata);
+    filterRef.prototype[key] = this.queryFn;
+    setFilterKeyMetaMapOnPrototype(filterRef.prototype, metadataMap);
+    const filterArgMetas = this.args.map((argInfo) => {
+      const [modelRef, arrDepth] = getNonArrayModel(argInfo.argRef);
+      const [opt, optArrDepth] = getNonArrayModel(argInfo.option ?? {});
+      return { name: argInfo.name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
+    });
+    setFilterArgMetasOnPrototype(filterRef.prototype, key, filterArgMetas);
+  }
+}
+const filter = () => new FilterInfo();
+export {
+  FilterInfo,
+  filter,
+  from,
+  getFilterArgMetas,
+  getFilterKeyMetaMapOnPrototype,
+  getFilterMeta,
+  getFilterQuery,
+  getFilterQueryMap,
+  getFilterSort,
+  getFilterSortMap,
+  isFilterModel,
+  setFilterArgMetasOnPrototype,
+  setFilterKeyMetaMapOnPrototype,
+  setFilterMeta
+};

package/esm/src/index.js

@@ -3,3 +3,5 @@ export * from "./schema";
 export * from "./types";
 export * from "./database";
 export * from "./dataLoader";
+export * from "./documentInfo";
+export * from "./filterMeta";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/document",
-  "version": "0.9.48",
+  "version": "0.9.49",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"

package/src/database.d.ts

@@ -1,13 +1,14 @@
 import type { Dayjs, GetActionObject, MergedValues, PromiseOrObject } from "@akanjs/base";
 import { Logger } from "@akanjs/common";
-import { type DocumentModel, type FilterType, type FindQueryOption, type ListQueryOption, type QueryOf, type SortOf } from "@akanjs/constant";
+import { type DocumentModel, type QueryOf } 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, CRUDEventType, Database, Mdl, SaveEventType } from "./dbDecorators";
-import type { DataInputOf } from "./types";
-interface RedisSetOptions {
+import type { BaseMiddleware, CRUDEventType, Mdl, SaveEventType } from "./dbDecorators";
+import type { Database } from "./documentInfo";
+import type { DataInputOf, FilterType, FindQueryOption, ListQueryOption, SortOf } from "./types";
+export interface RedisSetOptions {
     expireAt?: Dayjs;
 }
 declare class CacheDatabase<T = any> {
@@ -41,7 +42,7 @@ declare class SearchDatabase<T = any> {
         sort?: string | null;
     }): Promise<number>;
 }
-type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends any[], _ListArgs extends any[], _FindArgs extends any[]> = {
+type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends any[], _ListArgs extends any[], _FindArgs extends any[], _QueryOfDoc = QueryOf<Doc>> = {
     [K in `list${CapitalizedK}`]: (...args: _ListArgs) => Promise<Doc[]>;
 } & {
     [K in `listIds${CapitalizedK}`]: (...args: _ListArgs) => Promise<string[]>;
@@ -59,8 +60,10 @@ type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends a
     [K in `count${CapitalizedK}`]: (...args: _Args) => Promise<number>;
 } & {
     [K in `insight${CapitalizedK}`]: (...args: _Args) => Promise<Insight>;
+} & {
+    [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
 };
-export type QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption = FindQueryOption<Sort, Obj>, _ListQueryOption = ListQueryOption<Sort, Obj>> = MergedValues<{
+export type QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption = FindQueryOption<Sort, Obj>, _ListQueryOption = ListQueryOption<Sort, Obj>, _QueryOfDoc = QueryOf<Doc>> = MergedValues<{
     [K in keyof Query]: K extends string ? Query[K] extends (...args: infer Args) => any ? QueryMethodOfKey<Capitalize<K>, Doc, Insight, Args, [
         ...Args,
         queryOption?: _ListQueryOption
@@ -115,7 +118,7 @@ type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Quer
     [K in `searchDocs${_CapitalizedT}`]: (searchText: string, queryOption?: _ListQueryOption) => Promise<Doc[]>;
 } & {
     [K in `searchCount${_CapitalizedT}`]: (searchText: string) => Promise<number>;
-} & QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption>;
+} & QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>;
 export type DatabaseModel<T extends string, Input, Doc, Obj, Insight, Filter, _CapitalizedT extends string = Capitalize<T>, _QueryOfDoc = QueryOf<Doc>, _Query = GetActionObject<Filter>, _Sort = SortOf<Filter>, _DataInput = DataInputOf<Input, DocumentModel<Obj>>, _FindQueryOption = FindQueryOption<_Sort, Obj>, _ListQueryOption = ListQueryOption<_Sort, Obj>> = DatabaseModelWithQuerySort<T, Input, Doc, Obj, Insight, _Query, _Sort, _CapitalizedT, _QueryOfDoc, _DataInput, _FindQueryOption, _ListQueryOption>;
 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>(database: Database<T, Input, Doc, Model, Middleware, Insight, Obj, Filter>, model: Mdl<any, any>, redis: RedisClientType, meili: MeiliSearch) => DatabaseModel<T, Input, Doc, Model, Insight, Filter>;
 export {};

package/src/dbDecorators.d.ts

@@ -1,9 +1,9 @@
-import { BaseObject, type MergeAllActionTypes, PromiseOrObject, Type } from "@akanjs/base";
-import { type ConstantModel, type DocumentModel, type FilterType } from "@akanjs/constant";
+import { BaseObject, GetActionObject, type MergeAllActionTypes, PromiseOrObject, Type } from "@akanjs/base";
+import { type ConstantModel, type DocumentModel } 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> {
+export interface DefaultDocMtds<TDocument> {
     refresh(): Promise<this>;
     set(data: Partial<TDocument>): this;
     save(): Promise<this>;
@@ -37,33 +37,7 @@ 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> {
-    refName: T;
-    Input: Type<Input>;
-    Doc: Type<Doc>;
-    Model: Type<Model>;
-    Middleware: Type<Middleware>;
-    Obj: Type<Obj>;
-    Insight: Type<Insight>;
-    Filter: Type<Filter>;
-}
-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>(refName: T, Input: Type<Input>, Doc: Type<Doc>, Model: Type<Model>, Middleware: Type<Middleware>, Obj: Type<Obj>, Insight: Type<Insight>, Filter: Type<Filter>) => Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter>;
-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, Filter extends FilterType, _CapitalizedT extends string, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _Doc, _DocInput, _QueryOfDoc, _Query, _Sort, AddDbModels extends Type[], _DatabaseModel = DatabaseModel<T, _DocInput, Doc, Full, Insight, Filter, _CapitalizedT, _QueryOfDoc, _Query, _Sort>>(docRef: Type<Doc>, cnst: ConstantModel<T, Input, Full, Light, Insight, Filter, _CapitalizedT, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _Doc, _DocInput, _QueryOfDoc, _Query, _Sort>, ...addMdls: AddDbModels) => Type<MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel>;
+export declare const into: <Doc, Filter, T extends string, Input, Full, Light, Insight, AddDbModels extends Type[], _CapitalizedT extends string, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc, _Query = GetActionObject<Filter>, _Sort = keyof import("@akanjs/base").GetStateObject<Filter>, _DatabaseModel = DatabaseModel<T, _DocInput, Doc, Full, Insight, Filter, _CapitalizedT, _QueryOfDoc, _Query, _Sort>>(docRef: Type<Doc>, filterRef: Type<Filter>, cnst: ConstantModel<T, Input, Full, Light, Insight, _CapitalizedT, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc>, ...addMdls: AddDbModels) => Type<MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel>;
 export declare const by: <Model, AddDbModels extends Type[], _DocModel = Model extends BaseObject ? Doc<Model> : DocumentModel<Model>>(modelRef: Type<Model>, ...addRefs: AddDbModels) => Type<MergeAllActionTypes<AddDbModels, keyof _DocModel & string> & _DocModel>;
 export declare const beyond: <DbModel, Doc>(model: Type<DbModel>, doc: Type<Doc>) => {
     new (): {

package/src/documentInfo.d.ts

@@ -0,0 +1,56 @@
+import type { Type } from "@akanjs/base";
+import type { HydratedDocument } from "mongoose";
+import type { DatabaseModel } from "./database";
+import type { BaseMiddleware } from "./dbDecorators";
+import { FilterType } from "./types";
+export interface DatabaseDocumentModelInfo {
+    input: Type;
+    doc: Type;
+    model: Type;
+    filter: Type;
+    middleware: Type;
+}
+export declare const documentInfo: {
+    database: Map<string, DatabaseDocumentModelInfo>;
+    scalar: Map<string, Type>;
+    modelSets: {
+        input: Set<Type>;
+        doc: Set<Type>;
+        model: Set<Type>;
+        filter: Set<Type>;
+        middleware: Set<Type>;
+        scalar: Set<Type>;
+    };
+    modelRefNameMap: Map<Type, string>;
+    getRefName<AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? string | undefined : string;
+    isInput(modelRef: Type): boolean;
+    isDoc(modelRef: Type): boolean;
+    isModel(modelRef: Type): boolean;
+    isMiddleware(modelRef: Type): boolean;
+    isScalar(modelRef: Type): boolean;
+    setDatabase(refName: string, { Input, Doc, Model, Middleware, Filter }: Database<any, any, any, any, any, any, any, any>): void;
+    getDatabase<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? DatabaseDocumentModelInfo | undefined : DatabaseDocumentModelInfo;
+    setScalar(refName: string, Model: Type): void;
+    getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? Type | undefined : Type;
+};
+export interface Database<T extends string, Input, Doc extends HydratedDocument<any>, Model, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType> {
+    refName: T;
+    Input: Type<Input>;
+    Doc: Type<Doc>;
+    Model: Type<Model>;
+    Middleware: Type<Middleware>;
+    Obj: Type<Obj>;
+    Insight: Type<Insight>;
+    Filter: Type<Filter>;
+}
+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>(refName: T, Input: Type<Input>, Doc: Type<Doc>, Model: Type<Model>, Middleware: Type<Middleware>, Obj: Type<Obj>, Insight: Type<Insight>, Filter: Type<Filter>) => Database<T, Input, Doc, Model, Middleware, Obj, Insight, Filter>;
+export declare const scalarDbOf: <T extends string, Model>(refName: T, Model: Type<Model>) => {
+    refName: T;
+    Model: Type<Model>;
+};

package/src/filterMeta.d.ts

@@ -0,0 +1,71 @@
+import { type BaseObject, type MergeAllTypes, type Prettify, type Type } from "@akanjs/base";
+import { ConstantFieldTypeInput, FieldToValue, PlainTypeToFieldType, QueryOf } from "@akanjs/constant";
+import type { ConstantFilterMeta, FilterArgMeta, FilterKeyMeta, SortType } from "./types";
+export declare const isFilterModel: (filterRef: Type) => boolean;
+export declare const getFilterMeta: (filterRef: Type) => ConstantFilterMeta;
+export declare const setFilterMeta: (filterRef: Type, filterMeta: ConstantFilterMeta) => void;
+export declare const getFilterKeyMetaMapOnPrototype: (prototype: object) => Map<string, FilterKeyMeta>;
+export declare const setFilterKeyMetaMapOnPrototype: (prototype: object, metadataMap: Map<string, FilterKeyMeta>) => void;
+export declare const setFilterArgMetasOnPrototype: (prototype: object, key: string, filterArgMetas: FilterArgMeta[]) => void;
+export declare const getFilterArgMetas: (filterRef: Type, key: string) => FilterArgMeta[];
+export declare const getFilterQuery: (filterRef: Type, key: string) => (...args: any[]) => QueryOf<any>;
+export declare const getFilterQueryMap: (filterRef: Type) => Map<string, FilterKeyMeta>;
+export declare const getFilterSort: (filterRef: Type, key: string) => Partial<{
+    [x: string]: number;
+}>;
+export declare const getFilterSortMap: (filterRef: Type) => SortType<{
+    [key: string]: any;
+}>;
+export type BaseFilterKey = "latest" | "oldest" | "any" | "byStatuses";
+interface BaseFilter<Status extends string = string> {
+    latest: {
+        createdAt: -1;
+    };
+    oldest: {
+        createdAt: 1;
+    };
+    any: () => {
+        removedAt: {
+            $exists: false;
+        };
+    };
+    byStatuses: (statuses?: Status[] | null) => {
+        status: {
+            $in: Status[];
+        };
+    };
+}
+type ExtractQuery<Query extends {
+    [key: string]: FilterInfo<any[]>;
+}> = {
+    [K in keyof Query]: Query[K] extends FilterInfo<infer Args> ? (...args: Args) => QueryOf<any> : never;
+};
+export declare const from: <Full extends BaseObject, FilterSort extends {
+    query: {
+        [key: string]: FilterInfo<any[]>;
+    };
+    sort: SortType<Full>;
+}, LibFilters extends Type[]>(modelRef: Type<Full>, filterSort: (filter: () => FilterInfo<[], Full>) => FilterSort, ...libFilterRefs: LibFilters) => Type<Prettify<MergeAllTypes<LibFilters> & BaseFilter<Full extends {
+    status: infer Status;
+} ? Status : string> & ExtractQuery<FilterSort["query"]> & FilterSort["sort"]>>;
+interface ArgProps<Value = any> {
+    nullable?: boolean;
+    ref?: string;
+    default?: Value;
+    renderOption?: (arg: any) => string;
+}
+export declare class FilterInfo<Args extends any[] = [], Model = any> {
+    readonly args: {
+        name: string;
+        argRef: any;
+        option?: ArgProps;
+    }[];
+    queryFn: ((...args: Args) => QueryOf<any>) | null;
+    constructor();
+    arg<ExplicitType, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _FieldToValue = FieldToValue<Arg>>(name: string, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">): FilterInfo<[...Args, arg: _FieldToValue], Model>;
+    opt<ExplicitType, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, _FieldToValue = FieldToValue<Arg>>(name: string, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">): FilterInfo<[...Args, opt?: _FieldToValue | null], Model>;
+    query(query: (...args: Args) => QueryOf<Model>): this;
+    applyFilterMeta(filterRef: Type, key: string): void;
+}
+export declare const filter: () => FilterInfo<[], any>;
+export {};

package/src/index.d.ts

@@ -3,3 +3,5 @@ export * from "./schema";
 export * from "./types";
 export * from "./database";
 export * from "./dataLoader";
+export * from "./documentInfo";
+export * from "./filterMeta";

package/src/types.d.ts

@@ -1,6 +1,57 @@
-import type { GetStateObject } from "@akanjs/base";
-import type { Document } from "mongoose";
+import type { Enum, GetStateObject, Type } from "@akanjs/base";
+import type { Document, ProjectionType } from "mongoose";
 export type DataInputOf<Input, Obj> = {
     [K in keyof Input as K extends K ? K : never]: Input[K] extends any[] ? Input[K] | undefined : Input[K];
 } & Partial<Obj>;
 export type GetDocObject<D> = GetStateObject<Omit<D, Exclude<keyof Document, "id"> | "__v">>;
+export interface FilterType {
+    [key: string]: any;
+}
+export interface SortType<Model extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}> {
+    [key: string]: Partial<{
+        [K in keyof GetStateObject<Model>]: number;
+    }>;
+}
+export type SortOf<Filter> = keyof GetStateObject<Filter>;
+export interface ConstantFilterMeta {
+    refName: string;
+    sort: SortType;
+}
+export interface FilterKeyProps {
+    type?: "mongo" | "meili";
+}
+export interface FilterKeyMeta extends FilterKeyProps {
+    key: string;
+    descriptor: PropertyDescriptor;
+}
+export interface FilterArgProps {
+    nullable?: boolean;
+    ref?: string;
+    default?: string | number | boolean | object | null | (() => string | number | boolean | object | null);
+    renderOption?: (value: any) => string;
+    enum?: Enum;
+}
+export interface FilterArgMeta extends FilterArgProps {
+    name: string;
+    modelRef: Type;
+    arrDepth: number;
+    isArray: boolean;
+    optArrDepth: number;
+}
+export interface ListQueryOption<Sort, Obj> {
+    skip?: number | null;
+    limit?: number | null;
+    sort?: Sort | null;
+    sample?: number;
+    select?: ProjectionType<Obj>;
+}
+export interface FindQueryOption<Sort, Obj> {
+    skip?: number | null;
+    sort?: Sort | null;
+    sample?: boolean;
+    select?: ProjectionType<Obj>;
+}