akanjs 2.3.5-rc.8 → 2.3.5

package/dictionary/locale.ts

@@ -1,7 +1,7 @@
 import type { GetStateObject, MergedValues } from "akanjs/base";
 import type { BaseInsight, BaseObject } from "akanjs/constant";
-import type { FilterInfo, FilterInstance } from "akanjs/document";
-import type { EndpointInfo, SliceInfo } from "akanjs/signal";
+import type { FilterCls, FilterInfo, FilterInstance } from "akanjs/document";
+import type { EndpInfoArgNames, EndpointInfo, SliceInfo, SliceInfoArgNames, SliceInfoRefName } from "akanjs/signal";
 import type { ModelDictInfo, ScalarDictInfo, ServiceDictInfo } from ".";
 
 interface Trans {
@@ -16,46 +16,44 @@ interface FnTrans<ArgKey extends string> {
   desc?: string;
   arg?: { [key in ArgKey]: FieldTrans };
 }
-type FilterTranslatorKey<Filter extends FilterInstance> = {
-  [Key in keyof Filter["query"] & string]:
+type AnyFilterShape = FilterInstance<Record<string, FilterInfo>, Record<string, unknown>>;
+type DictFilterShape<Filter> = Filter extends FilterInstance
+  ? Filter
+  : Filter extends FilterCls<infer FilterShape>
+    ? FilterShape
+    : Filter extends { query: Record<string, FilterInfo>; sort: Record<string, unknown> }
+      ? Filter
+      : AnyFilterShape;
+type DictFilterQuery<Filter> = DictFilterShape<Filter>["query"];
+type DictFilterSort<Filter> = DictFilterShape<Filter>["sort"];
+type FilterTranslatorKey<Filter> = {
+  [Key in keyof DictFilterQuery<Filter> & string]:
     | `${Key}`
     | `${Key}.desc`
-    | (Filter["query"][Key] extends FilterInfo<infer ArgNames, any>
+    | (DictFilterQuery<Filter>[Key] extends FilterInfo<infer ArgNames, any>
         ? ArgNames[number] extends string
           ? `${Key}.arg.${ArgNames[number]}` | `${Key}.arg.${ArgNames[number]}.desc`
           : never
         : never);
-}[keyof Filter["query"] & string];
+}[keyof DictFilterQuery<Filter> & string];
 type EndpointTranslatorKey<Endpoint extends { [key: string]: EndpointInfo }> = {
   [Key in keyof Endpoint & string]:
     | `${Key}`
     | `${Key}.desc`
-    | `${Key}.arg.${Endpoint[Key]["argNames"][number]}`
-    | `${Key}.arg.${Endpoint[Key]["argNames"][number]}.desc`;
+    | `${Key}.arg.${EndpInfoArgNames<Endpoint[Key]>[number]}`
+    | `${Key}.arg.${EndpInfoArgNames<Endpoint[Key]>[number]}.desc`;
 }[keyof Endpoint & string];
 type SliceTranslatorKey<Slice> = {
-  [Key in keyof Slice & string]: Slice[Key] extends SliceInfo<
-    infer T,
-    any,
-    any,
-    any,
-    any,
-    any,
-    any,
-    infer ArgNames,
-    any,
-    any,
-    any
-  >
+  [Key in keyof Slice & string]: Slice[Key] extends infer Info extends SliceInfo
     ?
-        | `${T}List${Capitalize<Key>}`
-        | `${T}List${Capitalize<Key>}.desc`
-        | `${T}List${Capitalize<Key>}.arg.${ArgNames[number] | "skip" | "limit" | "sort"}`
-        | `${T}List${Capitalize<Key>}.arg.${ArgNames[number] | "skip" | "limit" | "sort"}.desc`
-        | `${T}Insight${Capitalize<Key>}`
-        | `${T}Insight${Capitalize<Key>}.desc`
-        | `${T}Insight${Capitalize<Key>}.arg.${ArgNames[number]}`
-        | `${T}Insight${Capitalize<Key>}.arg.${ArgNames[number]}.desc`
+        | `${SliceInfoRefName<Info>}List${Capitalize<Key>}`
+        | `${SliceInfoRefName<Info>}List${Capitalize<Key>}.desc`
+        | `${SliceInfoRefName<Info>}List${Capitalize<Key>}.arg.${SliceInfoArgNames<Info>[number] | "skip" | "limit" | "sort"}`
+        | `${SliceInfoRefName<Info>}List${Capitalize<Key>}.arg.${SliceInfoArgNames<Info>[number] | "skip" | "limit" | "sort"}.desc`
+        | `${SliceInfoRefName<Info>}Insight${Capitalize<Key>}`
+        | `${SliceInfoRefName<Info>}Insight${Capitalize<Key>}.desc`
+        | `${SliceInfoRefName<Info>}Insight${Capitalize<Key>}.arg.${SliceInfoArgNames<Info>[number]}`
+        | `${SliceInfoRefName<Info>}Insight${Capitalize<Key>}.arg.${SliceInfoArgNames<Info>[number]}.desc`
     : never;
 }[keyof Slice & string];
 
@@ -85,7 +83,7 @@ export type ModelTrans<
   T extends string,
   Model extends BaseObject,
   Insight extends BaseInsight,
-  Filter extends FilterInstance,
+  Filter,
   Slice extends { [key: string]: SliceInfo },
   Endpoint extends { [key: string]: EndpointInfo },
   ErrorKey extends string,
@@ -96,16 +94,16 @@ export type ModelTrans<
   model: { [K in keyof GetStateObject<Model>]: FieldTrans };
   insight: { [K in keyof GetStateObject<Insight>]: FieldTrans };
   query: {
-    [K in keyof Filter["query"]]: Filter["query"][K] extends FilterInfo<infer ArgNames, any>
+    [K in keyof DictFilterQuery<Filter>]: DictFilterQuery<Filter>[K] extends FilterInfo<infer ArgNames, any>
       ? FnTrans<ArgNames[number]>
       : never;
   };
-  sort: { [K in keyof Filter["sort"]]: FieldTrans };
+  sort: { [K in keyof DictFilterSort<Filter>]: FieldTrans };
   api: {
-    [K in keyof Endpoint]: FnTrans<Endpoint[K]["argNames"][number]>;
+    [K in keyof Endpoint]: FnTrans<EndpInfoArgNames<Endpoint[K]>[number]>;
   } & BaseModelCrudGetApiTrans<T> &
     MergedValues<{
-      [K in keyof Slice]: SliceApiTrans<Slice[K]["refName"], K & string, Slice[K]["argNames"][number]>;
+      [K in keyof Slice]: SliceApiTrans<SliceInfoRefName<Slice[K]>, K & string, SliceInfoArgNames<Slice[K]>[number]>;
     }>;
   error: { [K in ErrorKey]: Trans };
 } & { [K in EtcKey]: Trans };
@@ -113,7 +111,7 @@ export type ModelTranslatorKey<
   T extends string,
   Model,
   Insight,
-  Filter extends FilterInstance,
+  Filter,
   Slice extends { [key: string]: SliceInfo },
   Endpoint extends { [key: string]: EndpointInfo },
   EtcKey extends string,
@@ -123,7 +121,7 @@ export type ModelTranslatorKey<
   | `${T}.${keyof GetStateObject<Model> & string}${"" | ".desc"}`
   | `${T}.insight.${keyof GetStateObject<Insight> & string}${"" | ".desc"}`
   | `${T}.query.${FilterTranslatorKey<Filter>}`
-  | `${T}.sort.${keyof Filter["sort"] & string}${"" | ".desc"}`
+  | `${T}.sort.${keyof DictFilterSort<Filter> & string}${"" | ".desc"}`
   | `${T}.signal.${EndpointTranslatorKey<Endpoint> | SliceTranslatorKey<Slice>}`
   | `${T}.${EtcKey}`;
 
@@ -146,7 +144,7 @@ export type ServiceTrans<
   EtcKey extends string,
 > = {
   api: {
-    [K in keyof Endpoint]: FnTrans<Endpoint[K]["argNames"][number]>;
+    [K in keyof Endpoint]: FnTrans<EndpInfoArgNames<Endpoint[K]>[number]>;
   };
   error: { [K in ErrorKey]: Trans };
 } & { [K in EtcKey]: Trans };
@@ -171,7 +169,7 @@ export const registerModelTrans = <
   RefName extends string,
   Model extends BaseObject,
   Insight extends BaseInsight,
-  Filter extends FilterInstance,
+  Filter,
   Slice extends { [key: string]: SliceInfo },
   Endpoint extends { [key: string]: EndpointInfo },
   ModelDict extends ModelDictInfo<any>,

package/document/by.ts

@@ -1,14 +1,14 @@
-import { type Cls, FIELD_META, type MergeAllActionTypes } from "akanjs/base";
+import { type Cls, FIELD_META, type GetActionObject, SERVER_VALUE } from "akanjs/base";
 import { applyMixins } from "akanjs/common";
-import {
-  type BaseObject,
-  type ConstantCls,
-  ConstantRegistry,
-  type DocumentModel,
-  type FieldObject,
-} from "akanjs/constant";
+import { ConstantRegistry, type DocumentConstantModelRef, type DocumentModel, type FieldObject } from "akanjs/constant";
 
-export type DatabaseCls<Schema = any> = Cls<Schema, { refName: string; [FIELD_META]: FieldObject }>;
+export type DatabaseCls<Schema = unknown> = Cls<Schema, { refName: string; [FIELD_META]: FieldObject }>;
+export type DatabaseInstanceOf<DatabaseRef extends DatabaseCls> = DatabaseRef extends new (
+  ...args: never[]
+) => infer Instance
+  ? Instance
+  : never;
+type ConstantModelCls = DocumentConstantModelRef<unknown>;
 
 export interface DefaultDocMtds<TDocument> {
   refresh(): Promise<this>;
@@ -18,23 +18,86 @@ export interface DefaultDocMtds<TDocument> {
   toJSON(): DocumentModel<TDocument>;
   toObject(): DocumentModel<TDocument>;
 }
-type HydratedDocumentWithId<TDocument> = TDocument & { id: string } & DefaultDocMtds<TDocument>;
-export type Doc<M = any> = HydratedDocumentWithId<DocumentModel<M>>;
+type HydratedDocumentMethods<TDocument, Self> = Omit<
+  DefaultDocMtds<TDocument>,
+  "isModified" | "refresh" | "save" | "set"
+> & {
+  refresh(): Promise<Self>;
+  isModified(field?: keyof TDocument & string): boolean;
+  set(data: Partial<TDocument>): Self;
+  save(): Promise<Self>;
+};
+type HydratedDocumentWithId<TDocument> = TDocument & { id: string } & HydratedDocumentMethods<TDocument, TDocument>;
+interface ChainableHydratedMethods<TDocument>
+  extends Omit<DefaultDocMtds<TDocument>, "isModified" | "refresh" | "save" | "set"> {
+  refresh(): Promise<this>;
+  isModified(field?: keyof TDocument & string): boolean;
+  set(data: Partial<TDocument>): this;
+  save(): Promise<this>;
+}
+type ChainableHydratedDocument<TDocument> = TDocument & {
+  id: string;
+} & ChainableHydratedMethods<TDocument>;
+export type Doc<M = unknown> = HydratedDocumentWithId<DocumentModel<M>>;
+type DatabaseSchemaOf<ModelCls> = ModelCls extends { _DatabaseSchema: infer Schema } ? Schema : never;
+type ConstantValueOf<ModelCls> = ModelCls extends { [SERVER_VALUE]: infer Schema }
+  ? Schema
+  : ModelCls extends new (
+        ...args: never[]
+      ) => infer Schema
+    ? Schema
+    : never;
+type ObjectDocumentModelType = "object" | "full" | "light";
+type ModelTypeOf<ModelCls> = ModelCls extends { _ModelType: infer ModelType } ? ModelType : never;
+type IsObjectModel<ModelCls> = ModelTypeOf<ModelCls> extends ObjectDocumentModelType ? true : false;
+type DocModelOf<ModelCls, Schema = DatabaseSchemaOf<ModelCls>> =
+  IsObjectModel<ModelCls> extends true ? ChainableHydratedDocument<DocumentModel<Schema>> : DocumentModel<Schema>;
+type DocActionOmitKey<ModelCls, Schema = DatabaseSchemaOf<ModelCls>> =
+  | (keyof Schema & string)
+  | (IsObjectModel<ModelCls> extends true ? keyof DefaultDocMtds<unknown> | "id" : never);
+type DatabaseSchemaFor<ModelCls extends ConstantModelCls> = DatabaseSchemaOf<ModelCls> & ConstantValueOf<ModelCls>;
+type DocModelFor<ModelCls extends ConstantModelCls> = DocModelOf<ModelCls, DatabaseSchemaFor<ModelCls>>;
+type DocActionOmitKeyFor<ModelCls extends ConstantModelCls> = DocActionOmitKey<ModelCls, DatabaseSchemaFor<ModelCls>>;
+type StrictDocumentActions<T> = string extends keyof T
+  ? T[string] extends never
+    ? Record<never, never>
+    : GetActionObject<T>
+  : GetActionObject<T>;
+type DocumentActionsOf<AddDbModel extends DatabaseCls, OmitKey extends string> = Omit<
+  StrictDocumentActions<DatabaseInstanceOf<AddDbModel>>,
+  OmitKey
+>;
+type MergeDocumentActions<
+  AddDbModels extends readonly DatabaseCls[],
+  OmitKey extends string,
+  Acc = Record<never, never>,
+> = AddDbModels extends readonly [infer First extends DatabaseCls, ...infer Rest extends readonly DatabaseCls[]]
+  ? MergeDocumentActions<Rest, OmitKey, Acc & DocumentActionsOf<First, OmitKey>>
+  : AddDbModels extends readonly (infer AddDbModel extends DatabaseCls)[]
+    ? Acc & DocumentActionsOf<AddDbModel, OmitKey>
+    : Acc;
+type ByInstance<
+  ModelCls extends ConstantModelCls,
+  AddDbModels extends readonly DatabaseCls[],
+  _OmitKey extends string = DocActionOmitKeyFor<ModelCls> & string,
+  _DocModel = DocModelFor<ModelCls>,
+> = MergeDocumentActions<AddDbModels, _OmitKey> & _DocModel;
 
-export const by = <
-  ModelCls,
-  AddDbModels extends DatabaseCls[],
-  _DatabaseSchema = ModelCls extends { _DatabaseSchema: infer Schema } ? Schema : never,
-  _DocModel = _DatabaseSchema extends BaseObject ? Doc<_DatabaseSchema> : DocumentModel<_DatabaseSchema>,
->(
+export function by<ModelCls extends ConstantModelCls>(modelRef: ModelCls): DatabaseCls<DocModelFor<ModelCls>>;
+export function by<ModelCls extends ConstantModelCls, AddDbModel extends DatabaseCls>(
+  modelRef: ModelCls,
+  addRef: AddDbModel,
+): DatabaseCls<DocumentActionsOf<AddDbModel, DocActionOmitKeyFor<ModelCls> & string> & DocModelFor<ModelCls>>;
+export function by<ModelCls extends ConstantModelCls, const AddDbModels extends DatabaseCls[]>(
   modelRef: ModelCls,
   ...addRefs: AddDbModels
-): DatabaseCls<MergeAllActionTypes<AddDbModels, keyof _DocModel & string> & _DocModel> => {
+): DatabaseCls<ByInstance<ModelCls, AddDbModels>>;
+export function by(modelRef: ConstantModelCls, ...addRefs: DatabaseCls[]): DatabaseCls {
   const refName = ConstantRegistry.getRefName(modelRef as Cls);
   const databaseCls = class DatabaseCls {
     static refName = refName;
-    static [FIELD_META] = (modelRef as ConstantCls)[FIELD_META];
+    static [FIELD_META] = modelRef[FIELD_META];
   };
   applyMixins(databaseCls as Cls, addRefs);
-  return databaseCls as any;
-};
+  return databaseCls as unknown as DatabaseCls;
+}

package/document/database.ts

@@ -58,17 +58,7 @@ type QueryMethodOfKey<
 } & {
   [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
 };
-
-export type QueryMethodPart<
-  Query,
-  Sort,
-  Obj,
-  Doc,
-  Insight,
-  _FindQueryOption = FindQueryOption<Sort, Obj>,
-  _ListQueryOption = ListQueryOption<Sort, Obj>,
-  _QueryOfDoc = QueryOf<Doc>,
-> = MergedValues<{
+type QueryMethodMap<Query, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> = {
   [K in keyof Query]: K extends string
     ? Query[K] extends (...args: infer Args) => any
       ? QueryMethodOfKey<
@@ -77,11 +67,23 @@ export type QueryMethodPart<
           Insight,
           Args,
           [...Args, queryOption?: _ListQueryOption],
-          [...Args, queryOption?: _FindQueryOption]
+          [...Args, queryOption?: _FindQueryOption],
+          _QueryOfDoc
         >
       : never
     : never;
-}>;
+};
+
+export type QueryMethodPart<
+  Query,
+  Sort,
+  Obj,
+  Doc,
+  Insight,
+  _FindQueryOption = FindQueryOption<Sort, Obj>,
+  _ListQueryOption = ListQueryOption<Sort, Obj>,
+  _QueryOfDoc = QueryOf<Doc>,
+> = MergedValues<QueryMethodMap<Query, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>>;
 type DatabaseModelWithQuerySort<
   T extends string,
   Input,
@@ -92,12 +94,13 @@ type DatabaseModelWithQuerySort<
   Sort,
   _CapitalizedRefName extends string = Capitalize<T>,
   _QueryOfDoc = QueryOf<Doc>,
-  _DataInput = DataInputOf<Input, DocumentModel<Obj>>,
+  _DocumentObj = DocumentModel<Obj>,
+  _DataInput = DataInputOf<Input, _DocumentObj>,
   _FindQueryOption = FindQueryOption<Sort, Obj>,
   _ListQueryOption = ListQueryOption<Sort, Obj>,
 > = {
   logger: Logger;
-  __model: Mdl<Doc, Obj>;
+  __model: Mdl<Doc, Obj, _DocumentObj>;
   __cache: CacheDatabase<T>;
   __loader: DataLoader<string, Doc, string>;
   __get: (id: string) => Promise<Doc>;
@@ -119,7 +122,7 @@ type DatabaseModelWithQuerySort<
   listenPre: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
   listenPost: (type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => () => void;
 } & {
-  [key in _CapitalizedRefName]: Mdl<Doc, Obj>;
+  [key in _CapitalizedRefName]: Mdl<Doc, Obj, _DocumentObj>;
 } & {
   [key in `${T}Loader`]: DataLoader<string, Doc, string>;
 } & {
@@ -138,6 +141,36 @@ type DatabaseModelWithQuerySort<
   [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
 } & QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>;
 
+export type DatabaseInstanceWithQuerySort<
+  T extends string = string,
+  Input = any,
+  Doc = any,
+  Obj = any,
+  Insight = any,
+  Query = ExtractQuery<FilterInstance>,
+  Sort = ExtractSort<FilterInstance>,
+  _CapitalizedRefName extends string = Capitalize<T>,
+  _QueryOfDoc = QueryOf<Doc>,
+  _DocumentObj = DocumentModel<Obj>,
+  _DataInput = DataInputOf<Input, _DocumentObj>,
+  _FindQueryOption = FindQueryOption<Sort, Obj>,
+  _ListQueryOption = ListQueryOption<Sort, Obj>,
+> = DatabaseModelWithQuerySort<
+  T,
+  Input,
+  Doc,
+  Obj,
+  Insight,
+  Query,
+  Sort,
+  _CapitalizedRefName,
+  _QueryOfDoc,
+  _DocumentObj,
+  _DataInput,
+  _FindQueryOption,
+  _ListQueryOption
+>;
+
 export type DatabaseInstance<
   T extends string = string,
   Input = any,
@@ -149,10 +182,11 @@ export type DatabaseInstance<
   _QueryOfDoc = QueryOf<Doc>,
   _Query = ExtractQuery<Filter>,
   _Sort = ExtractSort<Filter>,
-  _DataInput = DataInputOf<Input, DocumentModel<Obj>>,
+  _DocumentObj = DocumentModel<Obj>,
+  _DataInput = DataInputOf<Input, _DocumentObj>,
   _FindQueryOption = FindQueryOption<_Sort, Obj>,
   _ListQueryOption = ListQueryOption<_Sort, Obj>,
-> = DatabaseModelWithQuerySort<
+> = DatabaseInstanceWithQuerySort<
   T,
   Input,
   Doc,
@@ -162,6 +196,7 @@ export type DatabaseInstance<
   _Sort,
   _CapitalizedRefName,
   _QueryOfDoc,
+  _DocumentObj,
   _DataInput,
   _FindQueryOption,
   _ListQueryOption

package/document/databaseRegistry.ts

@@ -1,5 +1,5 @@
 import type { ConstantCls } from "akanjs/constant";
-import type { DatabaseCls, ExtractSort, FilterCls, FilterInstance } from ".";
+import type { DatabaseCls, ExtractQuery, ExtractSort, FilterCls, FilterInstance } from ".";
 import type { ModelCls } from "./loaderInfo";
 
 export interface DatabaseModel<
@@ -10,6 +10,7 @@ export interface DatabaseModel<
   Obj = any,
   Insight = any,
   Filter extends FilterInstance = any,
+  _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>,
   _Sort extends ExtractSort<Filter> = ExtractSort<Filter>,
 > {
   refName: T;
@@ -25,6 +26,7 @@ export interface DatabaseModel<
   _Obj: Obj;
   _Insight: Insight;
   _Filter: Filter;
+  _Query: _Query;
   _Sort: _Sort;
 }
 export class DatabaseRegistry {
@@ -82,6 +84,7 @@ export class DatabaseRegistry {
     Obj,
     Insight,
     Filter extends FilterInstance,
+    _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>,
     _Sort extends ExtractSort<Filter> = ExtractSort<Filter>,
   >(
     refName: T,
@@ -91,7 +94,7 @@ export class DatabaseRegistry {
     obj: ConstantCls<Obj>,
     insight: ConstantCls<Insight>,
     filter: FilterCls<Filter>,
-  ): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Sort> {
+  ): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Query, _Sort> {
     const dbInfo = {
       refName,
       input,
@@ -100,8 +103,9 @@ export class DatabaseRegistry {
       obj,
       insight,
       filter,
+      _Query: null as unknown as _Query,
       _Sort: null as unknown as _Sort,
-    } as DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Sort>;
+    } as DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Query, _Sort>;
     DatabaseRegistry.setDatabase(refName, dbInfo);
     return dbInfo;
   }

package/document/filterMeta.ts

@@ -116,6 +116,22 @@ interface BaseSort {
   latest: { createdAt: -1 };
   oldest: { createdAt: 1 };
 }
+type LibFilterQuery<LibFilters extends FilterCls[]> = MergeAllDoubleKeyOfObjects<
+  LibFilters,
+  typeof FILTER_META,
+  "query"
+>;
+type LibFilterSort<LibFilters extends FilterCls[]> = MergeAllKeyOfTypes<LibFilters, "sort">;
+type FilterQuery<Full, LibFilters extends FilterCls[], Filter extends FilterInstance> = BaseQuery<Full> &
+  LibFilterQuery<LibFilters> &
+  Filter["query"];
+type FilterSort<LibFilters extends FilterCls[], Filter extends FilterInstance> = BaseSort &
+  LibFilterSort<LibFilters> &
+  Filter["sort"];
+type MergedFilterInstance<Full, LibFilters extends FilterCls[], Filter extends FilterInstance> = {
+  query: FilterQuery<Full, LibFilters, Filter>;
+  sort: FilterSort<LibFilters, Filter>;
+};
 
 export type ExtractQuery<Filter extends FilterInstance> = {
   [K in keyof Filter["query"]]: Filter["query"][K] extends FilterInfo<any, infer Args>
@@ -123,16 +139,24 @@ export type ExtractQuery<Filter extends FilterInstance> = {
     : never;
 };
 export type ExtractSort<Filter extends FilterInstance> = keyof Filter["sort"];
-export interface FilterCls<Filter extends FilterInstance = any> extends Cls<{ [key: string]: any }> {
+export interface FilterCls<Filter extends FilterInstance = any, Query = unknown, Sort = unknown>
+  extends Cls<{ [key: string]: any }> {
   [FILTER_META]: Filter;
   sortField: Set<string>;
+  _Query: Query;
+  _Sort: Sort;
 }
+export type FilterQueryOf<FilterRef extends FilterCls> = FilterRef extends { _Query: infer Query } ? Query : never;
+export type FilterSortOf<FilterRef extends FilterCls> = FilterRef extends { _Sort: infer Sort } ? Sort : never;
 
 export const from = <
   Full extends BaseObject,
   BuildFilter extends (filter: () => FilterInfo<[], [], Full>) => FilterInstance,
   LibFilters extends FilterCls[],
   _Filter extends ReturnType<BuildFilter>,
+  _MergedFilter extends FilterInstance = MergedFilterInstance<Full, LibFilters, _Filter>,
+  _Query = ExtractQuery<_MergedFilter>,
+  _Sort = ExtractSort<_MergedFilter>,
 >(
   modelRef: Cls<Full>,
   buildFilter: BuildFilter,
@@ -153,19 +177,7 @@ export const from = <
     },
     ...libFilterRefs.map((libFilterRef) => getFilterMeta(libFilterRef)),
   );
-  return Base as unknown as Cls<
-    {
-      query: BaseQuery<Full> & MergeAllDoubleKeyOfObjects<LibFilters, typeof FILTER_META, "query"> & _Filter["query"];
-      sort: BaseSort & MergeAllKeyOfTypes<LibFilters, "sort"> & _Filter["sort"];
-    },
-    {
-      [FILTER_META]: {
-        query: BaseQuery<Full> & MergeAllDoubleKeyOfObjects<LibFilters, typeof FILTER_META, "query"> & _Filter["query"];
-        sort: BaseSort & MergeAllKeyOfTypes<LibFilters, "sort"> & _Filter["sort"];
-      };
-      sortField: Set<string>;
-    }
-  >;
+  return Base as unknown as FilterCls<_MergedFilter, _Query, _Sort>;
 };
 
 interface ArgProps<Value = unknown> {