akanjs 2.3.5-rc.8 → 2.3.5

package/types/dictionary/dictInfo.d.ts

@@ -1,9 +1,16 @@
 import type { GetStateObject } from "akanjs/base";
 import type { BaseInsight, BaseObject } from "akanjs/constant";
-import type { BaseFilterQueryKey, BaseFilterSortKey, FilterInfo, FilterInstance } from "akanjs/document";
-import type { EndpointInfo, SliceInfo } from "akanjs/signal";
+import type { BaseFilterQueryKey, BaseFilterSortKey, FilterCls, FilterInfo, FilterInstance } from "akanjs/document";
+import type { EndpInfoArgNames, EndpointInfo, SliceInfo, SliceInfoArgNames } from "akanjs/signal";
 import type { RootDictionary } from "./trans.d.ts";
 type EnumValueKey = string | number;
+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"];
 declare class FieldTranslation<Languages extends [string, ...string[]]> {
     static translate: <Languages_1 extends [string, ...string[]]>(trans: Languages_1) => FieldTranslation<Languages_1>;
     trans: Languages;
@@ -95,12 +102,12 @@ export declare class ModelDictInfo<Languages extends [string, ...string[]] = [st
     insight<Insight extends object>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
         [K in Exclude<keyof GetStateObject<Insight>, InsightKey>]: FieldTranslation<Languages>;
     }): ModelDictInfo<Languages, ModelKey, keyof GetStateObject<Insight> & string, QueryKey, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
-    query<Filter extends FilterInstance>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-        [K in Exclude<keyof Filter["query"], QueryKey>]: Filter["query"][K] extends FilterInfo<infer ArgNames, any> ? FunctionTranslation<Languages, ArgNames[number]> : never;
-    }): ModelDictInfo<Languages, ModelKey, InsightKey, keyof Filter["query"] & string, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
-    sort<Filter extends FilterInstance>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
-        [K in Exclude<keyof Filter["sort"], SortKey>]: FieldTranslation<Languages>;
-    }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, keyof Filter["sort"] & string, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    query<Filter>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
+        [K in Exclude<keyof DictFilterQuery<Filter>, QueryKey>]: DictFilterQuery<Filter>[K] extends FilterInfo<infer ArgNames, any> ? FunctionTranslation<Languages, ArgNames[number]> : never;
+    }): ModelDictInfo<Languages, ModelKey, InsightKey, keyof DictFilterQuery<Filter> & string, SortKey, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
+    sort<Filter>(translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
+        [K in Exclude<keyof DictFilterSort<Filter>, SortKey>]: FieldTranslation<Languages>;
+    }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, keyof DictFilterSort<Filter> & string, EnumKey, BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
     enum<Enum extends {
         refName: string;
         value: EnumValueKey;
@@ -108,10 +115,10 @@ export declare class ModelDictInfo<Languages extends [string, ...string[]] = [st
         [K in Enum["value"]]: FieldTranslation<Languages>;
     }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey | Enum["refName"], BaseSignalKey, SliceKey, EndpointKey, ErrorKey, EtcKey>;
     slice<Slice>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-        [K in Exclude<keyof Slice, SliceKey>]: Slice[K] extends SliceInfo<any, any, any, any, any, any, any, infer ArgNames, any, any, any> ? FunctionTranslation<Languages, ArgNames[number]> : never;
+        [K in Exclude<keyof Slice, SliceKey>]: Slice[K] extends infer Info extends SliceInfo ? FunctionTranslation<Languages, SliceInfoArgNames<Info>[number]> : never;
     }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey, BaseSignalKey, keyof Slice & string, EndpointKey, ErrorKey, EtcKey>;
     endpoint<Endpoint>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-        [K in Exclude<keyof Endpoint, EndpointKey>]: Endpoint[K] extends EndpointInfo<any, any, infer ArgNames, any, any, any, any, any, any, any> ? FunctionTranslation<Languages, ArgNames[number]> : never;
