@akanjs/document 0.9.56 → 0.9.57

package/cjs/src/dbDecorators.js

@@ -23,9 +23,14 @@ __export(dbDecorators_exports, {
 });
 module.exports = __toCommonJS(dbDecorators_exports);
 var import_constant = require("@akanjs/constant");
-const Model = (docRef, filterRef, cnst, ...addMdls) => {
+var import_loaderInfo = require("./loaderInfo");
+const Model = (docRef, filterRef, cnst, loaderBuilder, ...addMdls) => {
   class DefaultModel {
   }
+  const loaderInfoMap = loaderBuilder((0, import_loaderInfo.makeLoaderBuilder)());
+  Object.entries(loaderInfoMap).forEach(([key, loaderInfo]) => {
+    loaderInfo.applyLoaderInfo(DefaultModel, key);
+  });
   return DefaultModel;
 };
 const into = Model;

package/cjs/src/filterMeta.js

@@ -35,7 +35,6 @@ __export(filterMeta_exports, {
 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;
 };
@@ -90,17 +89,12 @@ 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}`);
+const from = (modelRef, buildFilter, ...libFilterRefs) => {
   class Base {
   }
-  const querySort = filterSort(filter);
+  const querySort = buildFilter(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]) => {
@@ -123,6 +117,7 @@ const from = (modelRef, filterSort, ...libFilterRefs) => {
   return Base;
 };
 class FilterInfo {
+  argNames = [];
   args;
   queryFn = null;
   constructor() {
@@ -133,12 +128,14 @@ class FilterInfo {
       throw new Error("Query function is already set");
     else if (this.args.at(-1)?.option?.nullable)
       throw new Error("Last argument is nullable");
+    this.argNames.push(name);
     this.args.push({ name, argRef, option });
     return this;
   }
   opt(name, argRef, option) {
     if (this.queryFn)
       throw new Error("Query function is already set");
+    this.argNames.push(name);
     this.args.push({ name, argRef, option: { ...option, nullable: true } });
     return this;
   }

package/cjs/src/loaderInfo.js

@@ -0,0 +1,60 @@
+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 loaderInfo_exports = {};
+__export(loaderInfo_exports, {
+  LoaderInfo: () => LoaderInfo,
+  makeLoaderBuilder: () => makeLoaderBuilder
+});
+module.exports = __toCommonJS(loaderInfo_exports);
+var import__ = require(".");
+class LoaderInfo {
+  type;
+  field;
+  defaultQuery;
+  queryArg;
+  constructor(type, field, defaultQuery = {}) {
+    this.type = type;
+    this.field = field;
+    this.defaultQuery = defaultQuery;
+  }
+  applyLoaderInfo(mdlRef, key) {
+    switch (this.type) {
+      case "field":
+        import__.Loader.ByField(this.field, this.defaultQuery)(mdlRef.prototype, key);
+        break;
+      case "arrayField":
+        import__.Loader.ByArrayField(this.field, this.defaultQuery)(mdlRef.prototype, key);
+        break;
+      case "query":
+        import__.Loader.ByQuery(this.field, this.defaultQuery)(mdlRef.prototype, key);
+        break;
+      default:
+        throw new Error(`Invalid inject type: ${this.type}`);
+    }
+  }
+}
+const makeLoaderBuilder = () => ({
+  byField: (fieldName, defaultQuery = {}) => new LoaderInfo("field", fieldName, defaultQuery),
+  byArrayField: (fieldName, defaultQuery = {}) => new LoaderInfo("arrayField", fieldName, defaultQuery),
+  byQuery: (queryKeys, defaultQuery = {}) => new LoaderInfo("query", queryKeys, defaultQuery)
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LoaderInfo,
+  makeLoaderBuilder
+});

package/esm/src/database.js

@@ -2,7 +2,11 @@ import { dayjs } from "@akanjs/base";
 import { capitalize, Logger, lowerlize } from "@akanjs/common";
 import { DEFAULT_PAGE_SIZE, getFieldMetas } from "@akanjs/constant";
 import { createArrayLoader, createLoader, createQueryLoader, getLoaderMetas } from "./dataLoader";
-import { getFilterKeyMetaMapOnPrototype, getFilterQuery, getFilterSort } from "./filterMeta";
+import {
+  getFilterKeyMetaMapOnPrototype,
+  getFilterQuery,
+  getFilterSort
+} from "./filterMeta";
 import { convertAggregateMatch } from "./schema";
 class CacheDatabase {
   constructor(refName, redis) {

package/esm/src/dbDecorators.js

@@ -1,7 +1,12 @@
 import { getFieldMetaMap, setFieldMetaMap } from "@akanjs/constant";
-const Model = (docRef, filterRef, cnst, ...addMdls) => {
+import { makeLoaderBuilder } from "./loaderInfo";
+const Model = (docRef, filterRef, cnst, loaderBuilder, ...addMdls) => {
   class DefaultModel {
   }
+  const loaderInfoMap = loaderBuilder(makeLoaderBuilder());
+  Object.entries(loaderInfoMap).forEach(([key, loaderInfo]) => {
+    loaderInfo.applyLoaderInfo(DefaultModel, key);
+  });
   return DefaultModel;
 };
 const into = Model;

package/esm/src/filterMeta.js

@@ -1,8 +1,5 @@
-import {
-  getNonArrayModel
-} from "@akanjs/base";
+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;
 };
@@ -57,17 +54,12 @@ 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}`);
+const from = (modelRef, buildFilter, ...libFilterRefs) => {
   class Base {
   }
-  const querySort = filterSort(filter);
+  const querySort = buildFilter(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]) => {
@@ -90,6 +82,7 @@ const from = (modelRef, filterSort, ...libFilterRefs) => {
   return Base;
 };
 class FilterInfo {
+  argNames = [];
   args;
   queryFn = null;
   constructor() {
@@ -100,12 +93,14 @@ class FilterInfo {
       throw new Error("Query function is already set");
     else if (this.args.at(-1)?.option?.nullable)
       throw new Error("Last argument is nullable");
+    this.argNames.push(name);
     this.args.push({ name, argRef, option });
     return this;
   }
   opt(name, argRef, option) {
     if (this.queryFn)
       throw new Error("Query function is already set");
+    this.argNames.push(name);
     this.args.push({ name, argRef, option: { ...option, nullable: true } });
     return this;
   }

package/esm/src/loaderInfo.js

@@ -0,0 +1,36 @@
+import { Loader } from ".";
+class LoaderInfo {
+  type;
+  field;
+  defaultQuery;
+  queryArg;
+  constructor(type, field, defaultQuery = {}) {
+    this.type = type;
+    this.field = field;
+    this.defaultQuery = defaultQuery;
+  }
+  applyLoaderInfo(mdlRef, key) {
+    switch (this.type) {
+      case "field":
+        Loader.ByField(this.field, this.defaultQuery)(mdlRef.prototype, key);
+        break;
+      case "arrayField":
+        Loader.ByArrayField(this.field, this.defaultQuery)(mdlRef.prototype, key);
+        break;
+      case "query":
+        Loader.ByQuery(this.field, this.defaultQuery)(mdlRef.prototype, key);
+        break;
+      default:
+        throw new Error(`Invalid inject type: ${this.type}`);
+    }
+  }
+}
+const makeLoaderBuilder = () => ({
+  byField: (fieldName, defaultQuery = {}) => new LoaderInfo("field", fieldName, defaultQuery),
+  byArrayField: (fieldName, defaultQuery = {}) => new LoaderInfo("arrayField", fieldName, defaultQuery),
+  byQuery: (queryKeys, defaultQuery = {}) => new LoaderInfo("query", queryKeys, defaultQuery)
+});
+export {
+  LoaderInfo,
+  makeLoaderBuilder
+};

package/package.json

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

package/src/database.d.ts

@@ -1,4 +1,4 @@
-import type { Dayjs, GetActionObject, MergedValues, PromiseOrObject } from "@akanjs/base";
+import type { Dayjs, MergedValues, PromiseOrObject } from "@akanjs/base";
 import { Logger } from "@akanjs/common";
 import { type DocumentModel, type QueryOf } from "@akanjs/constant";
 import type DataLoader from "dataloader";
@@ -7,7 +7,8 @@ import type { HydratedDocument } from "mongoose";
 import type { RedisClientType } from "redis";
 import type { BaseMiddleware, CRUDEventType, Mdl, SaveEventType } from "./dbDecorators";
 import type { Database } from "./documentInfo";
-import type { DataInputOf, FilterType, FindQueryOption, ListQueryOption, SortOf } from "./types";
+import { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
+import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
 export interface RedisSetOptions {
     expireAt?: Dayjs;
 }
@@ -119,6 +120,6 @@ type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Quer
 } & {
     [K in `searchCount${_CapitalizedT}`]: (searchText: string) => Promise<number>;
 } & 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 type DatabaseModel<T extends string, Input, Doc, Obj, Insight, Filter extends FilterInstance, _CapitalizedT extends string = Capitalize<T>, _QueryOfDoc = QueryOf<Doc>, _Query = ExtractQuery<Filter>, _Sort = ExtractSort<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 FilterInstance>(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,7 +1,9 @@
-import { BaseObject, GetActionObject, type MergeAllActionTypes, PromiseOrObject, Type } from "@akanjs/base";
+import { BaseObject, 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 { ExtractQuery, FilterInstance } from ".";
 import type { DatabaseModel } from "./database";
+import { ExtractLoaderInfoObject, LoaderBuilder } from "./loaderInfo";
 export type { FilterQuery as QueryOf };
 export interface DefaultDocMtds<TDocument> {
     refresh(): Promise<this>;
@@ -37,7 +39,7 @@ export type SchemaOf<Mdl, Doc> = Schema<null, Mdl, Doc, undefined, null, Mdl>;
 export interface BaseMiddleware {
     onSchema: (schema: SchemaOf<any, any>) => void;
 }
-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 into: <Doc, Filter extends FilterInstance, T extends string, Input, Full, Light, Insight, AddDbModels extends Type[], _CapitalizedT extends string, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc, _Query = ExtractQuery<Filter>, _Sort = keyof Filter["sort"], _DatabaseModel = DatabaseModel<T, _DocInput, Doc, Full, Insight, Filter, _CapitalizedT, _QueryOfDoc, _Query, _Sort>, _LoaderBuilder extends LoaderBuilder<_Doc> = LoaderBuilder<_Doc>>(docRef: Type<Doc>, filterRef: Type<Filter>, cnst: ConstantModel<T, Input, Full, Light, Insight, _CapitalizedT, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc>, loaderBuilder: _LoaderBuilder, ...addMdls: AddDbModels) => Type<MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel & ExtractLoaderInfoObject<ReturnType<_LoaderBuilder>>>;
 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

@@ -2,7 +2,7 @@ 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";
+import { FilterInstance } from "./filterMeta";
 export interface DatabaseDocumentModelInfo {
     input: Type;
     doc: Type;
@@ -12,16 +12,16 @@ export interface DatabaseDocumentModelInfo {
 }
 export declare const documentInfo: {
     database: Map<string, DatabaseDocumentModelInfo>;
-    scalar: Map<string, Type>;
+    scalar: Map<string, new (...args: any[]) => any>;
     modelSets: {
-        input: Set<Type>;
-        doc: Set<Type>;
-        model: Set<Type>;
-        filter: Set<Type>;
-        middleware: Set<Type>;
-        scalar: Set<Type>;
+        input: Set<new (...args: any[]) => any>;
+        doc: Set<new (...args: any[]) => any>;
+        model: Set<new (...args: any[]) => any>;
+        filter: Set<new (...args: any[]) => any>;
+        middleware: Set<new (...args: any[]) => any>;
+        scalar: Set<new (...args: any[]) => any>;
     };
-    modelRefNameMap: Map<Type, string>;
+    modelRefNameMap: Map<new (...args: any[]) => any, string>;
     getRefName<AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
         allowEmpty?: AllowEmpty;
     }): AllowEmpty extends true ? string | undefined : string;
@@ -43,7 +43,7 @@ export declare const documentInfo: {
         sortKeys: string[];
     } | undefined;
 };
-export interface Database<T extends string, Input, Doc extends HydratedDocument<any>, Model, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterType> {
+export interface Database<T extends string, Input, Doc extends HydratedDocument<any>, Model, Middleware extends BaseMiddleware, Obj, Insight, Filter extends FilterInstance> {
     refName: T;
     Input: Type<Input>;
     Doc: Type<Doc>;
@@ -53,7 +53,7 @@ export interface Database<T extends string, Input, Doc extends HydratedDocument<
     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 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 FilterInstance>(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

@@ -1,6 +1,6 @@
-import { type BaseObject, type MergeAllTypes, type Prettify, type Type } from "@akanjs/base";
+import { type BaseObject, MergeAllKeyOfTypes, type Type } from "@akanjs/base";
 import { ConstantFieldTypeInput, FieldToValue, PlainTypeToFieldType, QueryOf } from "@akanjs/constant";
-import type { ConstantFilterMeta, FilterArgMeta, FilterKeyMeta, SortType } from "./types";
+import type { ConstantFilterMeta, FilterArgMeta, FilterKeyMeta } 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;
@@ -10,51 +10,43 @@ export declare const setFilterArgMetasOnPrototype: (prototype: object, key: stri
 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<{
+export declare const getFilterSort: (filterRef: Type, key: string) => {
     [key: string]: any;
-}>;
-export type BaseFilterKey = "latest" | "oldest" | "any" | "byStatuses";
-interface BaseFilter<Status extends string = string> {
+};
+export declare const getFilterSortMap: (filterRef: Type) => {
+    [key: string]: any;
+};
+export type BaseFilterSortKey = "latest" | "oldest";
+export type BaseFilterQueryKey = "any";
+export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;
+export interface FilterInstance<Query = unknown, Sort = unknown> {
+    query: Query;
+    sort: Sort;
+}
+interface BaseQuery<Model> {
+    any: FilterInfo<[], [], Model>;
+}
+interface BaseSort {
     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 type ExtractQuery<Filter extends FilterInstance> = {
+    [K in keyof Filter["query"]]: Filter["query"][K] extends FilterInfo<any, 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"]>>;
+export type ExtractSort<Filter extends FilterInstance> = keyof Filter["sort"];
+export declare const from: <Full extends BaseObject, BuildFilter extends (filter: () => FilterInfo<[], [], Full>) => FilterInstance, LibFilters extends Type[], _Filter extends ReturnType<BuildFilter>>(modelRef: Type<Full>, buildFilter: BuildFilter, ...libFilterRefs: LibFilters) => Type<FilterInstance<BaseQuery<Full> & MergeAllKeyOfTypes<LibFilters, "query"> & _Filter["query"], BaseSort & MergeAllKeyOfTypes<LibFilters, "sort"> & _Filter["sort"]>>;
 interface ArgProps<Value = any> {
     nullable?: boolean;
     ref?: string;
     default?: Value;
     renderOption?: (arg: any) => string;
 }
-export declare class FilterInfo<Args extends any[] = [], Model = any> {
+export declare class FilterInfo<ArgNames extends string[] = [], Args extends any[] = [], Model = any> {
+    readonly argNames: ArgNames;
     readonly args: {
         name: string;
         argRef: any;
@@ -62,10 +54,10 @@ export declare class FilterInfo<Args extends any[] = [], Model = any> {
     }[];
     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>;
+    arg<ExplicitType, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, ArgName extends string = "unknown", _FieldToValue = FieldToValue<Arg>>(name: ArgName, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">): FilterInfo<[...ArgNames, ArgName], [...Args, arg: _FieldToValue], Model>;
+    opt<ExplicitType, Arg extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, ArgName extends string = "unknown", _FieldToValue = FieldToValue<Arg>>(name: ArgName, argRef: Arg, option?: Omit<ArgProps<_FieldToValue>, "nullable">): FilterInfo<[...ArgNames, ArgName], [...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 declare const filter: () => FilterInfo<[], [], any>;
 export {};

package/src/loaderInfo.d.ts

@@ -0,0 +1,26 @@
+import { Type } from "@akanjs/base";
+import { FilterQuery } from "mongoose";
+import { Loader } from ".";
+type LoaderType = "field" | "arrayField" | "query";
+export declare class LoaderInfo<Doc, Key extends keyof Doc, QueryArg = Doc[Key]> {
+    type: LoaderType;
+    field: Key | Key[];
+    defaultQuery: FilterQuery<unknown>;
+    queryArg: QueryArg;
+    constructor(type: LoaderType, field: Key | Key[], defaultQuery?: FilterQuery<unknown>);
+    applyLoaderInfo(mdlRef: Type, key: string): void;
+}
+export declare const makeLoaderBuilder: <Doc>() => {
+    byField: <Key extends keyof Doc & string>(fieldName: Key, defaultQuery?: FilterQuery<unknown>) => LoaderInfo<Doc, Key, Doc[Key]>;
+    byArrayField: <Key extends keyof Doc & string>(fieldName: Key, defaultQuery?: FilterQuery<unknown>) => LoaderInfo<Doc, Key, Doc[Key]>;
+    byQuery: <Key extends keyof Doc & string>(queryKeys: readonly Key[], defaultQuery?: FilterQuery<unknown>) => LoaderInfo<Doc, Key, Pick<Doc, Key>>;
+};
+export type LoaderBuilder<Doc = any> = (builder: ReturnType<typeof makeLoaderBuilder<Doc>>) => {
+    [key: string]: LoaderInfo<Doc, any, any>;
+};
+export type ExtractLoaderInfoObject<LoaderInfoMap extends {
+    [key: string]: LoaderInfo<any, any, any>;
+}> = {
+    [K in keyof LoaderInfoMap]: LoaderInfoMap[K] extends LoaderInfo<infer Doc, any, infer QueryArg> ? Loader<QueryArg, Doc> : never;
+};
+export {};

package/src/types.d.ts

@@ -1,25 +1,14 @@
-import type { Enum, GetStateObject, Type } from "@akanjs/base";
+import type { EnumInstance, 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;
+    sort: {
+        [key: string]: any;
+    };
 }
 export interface FilterKeyProps {
     type?: "mongo" | "meili";
@@ -33,7 +22,7 @@ export interface FilterArgProps {
     ref?: string;
     default?: string | number | boolean | object | null | (() => string | number | boolean | object | null);
     renderOption?: (value: any) => string;
-    enum?: Enum;
+    enum?: EnumInstance;
 }
 export interface FilterArgMeta extends FilterArgProps {
     name: string;