+        [K in Exclude<keyof Endpoint, EndpointKey>]: Endpoint[K] extends infer Info extends EndpointInfo ? FunctionTranslation<Languages, EndpInfoArgNames<Info>[number]> : never;
     }): ModelDictInfo<Languages, ModelKey, InsightKey, QueryKey, SortKey, EnumKey, BaseSignalKey, SliceKey, keyof Endpoint & string, ErrorKey, EtcKey>;
     error<ErrorDict extends {
         [key: string]: Languages;
@@ -189,7 +196,7 @@ export declare class ServiceDictInfo<Languages extends [string, ...string[]] = [
     endpoint<Endpoint extends {
         [key: string]: EndpointInfo;
     }>(translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-        [K in keyof Endpoint]: FunctionTranslation<Languages, Endpoint[K]["argNames"][number]>;
+        [K in keyof Endpoint]: FunctionTranslation<Languages, EndpInfoArgNames<Endpoint[K]>[number]>;
     }): ServiceDictInfo<Languages, keyof Endpoint & string, ErrorKey, EtcKey>;
     error<ErrorDict extends {
         [key: string]: Languages;

package/types/dictionary/locale.d.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 {
     t: string;
@@ -17,16 +17,23 @@ interface FnTrans<ArgKey extends string> {
         [key in ArgKey]: FieldTrans;
     };
 }
-type FilterTranslatorKey<Filter extends FilterInstance> = {
-    [Key in keyof Filter["query"] & string]: `${Key}` | `${Key}.desc` | (Filter["query"][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];
+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` | (DictFilterQuery<Filter>[Key] extends FilterInfo<infer ArgNames, any> ? ArgNames[number] extends string ? `${Key}.arg.${ArgNames[number]}` | `${Key}.arg.${ArgNames[number]}.desc` : never : never);
+}[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 in keyof Endpoint & string]: `${Key}` | `${Key}.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> ? `${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` : never;
+    [Key in keyof Slice & string]: Slice[Key] extends infer Info extends SliceInfo ? `${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];
 type SliceApiTrans<T extends string, Suffix extends string, ArgName extends string, _CapitalizedSuffix extends string = Capitalize<Suffix>> = {
     [K in `${T}List${_CapitalizedSuffix}`]: FnTrans<ArgName | "skip" | "limit" | "sort">;
@@ -44,7 +51,7 @@ type BaseModelCrudGetApiTrans<T extends string> = {
 } & {
     [K in `remove${T}`]: FnTrans<`${T}Id`>;
 };
-export type ModelTrans<T extends string, Model extends BaseObject, Insight extends BaseInsight, Filter extends FilterInstance, Slice extends {
+export type ModelTrans<T extends string, Model extends BaseObject, Insight extends BaseInsight, Filter, Slice extends {
     [key: string]: SliceInfo;
 }, Endpoint extends {
     [key: string]: EndpointInfo;
@@ -58,15 +65,15 @@ export type ModelTrans<T extends string, Model extends BaseObject, Insight exten
         [K in keyof GetStateObject<Insight>]: FieldTrans;
     };
     query: {
-        [K in keyof Filter["query"]]: Filter["query"][K] extends FilterInfo<infer ArgNames, any> ? FnTrans<ArgNames[number]> : never;
+        [K in keyof DictFilterQuery<Filter>]: DictFilterQuery<Filter>[K] extends FilterInfo<infer ArgNames, any> ? FnTrans<ArgNames[number]> : never;
     };
     sort: {
-        [K in keyof Filter["sort"]]: FieldTrans;
+        [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;
@@ -74,11 +81,11 @@ export type ModelTrans<T extends string, Model extends BaseObject, Insight exten
 } & {
     [K in EtcKey]: Trans;
 };
-export type ModelTranslatorKey<T extends string, Model, Insight, Filter extends FilterInstance, Slice extends {
+export type ModelTranslatorKey<T extends string, Model, Insight, Filter, Slice extends {
     [key: string]: SliceInfo;
 }, Endpoint extends {
     [key: string]: EndpointInfo;
-}, EtcKey extends string> = `${T}.modelName` | `${T}.modelDesc` | `${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}.signal.${EndpointTranslatorKey<Endpoint> | SliceTranslatorKey<Slice>}` | `${T}.${EtcKey}`;
+}, EtcKey extends string> = `${T}.modelName` | `${T}.modelDesc` | `${T}.${keyof GetStateObject<Model> & string}${"" | ".desc"}` | `${T}.insight.${keyof GetStateObject<Insight> & string}${"" | ".desc"}` | `${T}.query.${FilterTranslatorKey<Filter>}` | `${T}.sort.${keyof DictFilterSort<Filter> & string}${"" | ".desc"}` | `${T}.signal.${EndpointTranslatorKey<Endpoint> | SliceTranslatorKey<Slice>}` | `${T}.${EtcKey}`;
 export type ScalarTrans<T extends string, Model, ErrorKey extends string, EtcKey extends string> = {
     name: Trans;
     desc: Trans;
@@ -96,7 +103,7 @@ export type ServiceTrans<T extends string, Endpoint extends {
     [key: string]: EndpointInfo;
 }, ErrorKey extends string, 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;
@@ -116,7 +123,7 @@ export interface DictModule<DictKey extends string, ErrorKey extends string> {
     __Error_Key__: ErrorKey;
     dict: ModelDictInfo<any> | ScalarDictInfo<any> | ServiceDictInfo<any>;
 }
-export declare const registerModelTrans: <RefName extends string, Model extends BaseObject, Insight extends BaseInsight, Filter extends FilterInstance, Slice extends {
+export declare const registerModelTrans: <RefName extends string, Model extends BaseObject, Insight extends BaseInsight, Filter, Slice extends {
     [key: string]: SliceInfo;
 }, Endpoint extends {
     [key: string]: EndpointInfo;

package/types/document/by.d.ts

@@ -1,9 +1,11 @@
-import { type Cls, FIELD_META, type MergeAllActionTypes } from "akanjs/base";
-import { type BaseObject, type DocumentModel, type FieldObject } from "akanjs/constant";
-export type DatabaseCls<Schema = any> = Cls<Schema, {
+import { type Cls, FIELD_META, type GetActionObject, SERVER_VALUE } from "akanjs/base";
+import { type DocumentConstantModelRef, type DocumentModel, type FieldObject } from "akanjs/constant";
+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>;
     isModified(field?: keyof TDocument & string): boolean;
@@ -12,11 +14,46 @@ export interface DefaultDocMtds<TDocument> {
     toJSON(): DocumentModel<TDocument>;
     toObject(): DocumentModel<TDocument>;
 }
+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;
-} & DefaultDocMtds<TDocument>;
-export type Doc<M = any> = HydratedDocumentWithId<DocumentModel<M>>;
-export declare const by: <ModelCls, AddDbModels extends DatabaseCls[], _DatabaseSchema = ModelCls extends {
+} & 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, _DocModel = _DatabaseSchema extends BaseObject ? Doc<_DatabaseSchema> : DocumentModel<_DatabaseSchema>>(modelRef: ModelCls, ...addRefs: AddDbModels) => DatabaseCls<MergeAllActionTypes<AddDbModels, keyof _DocModel & string> & _DocModel>;
+} ? 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 declare function by<ModelCls extends ConstantModelCls>(modelRef: ModelCls): DatabaseCls<DocModelFor<ModelCls>>;
+export declare function by<ModelCls extends ConstantModelCls, AddDbModel extends DatabaseCls>(modelRef: ModelCls, addRef: AddDbModel): DatabaseCls<DocumentActionsOf<AddDbModel, DocActionOmitKeyFor<ModelCls> & string> & DocModelFor<ModelCls>>;
+export declare function by<ModelCls extends ConstantModelCls, const AddDbModels extends DatabaseCls[]>(modelRef: ModelCls, ...addRefs: AddDbModels): DatabaseCls<ByInstance<ModelCls, AddDbModels>>;
 export {};

package/types/document/database.d.ts

@@ -39,18 +39,19 @@ type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends a
 } & {
     [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<Capitalize<K>, Doc, Insight, Args, [
         ...Args,
         queryOption?: _ListQueryOption
     ], [
         ...Args,
         queryOption?: _FindQueryOption
-    ]> : never : never;
-}>;
-type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Query, Sort, _CapitalizedRefName extends string = Capitalize<T>, _QueryOfDoc = QueryOf<Doc>, _DataInput = DataInputOf<Input, DocumentModel<Obj>>, _FindQueryOption = FindQueryOption<Sort, Obj>, _ListQueryOption = ListQueryOption<Sort, Obj>> = {
+    ], _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, Doc, Obj, Insight, Query, Sort, _CapitalizedRefName extends string = Capitalize<T>, _QueryOfDoc = QueryOf<Doc>, _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>;
@@ -74,7 +75,7 @@ type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Quer
     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>;
 } & {
@@ -92,5 +93,6 @@ type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Quer
 } & {
     [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
 } & QueryMethodPart<Query, Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc>;
-export type DatabaseInstance<T extends string = string, Input = any, Doc = any, Obj = any, Insight = any, Filter extends FilterInstance = FilterInstance, _CapitalizedRefName 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, _CapitalizedRefName, _QueryOfDoc, _DataInput, _FindQueryOption, _ListQueryOption>;
+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, Doc = any, Obj = any, Insight = any, Filter extends FilterInstance = FilterInstance, _CapitalizedRefName extends string = Capitalize<T>, _QueryOfDoc = QueryOf<Doc>, _Query = ExtractQuery<Filter>, _Sort = ExtractSort<Filter>, _DocumentObj = DocumentModel<Obj>, _DataInput = DataInputOf<Input, _DocumentObj>, _FindQueryOption = FindQueryOption<_Sort, Obj>, _ListQueryOption = ListQueryOption<_Sort, Obj>> = DatabaseInstanceWithQuerySort<T, Input, Doc, Obj, Insight, _Query, _Sort, _CapitalizedRefName, _QueryOfDoc, _DocumentObj, _DataInput, _FindQueryOption, _ListQueryOption>;
 export {};

package/types/document/databaseRegistry.d.ts

@@ -1,7 +1,7 @@
 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.d.ts";
-export interface DatabaseModel<T extends string = string, Input = any, Doc = any, Model = any, Obj = any, Insight = any, Filter extends FilterInstance = any, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>> {
+export interface DatabaseModel<T extends string = string, Input = any, Doc = any, Model = any, Obj = any, Insight = any, Filter extends FilterInstance = any, _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>> {
     refName: T;
     input: DatabaseCls<Input>;
     doc: DatabaseCls<Doc>;
@@ -15,6 +15,7 @@ export interface DatabaseModel<T extends string = string, Input = any, Doc = any
     _Obj: Obj;
     _Insight: Insight;
     _Filter: Filter;
+    _Query: _Query;
     _Sort: _Sort;
 }
 export declare class DatabaseRegistry {
@@ -23,7 +24,7 @@ export declare class DatabaseRegistry {
     static isDoc(modelRef: DatabaseCls): boolean;
     static isModel(modelRef: DatabaseCls): boolean;
     static isScalar(modelRef: DatabaseCls): boolean;
-    static setDatabase(refName: string, dbModel: DatabaseModel): DatabaseModel<string, any, any, any, any, any, any, string | number | symbol>;
+    static setDatabase(refName: string, dbModel: DatabaseModel): DatabaseModel<string, any, any, any, any, any, any, ExtractQuery<any>, string | number | symbol>;
     static getDatabase<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
         allowEmpty?: AllowEmpty;
     }): AllowEmpty extends true ? DatabaseModel | undefined : DatabaseModel;
@@ -31,6 +32,6 @@ export declare class DatabaseRegistry {
     static getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
         allowEmpty?: AllowEmpty;
     }): AllowEmpty extends true ? DatabaseCls | undefined : DatabaseCls;
-    static buildModel<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>>(refName: T, input: DatabaseCls<Input>, doc: DatabaseCls<Doc>, model: ModelCls<Model>, obj: ConstantCls<Obj>, insight: ConstantCls<Insight>, filter: FilterCls<Filter>): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Sort>;
+    static buildModel<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>, _Sort extends ExtractSort<Filter> = ExtractSort<Filter>>(refName: T, input: DatabaseCls<Input>, doc: DatabaseCls<Doc>, model: ModelCls<Model>, obj: ConstantCls<Obj>, insight: ConstantCls<Insight>, filter: FilterCls<Filter>): DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter, _Query, _Sort>;
     static buildScalar<T extends string, Model>(refName: T, Model: DatabaseCls<Model>): DatabaseCls<Model>;
 }

package/types/document/filterMeta.d.ts

@@ -41,26 +41,33 @@ interface BaseSort {
         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> ? (...args: Args) => QueryOf<any> : never;
 };
 export type ExtractSort<Filter extends FilterInstance> = keyof Filter["sort"];
-export interface FilterCls<Filter extends FilterInstance = any> extends Cls<{
+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 declare const from: <Full extends BaseObject, BuildFilter extends (filter: () => FilterInfo<[], [], Full>) => FilterInstance, LibFilters extends FilterCls[], _Filter extends ReturnType<BuildFilter>>(modelRef: Cls<Full>, buildFilter: BuildFilter, ...libFilterRefs: LibFilters) => 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>;
-}>;
+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 declare 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, ...libFilterRefs: LibFilters) => FilterCls<_MergedFilter, _Query, _Sort>;
 interface ArgProps<Value = unknown> {
     nullable?: boolean;
     ref?: string;

package/types/document/into.d.ts

@@ -1,12 +1,14 @@
-import { type Cls, type MergeAllActionTypes, type PromiseOrObject } from "akanjs/base";
-import type { ConstantModel, DocumentModel, FieldObject, QueryOf } from "akanjs/constant";
-import type { ExtractQuery, ExtractSort, FilterCls, FilterInstance } from ".";
-import type { DatabaseInstance } from "./database.d.ts";
+import { type Cls, type PromiseOrObject } from "akanjs/base";
+import type { DocumentModel, QueryOf } from "akanjs/constant";
+import type { FilterCls, FilterQueryOf, FilterSortOf } from ".";
+import type { CacheDatabase, QueryMethodPart } from "./database.d.ts";
+import type { DataLoader } from "./dataLoader.d.ts";
 import type { DocumentUpdate, DocumentUpdateOptions } from "./documentQuery.d.ts";
 import { type LoaderBuilder, type ModelCls } from "./loaderInfo.d.ts";
+import type { DocumentProjection } from "./types.d.ts";
 export type CRUDEventType = "create" | "update" | "remove";
 export type SaveEventType = "save" | CRUDEventType;
-interface DefaultMdlStats<TDocument, TSchema, _Partial extends Partial<TSchema> = Partial<TSchema>, _FilterQuery extends QueryOf<TSchema> = QueryOf<TSchema>, _Projection extends Partial<Record<keyof TSchema, boolean>> = Partial<Record<keyof TSchema, boolean>>> {
+interface DefaultMdlStats<TDocument, TSchema, _Partial extends Partial<TSchema> = Partial<TSchema>, _FilterQuery extends QueryOf<TSchema> = QueryOf<TSchema>, _Projection = DocumentProjection<TSchema>> {
     pickOneAndWrite: (query: _FilterQuery, rawData: _Partial) => Promise<TDocument>;
     pickAndWrite: (docId: string, rawData: _Partial) => Promise<TDocument>;
     pickOne: (query: _FilterQuery, projection?: _Projection) => Promise<TDocument>;
@@ -30,9 +32,9 @@ export interface UpdateResult {
     modifiedCount: number;
     upsertedId?: string | null;
 }
-export interface BulkWriteOperation<Raw> {
+export interface BulkWriteOperation<Raw, _RawDoc = DocumentModel<Raw>, _RawQuery = QueryOf<_RawDoc>> {
     updateOne: {
-        filter: QueryOf<DocumentModel<Raw>>;
+        filter: _RawQuery;
         update: DocumentUpdate;
         upsert?: boolean;
     };
@@ -48,18 +50,43 @@ type FindOneChain<Doc> = Promise<Doc | null> & {
     skip(skip: number): FindOneChain<Doc>;
     select(projection?: unknown): FindOneChain<Doc>;
 };
-export type Mdl<Doc, Raw> = DefaultMdlStats<Doc, DocumentModel<Raw>> & {
+export type Mdl<Doc, Raw, _RawDoc = DocumentModel<Raw>, _RawQuery = QueryOf<_RawDoc>, _Projection extends DocumentProjection<Raw> = DocumentProjection<Raw>> = DefaultMdlStats<Doc, _RawDoc, Partial<_RawDoc>, _RawQuery, _Projection> & {
     refName: string;
-    new (data: Partial<DocumentModel<Raw>>): Doc;
-    find(query: QueryOf<DocumentModel<Raw>>, projection?: Partial<Record<keyof Raw, boolean>>): FindManyChain<Doc>;
-    findOne(query: QueryOf<DocumentModel<Raw>>, projection?: Partial<Record<keyof Raw, boolean>>): FindOneChain<Doc>;
-    findById(id: string | undefined, projection?: Partial<Record<keyof Raw, boolean>>): Promise<Doc | null>;
-    countDocuments(query: QueryOf<DocumentModel<Raw>>): Promise<number>;
-    exists(query: QueryOf<DocumentModel<Raw>>): Promise<string | null>;
-    updateOne(query: QueryOf<DocumentModel<Raw>>, update: DocumentUpdate, options?: DocumentUpdateOptions): Promise<UpdateResult>;
-    updateMany(query: QueryOf<DocumentModel<Raw>>, update: DocumentUpdate): Promise<UpdateResult>;
-    deleteMany(query: QueryOf<DocumentModel<Raw>>): Promise<UpdateResult>;
-    bulkWrite(operations: BulkWriteOperation<Raw>[]): Promise<UpdateResult>;
+    new (data: Partial<_RawDoc> | Partial<Doc>): Doc;
+    find(query: _RawQuery, projection?: _Projection): FindManyChain<Doc>;
+    findOne(query: _RawQuery, projection?: _Projection): FindOneChain<Doc>;
+    findById(id: string | undefined, projection?: _Projection): Promise<Doc | null>;
+    countDocuments(query: _RawQuery): Promise<number>;
+    exists(query: _RawQuery): Promise<string | null>;
+    updateOne(query: _RawQuery, update: DocumentUpdate, options?: DocumentUpdateOptions): Promise<UpdateResult>;
+    updateMany(query: _RawQuery, update: DocumentUpdate): Promise<UpdateResult>;
+    deleteMany(query: _RawQuery): Promise<UpdateResult>;
+    bulkWrite(operations: BulkWriteOperation<Raw, _RawDoc, _RawQuery>[]): Promise<UpdateResult>;
 };
-export declare const into: <Doc, Filter extends FilterInstance, T extends string, Input, Obj, Full, Light, Insight, FullFieldObj extends FieldObject, AddDbModels extends ModelCls[], _CapitalizedRefName extends string, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc, _Query = ExtractQuery<Filter>, _Sort = ExtractSort<Filter>, _DatabaseModel = DatabaseInstance<T, _DocInput, Doc, Full, Insight, Filter, _CapitalizedRefName, _QueryOfDoc, _Query, _Sort>, _LoaderBuilder extends LoaderBuilder<_Doc> = LoaderBuilder<_Doc>>(docRef: Cls<Doc>, filterRef: FilterCls<Filter>, cnst: ConstantModel<T, Input, Obj, Full, Light, Insight, FullFieldObj, _CapitalizedRefName, _Default, _DefaultInput, _DefaultState, _DefaultStateInput, _DefaultInsight, _PurifiedInput, _Doc, _DocInput, _QueryOfDoc>, loaderBuilder: _LoaderBuilder, ...addMdls: [...AddDbModels]) => ModelCls<MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel, ReturnType<_LoaderBuilder>>;
+interface IntoConstantModel<T extends string, _CapitalizedRefName extends string, Raw> {
+    refName: T;
+    _CapitalizedRefName: _CapitalizedRefName;
+    _Full: Raw;
+}
+type NoInferType<T> = [T][T extends unknown ? 0 : never];
+type IntoModelActions<T extends string, _CapitalizedRefName extends string, Doc, Raw, _Query, _Sort, _QueryOfDoc = QueryOf<Doc>> = {
+    [key in _CapitalizedRefName]: Mdl<Doc, Raw>;
+} & {
+    [key in `${Uncapitalize<_CapitalizedRefName>}Loader`]: DataLoader<string, Doc, string>;
+} & {
+    [key in `${Uncapitalize<_CapitalizedRefName>}Cache`]: CacheDatabase<T>;
+} & {
+    [K in `get${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & {
+    [K in `load${_CapitalizedRefName}`]: (id?: string) => Promise<Doc | null>;
+} & {
+    [K in `load${_CapitalizedRefName}Many`]: (ids: string[]) => Promise<Doc[]>;
+} & {
+    [K in `create${_CapitalizedRefName}`]: (data: Partial<Doc>) => Promise<Doc>;
+} & {
+    [K in `update${_CapitalizedRefName}`]: (id: string, data: Partial<Doc>) => Promise<Doc>;
+} & {
+    [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
+} & QueryMethodPart<_Query, _Sort, Raw, Doc, unknown, unknown, unknown, _QueryOfDoc>;
+export declare const into: <Doc, FilterRef extends FilterCls, T extends string, Raw, AddDbModels extends ModelCls[], _CapitalizedRefName extends string, _QueryOfDoc = QueryOf<Doc>, _Query = FilterQueryOf<FilterRef>, _Sort = FilterSortOf<FilterRef>, _LoaderBuilder extends LoaderBuilder<NoInferType<Doc>> = LoaderBuilder<Doc>>(docRef: Cls<Doc>, filterRef: FilterRef, cnst: IntoConstantModel<T, _CapitalizedRefName, Raw>, loaderBuilder: _LoaderBuilder, ...addMdls: [...AddDbModels]) => ModelCls<IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>, ReturnType<_LoaderBuilder>>;
 export {};

package/types/document/types.d.ts

@@ -20,17 +20,18 @@ export interface FilterArgProps {
     renderOption?: (value: never) => string;
     enum?: EnumInstance;
 }
+export type DocumentProjection<T> = Partial<Record<keyof T, boolean>>;
 export interface ListQueryOption<Sort = never, Obj = any> {
     skip?: number | null;
     limit?: number | null;
     sort?: Sort | null;
     sample?: number;
-    select?: Partial<Record<keyof Obj, boolean>>;
+    select?: DocumentProjection<Obj>;
 }
 export interface FindQueryOption<Sort = never, Obj = any> {
     skip?: number | null;
     sort?: Sort | null;
     sample?: boolean;
-    select?: Partial<Record<keyof Obj, boolean>>;
+    select?: DocumentProjection<Obj>;
 }
 export type { SchemaOf } from "./documentSchema.d.ts";

package/types/fetch/fetchType/endpointFetch.type.d.ts

@@ -1,8 +1,8 @@
 import type { ENDPOINT_META, PromiseOrObject } from "akanjs/base";
 import type { FetchPolicy } from "akanjs/common";
-import type { EndpInfoArgs, EndpInfoClientReturns, EndpInfoNullable, EndpInfoReqType, EndpointCls, EndpointInfo, SliceCls } from "akanjs/signal";
+import type { EndpInfoArgs, EndpInfoClientReturns, EndpInfoNullable, EndpInfoReqType, EndpointCls, EndpointInfo, SlceCnstFull, SlceCnstInsight, SlceCnstLight, SliceCls } from "akanjs/signal";
 type ExtendedEndpointReturn<ClientReturns, Full, Light, Insight> = ClientReturns extends (infer R)[] ? ExtendedEndpointReturn<R, Full, Light, Insight>[] : Full extends ClientReturns ? Full : Light extends ClientReturns ? Light : Insight extends ClientReturns ? Insight : ClientReturns;
-type EndpointClientReturns<E, SlceCls extends SliceCls | never> = [SlceCls] extends [never] ? EndpInfoClientReturns<E> : ExtendedEndpointReturn<EndpInfoClientReturns<E>, SlceCls["srv"]["cnst"]["_Full"], SlceCls["srv"]["cnst"]["_Light"], SlceCls["srv"]["cnst"]["_Insight"]>;
+type EndpointClientReturns<E, SlceCls extends SliceCls | never> = [SlceCls] extends [never] ? EndpInfoClientReturns<E> : ExtendedEndpointReturn<EndpInfoClientReturns<E>, SlceCnstFull<SlceCls>, SlceCnstLight<SlceCls>, SlceCnstInsight<SlceCls>>;
 type EndpInfoReturns<E, SlceCls extends SliceCls | never> = EndpointClientReturns<E, SlceCls> | (EndpInfoNullable<E> extends true ? null : never);
 type QueryOrMutationFetchFn<E, SlceCls extends SliceCls | never> = (...args: [...EndpInfoArgs<E>, fetchPolicy?: FetchPolicy]) => Promise<EndpInfoReturns<E, SlceCls>>;
 type MessageEmitFn<E, SlceCls extends SliceCls | never> = (...args: EndpInfoArgs<E>) => EndpInfoReturns<E, SlceCls>;

package/types/fetch/fetchType/sliceFetch.type.d.ts

@@ -2,19 +2,19 @@ import type { GetStateObject, SLICE_META } from "akanjs/base";
 import type { FetchPolicy } from "akanjs/common";
 import type { ConstantModel, DefaultOf, ProtoFile, PurifiedModel } from "akanjs/constant";
 import type { DatabaseModel, ExtractSort, FilterInstance } from "akanjs/document";
-import type { SliceCls, SliceInfoArgs } from "akanjs/signal";
+import type { SlceCnstCapitalizedRefName, SlceCnstDefaultInput, SlceCnstFull, SlceCnstInput, SlceCnstInsight, SlceCnstLight, SlceCnstPurifiedInput, SlceCnstRefName, SlceDbFilter, SlceDbSort, SliceCls, SliceInfoArgs } from "akanjs/signal";
 import type { ClientEdit, ClientInit, ClientView, EditReturn, InitReturn, ViewReturn } from "./appliedReturn.type";
 type _SliceMap<S extends SliceCls> = S[typeof SLICE_META];
-type _RefName<S extends SliceCls> = S["srv"]["cnst"]["refName"];
-type _Cap<S extends SliceCls> = S["srv"]["cnst"]["_CapitalizedRefName"];
-type _Input<S extends SliceCls> = S["srv"]["cnst"]["_Input"];
-type _Full<S extends SliceCls> = S["srv"]["cnst"]["_Full"];
-type _Light<S extends SliceCls> = S["srv"]["cnst"]["_Light"];
-type _Insight<S extends SliceCls> = S["srv"]["cnst"]["_Insight"];
-type _PurifiedInput<S extends SliceCls> = S["srv"]["cnst"]["_PurifiedInput"];
-type _DefaultInput<S extends SliceCls> = S["srv"]["cnst"]["_DefaultInput"];
-type _Filter<S extends SliceCls> = S["srv"]["db"]["_Filter"];
-type _Sort<S extends SliceCls> = S["srv"]["db"]["_Sort"];
+type _RefName<S extends SliceCls> = SlceCnstRefName<S>;
+type _Cap<S extends SliceCls> = SlceCnstCapitalizedRefName<S>;
+type _Input<S extends SliceCls> = SlceCnstInput<S>;
+type _Full<S extends SliceCls> = SlceCnstFull<S>;
+type _Light<S extends SliceCls> = SlceCnstLight<S>;
+type _Insight<S extends SliceCls> = SlceCnstInsight<S>;
+type _PurifiedInput<S extends SliceCls> = SlceCnstPurifiedInput<S>;
+type _DefaultInput<S extends SliceCls> = SlceCnstDefaultInput<S>;
+type _Filter<S extends SliceCls> = SlceDbFilter<S>;
+type _Sort<S extends SliceCls> = SlceDbSort<S>;
 type _LightWithId<S extends SliceCls> = _Light<S> extends {
     id: string;
 } ? _Light<S> : {

package/types/service/serve.d.ts

@@ -1,8 +1,8 @@
 import { type Cls, INJECT_META } from "akanjs/base";
 import { Logger } from "akanjs/common";
-import type { DatabaseModel, FilterInstance } from "akanjs/document";
+import type { DatabaseModel } from "akanjs/document";
 import { type ExtractInjectInfoObject, type InjectBuilder, InjectInfo } from "./injectInfo.d.ts";
-import type { DatabaseService } from "./types.d.ts";
+import type { DatabaseServiceForModel } from "./types.d.ts";
 interface ServiceOptions {
     enabled?: boolean;
     serverMode?: "batch" | "federation";
@@ -25,7 +25,6 @@ export type ServiceCls<RefName extends string = string, Methods = {}, InjectMap
 }>;
 export declare function serve<RefName extends string, Injection extends InjectBuilder>(refName: RefName, injectBuilder: Injection, ...extendSrvs: Cls[]): ServiceCls<RefName, {}, ReturnType<Injection>>;
 export declare function serve<RefName extends string, Injection extends InjectBuilder>(refName: RefName, option: ServiceOptions, injectBuilder: Injection, ...extendSrvs: Cls[]): ServiceCls<RefName, {}, ReturnType<Injection>>;
-export declare function serve<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(db: DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter>, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
-export declare function serve<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(db: DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter>, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
-export declare function serve<T extends string, Input, Doc, Model, Obj, Insight, Filter extends FilterInstance, Injection extends InjectBuilder, LibSrvs extends ServiceCls[] = []>(db: DatabaseModel<T, Input, Doc, Model, Obj, Insight, Filter>, option: ServiceOptions, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
+export declare function serve<Db extends DatabaseModel, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(db: Db, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<Db["refName"], DatabaseServiceForModel<Db, LibSrvs>, ReturnType<Injection>>;
+export declare function serve<Db extends DatabaseModel, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(db: Db, option: ServiceOptions, injectBuilder: Injection, ...extendSrvs: LibSrvs): ServiceCls<Db["refName"], DatabaseServiceForModel<Db, LibSrvs>, ReturnType<Injection>>;
 export {};

package/types/service/serviceModule.d.ts

@@ -19,7 +19,7 @@ export declare class ServiceModel<Srv extends ServiceCls = ServiceCls, CnstModel
     static from<Srv extends ServiceCls>(srv: Srv): ServiceModel<Srv, never, never, { [K in `${Uncapitalize<Srv["refName"]>}Service`]: UnCls<Srv>; }>;
     with<SrvModules extends ServiceModel[]>(...srvs: SrvModules): ServiceModel<Srv, CnstModel, DbModel, SrvMap & MergeAllKeyOfObjects<SrvModules, "srvMap">>;
     static getDefaultDbServiceMethods(className: string): {
-        [x: string]: ((this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) => Promise<any>) | ((this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) => Promise<any>) | ((this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => any) | ((this: DatabaseService, id: string, data: DataInputOf) => Promise<any>);
+        [x: string]: ((this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) => Promise<any>) | ((this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) => Promise<any>) | ((this: DatabaseService, id: string, data: Partial<Doc>) => Promise<Partial<Doc>>) | ((this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>) => any) | ((this: DatabaseService, id: string, data: DataInputOf) => Promise<any>);
         __get(this: DatabaseService, id: string): Promise<any>;
         __load(this: DatabaseService, id?: string): Promise<any>;
         __loadMany(this: DatabaseService, ids: string[]): Promise<any>;
@@ -33,11 +33,11 @@ export declare class ServiceModel<Srv extends ServiceCls = ServiceCls, CnstModel
         __count(this: DatabaseService, query: QueryOf<any>): Promise<any>;
         __insight(this: DatabaseService, query: QueryOf<any>): Promise<any>;
         _preCreate(this: DatabaseService, data: DataInputOf): Promise<DataInputOf>;
-        _postCreate(this: DatabaseService, doc: Doc): Promise<any>;
-        _preUpdate(this: DatabaseService, id: string, data: Partial<Doc>): Promise<Partial<any>>;
-        _postUpdate(this: DatabaseService, doc: Doc): Promise<any>;
+        _postCreate(this: DatabaseService, doc: Doc): Promise<Doc>;
+        _preUpdate(this: DatabaseService, id: string, data: Partial<Doc>): Promise<Partial<Doc>>;
+        _postUpdate(this: DatabaseService, doc: Doc): Promise<Doc>;
         _preRemove(this: DatabaseService, id: string): Promise<void>;
-        _postRemove(this: DatabaseService, doc: Doc): Promise<any>;
+        _postRemove(this: DatabaseService, doc: Doc): Promise<Doc>;
         listenPre(this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>): any;
         listenPost(this: DatabaseService, type: SaveEventType, listener: (doc: Doc, type: CRUDEventType) => PromiseOrObject<void>): any;
         __create(this: DatabaseService, data: DataInputOf): Promise<any>;