akanjs 2.3.5-rc.9 → 2.3.5

package/document/into.ts

@@ -1,10 +1,12 @@
-import { type Cls, LOADER_META, type MergeAllActionTypes, type PromiseOrObject } from "akanjs/base";
+import { type Cls, LOADER_META, type PromiseOrObject } from "akanjs/base";
 import { applyMixins } from "akanjs/common";
-import type { ConstantModel, DocumentModel, FieldObject, QueryOf } from "akanjs/constant";
-import type { ExtractQuery, ExtractSort, FilterCls, FilterInstance, SchemaOf } from ".";
-import type { DatabaseInstance } from "./database";
+import type { DocumentModel, QueryOf } from "akanjs/constant";
+import type { FilterCls, FilterQueryOf, FilterSortOf, SchemaOf } from ".";
+import type { CacheDatabase, QueryMethodPart } from "./database";
+import type { DataLoader } from "./dataLoader";
 import type { DocumentUpdate, DocumentUpdateOptions } from "./documentQuery";
 import { type LoaderBuilder, type ModelCls, makeLoaderBuilder } from "./loaderInfo";
+import type { DocumentProjection } from "./types";
 
 export type CRUDEventType = "create" | "update" | "remove";
 export type SaveEventType = "save" | CRUDEventType;
@@ -14,7 +16,7 @@ interface DefaultMdlStats<
   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>>,
+  _Projection = DocumentProjection<TSchema>,
 > {
   pickOneAndWrite: (query: _FilterQuery, rawData: _Partial) => Promise<TDocument>;
   pickAndWrite: (docId: string, rawData: _Partial) => Promise<TDocument>;
@@ -45,9 +47,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;
   };
@@ -63,89 +65,82 @@ 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>;
 };
 
+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 const into = <
   Doc,
-  Filter extends FilterInstance,
+  FilterRef extends FilterCls,
   T extends string,
-  Input,
-  Obj,
-  Full,
-  Light,
-  Insight,
-  FullFieldObj extends FieldObject,
+  Raw,
   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>,
+  _QueryOfDoc = QueryOf<Doc>,
+  _Query = FilterQueryOf<FilterRef>,
+  _Sort = FilterSortOf<FilterRef>,
+  _LoaderBuilder extends LoaderBuilder<NoInferType<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
-  >,
+  filterRef: FilterRef,
+  cnst: IntoConstantModel<T, _CapitalizedRefName, Raw>,
   loaderBuilder: _LoaderBuilder,
   ...addMdls: [...AddDbModels]
 ): ModelCls<
-  MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel,
+  IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>,
   ReturnType<_LoaderBuilder>
 > => {
-  const loaderInfoMap = loaderBuilder(makeLoaderBuilder());
+  const loaderInfoMap = loaderBuilder(makeLoaderBuilder<Doc>());
   const libsOnSchemaFns = addMdls.map((mdl) => mdl._onSchema);
   const DefaultModel = Object.assign(class DefaultModel {}, {
     [LOADER_META]: Object.assign({}, ...addMdls.map((mdl) => mdl[LOADER_META]), loaderInfoMap),
@@ -163,7 +158,7 @@ export const into = <
     });
   });
   return DefaultModel as unknown as ModelCls<
-    MergeAllActionTypes<AddDbModels, keyof _DatabaseModel & string> & _DatabaseModel,
+    IntoModelActions<T, _CapitalizedRefName, Doc, Raw, _Query, _Sort, _QueryOfDoc>,
     ReturnType<_LoaderBuilder>
   >;
 };

package/document/types.ts

@@ -25,17 +25,19 @@ export interface FilterArgProps {
   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";

package/fetch/fetchType/endpointFetch.type.ts

@@ -7,6 +7,9 @@ import type {
   EndpInfoReqType,
   EndpointCls,
   EndpointInfo,
+  SlceCnstFull,
+  SlceCnstInsight,
+  SlceCnstLight,
   SliceCls,
 } from "akanjs/signal";
 
@@ -24,9 +27,9 @@ type EndpointClientReturns<E, SlceCls extends SliceCls | never> = [SlceCls] exte
   ? EndpInfoClientReturns<E>
   : ExtendedEndpointReturn<
       EndpInfoClientReturns<E>,
-      SlceCls["srv"]["cnst"]["_Full"],
-      SlceCls["srv"]["cnst"]["_Light"],
-      SlceCls["srv"]["cnst"]["_Insight"]
+      SlceCnstFull<SlceCls>,
+      SlceCnstLight<SlceCls>,
+      SlceCnstInsight<SlceCls>
     >;
 
 type EndpInfoReturns<E, SlceCls extends SliceCls | never> =

package/fetch/fetchType/sliceFetch.type.ts

@@ -2,22 +2,33 @@ 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 _StateLight<S extends SliceCls> = S["srv"]["cnst"]["_StateLight"];
-type _StateInsight<S extends SliceCls> = S["srv"]["cnst"]["_StateInsight"];
-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> : { id: string };
 type _SliceFetchInitOption<S extends SliceCls> = FetchInitOption<_Input<S>, _Filter<S>, _DefaultInput<S>, _Sort<S>>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "2.3.5-rc.9",
+  "version": "2.3.5",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/service/predefinedAdaptor/compress.adaptor.ts

@@ -13,7 +13,7 @@ import {
   type PrimitiveScalar,
 } from "akanjs/base";
 import { Logger } from "akanjs/common";
-import { type ConstantCls, type ConstantField, ConstantRegistry } from "akanjs/constant";
+import { type ConstantCls, type ConstantField, type ConstantModelRef, ConstantRegistry } from "akanjs/constant";
 import { adapt } from "../adapt";
 
 type ProtoType = {
@@ -94,7 +94,7 @@ export class ProtobufCompressor extends adapt("protobufCompressor", () => ({}))
     return this.#proto;
   }
 
-  #getProtoModel(modelRef: ConstantCls<unknown>) {
+  #getProtoModel(modelRef: ConstantModelRef<unknown>) {
     const refName = ConstantRegistry.getRefName(modelRef);
     const predefinedProtoModel = this.#protoModelMap.get(modelRef);
     if (predefinedProtoModel) return predefinedProtoModel;
@@ -140,13 +140,13 @@ export class ProtobufCompressor extends adapt("protobufCompressor", () => ({}))
     const [valueRef] = getNonArrayModel(modelRef);
     return this.#primitiveProtoEncodeMap.get(valueRef) ?? ((value) => value as object);
   }
-  #getRelatedProtoModelRefs(modelRef: ConstantCls, baseModelRefs: ConstantCls[] = []) {
+  #getRelatedProtoModelRefs(modelRef: ConstantModelRef, baseModelRefs: ConstantModelRef[] = []) {
     const allModelRefs = [modelRef, ...baseModelRefs];
     allModelRefs.forEach((mRef) => {
       Object.values(mRef[FIELD_META]).forEach((field) => {
         const relatedRef = field.isMap && field.of ? (field.of as Cls) : field.modelRef;
-        if (!PrimitiveRegistry.has(relatedRef) && !allModelRefs.includes(relatedRef as ConstantCls)) {
-          allModelRefs.push(relatedRef as ConstantCls);
+        if (!PrimitiveRegistry.has(relatedRef) && !allModelRefs.includes(relatedRef as ConstantModelRef)) {
+          allModelRefs.push(relatedRef as ConstantModelRef);
         }
       });
     });
@@ -188,7 +188,7 @@ export class ProtobufCompressor extends adapt("protobufCompressor", () => ({}))
       | boolean
       | null;
   }
-  #makeProtoEncode = <T>(modelRef: ConstantCls<T>): ((value: never) => object) => {
+  #makeProtoEncode = <T>(modelRef: ConstantModelRef<T>): ((value: never) => object) => {
     const predefinedProtoEncode = this.#protoEncodeMap.get(modelRef);
     if (predefinedProtoEncode) return predefinedProtoEncode;
     const protoEncodeFn = (value: T) => {
@@ -286,7 +286,7 @@ export class ProtobufCompressor extends adapt("protobufCompressor", () => ({}))
       | null
       | undefined;
   }
-  #makeProtoDecode<T>(modelRef: ConstantCls<T>): (value: never) => object {
+  #makeProtoDecode<T>(modelRef: ConstantModelRef<T>): (value: never) => object {
     const predefinedProtoDecode = this.#protoDecodeMap.get(modelRef);
     if (predefinedProtoDecode) return predefinedProtoDecode;
     const protoDecodeFn = (value: T) => {
@@ -300,7 +300,7 @@ export class ProtobufCompressor extends adapt("protobufCompressor", () => ({}))
     return protoDecodeFn as (value: never) => object;
   }
   #decode<T>(modelRef: ConstantCls<T>, buffer: Buffer, { raw = false }: { raw?: boolean } = {}): T {
-    const protoModel = this.#getProtoModel(modelRef as unknown as ConstantCls<unknown>);
+    const protoModel = this.#getProtoModel(modelRef as unknown as ConstantModelRef<unknown>);
     const message = protoModel.decode(Buffer.from(buffer));
     const data = protoModel.toObject(message);
     const protoDecode = this.#makeProtoDecode(modelRef);
@@ -326,7 +326,7 @@ export class ProtobufCompressor extends adapt("protobufCompressor", () => ({}))
     const fieldType = isPrimitive ? (this.#protobufTypeMap.get(ref) ?? "string") : refName;
 
     if (!isPrimitive) {
-      const modelRef = ref as ConstantCls;
+      const modelRef = ref as ConstantModelRef;
       const allModelRefs = this.#getRelatedProtoModelRefs(modelRef, [...modelRef.children]);
 
       for (const mRef of allModelRefs) {

package/service/predefinedAdaptor/database.adaptor.ts

@@ -3,7 +3,7 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { mkdir } from "node:fs/promises";
 import path from "node:path";
 import type { InArgs, InValue, Client as LibsqlClient } from "@libsql/client";
-import { type BaseEnv, dayjs, FIELD_META, PRIMITIVE_DEFAULT_VALUE, type PromiseOrObject } from "akanjs/base";
+import { type BaseEnv, DEFAULT_VALUE, dayjs, FIELD_META, type PromiseOrObject } from "akanjs/base";
 import { type ConstantModel, getDefault } from "akanjs/constant";
 import {
   createDocumentId,
@@ -957,9 +957,7 @@ export class SqliteDocumentStore {
             typeof props.default === "function" ? (props.default as (data: unknown) => unknown)(doc) : props.default;
         } else {
           doc[field] =
-            ((props as Record<string, unknown>).modelRef as { [PRIMITIVE_DEFAULT_VALUE]?: unknown })?.[
-              PRIMITIVE_DEFAULT_VALUE
-            ] ?? null;
+            ((props as Record<string, unknown>).modelRef as { [DEFAULT_VALUE]?: unknown })?.[DEFAULT_VALUE] ?? null;
         }
       } else {
         doc[field] = props ? this.decodeFieldValue(value, props) : value;
@@ -1035,9 +1033,7 @@ export class SqliteDocumentStore {
           result[key] = null;
         } else {
           result[key] =
-            ((props as Record<string, unknown>).modelRef as { [PRIMITIVE_DEFAULT_VALUE]?: unknown })?.[
-              PRIMITIVE_DEFAULT_VALUE
-            ] ?? null;
+            ((props as Record<string, unknown>).modelRef as { [DEFAULT_VALUE]?: unknown })?.[DEFAULT_VALUE] ?? null;
         }
       } else {
         result[key] = this.decodeFieldValue(value, props);

package/service/serve.ts

@@ -1,6 +1,6 @@
 import { type Cls, INJECT_META } from "akanjs/base";
 import { applyMixins, capitalize, Logger, lowerlize } from "akanjs/common";
-import type { DatabaseModel, FilterInstance } from "akanjs/document";
+import type { DatabaseModel } from "akanjs/document";
 
 import {
   type ExtractInjectInfoObject,
@@ -9,7 +9,7 @@ import {
   type InjectType,
   injectionBuilder,
 } from "./injectInfo";
-import type { DatabaseService } from "./types";
+import type { DatabaseService, DatabaseServiceForModel } from "./types";
 
 interface ServiceOptions {
   enabled?: boolean;
@@ -17,6 +17,10 @@ interface ServiceOptions {
 }
 export type ServiceType = "database" | "plain";
 
+type DatabaseServiceData = Record<string, unknown>;
+type DatabaseServiceDoc = Record<string, unknown>;
+type DatabaseServicePatch = Partial<DatabaseServiceDoc>;
+
 const avoidKeys = new Set([
   "onInit",
   "onDestroy",
@@ -72,52 +76,17 @@ export function serve<RefName extends string, Injection extends InjectBuilder>(
   injectBuilder: Injection,
   ...extendSrvs: Cls[]
 ): ServiceCls<RefName, {}, ReturnType<Injection>>;
-export 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 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>,
+export function serve<Db extends DatabaseModel, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(
+  db: Db,
   injectBuilder: Injection,
   ...extendSrvs: LibSrvs
-): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
-export 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>,
+): ServiceCls<Db["refName"], DatabaseServiceForModel<Db, LibSrvs>, ReturnType<Injection>>;
+export function serve<Db extends DatabaseModel, Injection extends InjectBuilder, LibSrvs extends Cls[] = []>(
+  db: Db,
   option: ServiceOptions,
   injectBuilder: Injection,
   ...extendSrvs: LibSrvs
-): ServiceCls<T, DatabaseService<T, Input, Doc, Obj, Model, Insight, Filter, LibSrvs>, ReturnType<Injection>>;
+): ServiceCls<Db["refName"], DatabaseServiceForModel<Db, LibSrvs>, ReturnType<Injection>>;
 
 export function serve(
   refNameOrDb: string | DatabaseModel,
@@ -178,29 +147,25 @@ export function serve(
     const preRemoveFns = extSrvs.map((srv) => srv.prototype._preRemove);
     const postRemoveFns = extSrvs.map((srv) => srv.prototype._postRemove);
     Object.assign(srvRef.prototype, {
-      async __libsPreCreate(this: DatabaseService, data: Parameters<DatabaseService["__libsPreCreate"]>[0]) {
+      async __libsPreCreate(this: DatabaseService, data: DatabaseServiceData) {
         let result = data;
         for (const preCreate of preCreateFns) if (preCreate) result = await preCreate.call(this, result);
         if (this._preCreate) result = await this._preCreate(result);
         return result;
       },
-      async __libsPostCreate(this: DatabaseService, doc: Parameters<DatabaseService["__libsPostCreate"]>[0]) {
+      async __libsPostCreate(this: DatabaseService, doc: DatabaseServiceDoc) {
         let result = doc;
         for (const postCreate of postCreateFns) if (postCreate) result = await postCreate.call(this, result);
         if (this._postCreate) result = await this._postCreate(result);
         return result;
       },
-      async __libsPreUpdate(
-        this: DatabaseService,
-        id: string,
-        data: Parameters<DatabaseService["__libsPreUpdate"]>[1],
-      ) {
+      async __libsPreUpdate(this: DatabaseService, id: string, data: DatabaseServicePatch) {
         let result = data;
         for (const preUpdate of preUpdateFns) if (preUpdate) result = await preUpdate.call(this, id, result);
         if (this._preUpdate) result = await this._preUpdate(id, result);
         return result;
       },
-      async __libsPostUpdate(this: DatabaseService, doc: Parameters<DatabaseService["__libsPostUpdate"]>[0]) {
+      async __libsPostUpdate(this: DatabaseService, doc: DatabaseServiceDoc) {
         let result = doc;
         for (const postUpdate of postUpdateFns) if (postUpdate) result = await postUpdate.call(this, result);
         if (this._postUpdate) result = await this._postUpdate(result);
@@ -210,7 +175,7 @@ export function serve(
         for (const preRemove of preRemoveFns) await preRemove?.call(this, id);
         if (this._preRemove) await this._preRemove(id);
       },
-      async __libsPostRemove(this: DatabaseService, doc: Parameters<DatabaseService["__libsPostRemove"]>[0]) {
+      async __libsPostRemove(this: DatabaseService, doc: DatabaseServiceDoc) {
         let result = doc;
         for (const postRemove of postRemoveFns) if (postRemove) result = await postRemove.call(this, result);
         if (this._postRemove) result = await this._postRemove(result);

package/service/types.ts

@@ -3,11 +3,8 @@ import type { Logger } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
 import type {
   CRUDEventType,
-  DatabaseInstance,
+  DatabaseModel,
   DataInputOf,
-  Doc as DbDoc,
-  ExtractQuery,
-  ExtractSort,
   FilterInstance,
   FindQueryOption,
   GetDocObject,
@@ -34,6 +31,49 @@ type ServiceMixinOmitKey =
   | "_libsPreRemove"
   | "_libsPostRemove";
 
+type DatabaseQueryMethods<Query, Sort, Obj, Doc, Insight, FindQueryOption, ListQueryOption, DocQuery> = QueryMethodPart<
+  Query,
+  Sort,
+  Obj,
+  Doc,
+  Insight,
+  FindQueryOption,
+  ListQueryOption,
+  DocQuery
+>;
+
+type DocumentLike = {
+  id: string;
+  set: (...args: never[]) => unknown;
+  save: (...args: never[]) => unknown;
+};
+type MixedLibServiceReturn<Value, Doc, DocObjectOfDoc> = Value extends (infer SingleValue)[]
+  ? SingleValue extends DocumentLike
+    ? DocObjectOfDoc extends GetDocObject<SingleValue>
+      ? Doc[]
+      : Value
+    : Value
+  : Value extends DocumentLike
+    ? DocObjectOfDoc extends GetDocObject<Value>
+      ? Doc
+      : Value
+    : Value;
+type MixedLibServiceMethods<MixedLibSrv, Doc, DocObjectOfDoc> = {
+  [K in keyof MixedLibSrv]: MixedLibSrv[K] extends (...args: infer Args) => Promise<infer Value>
+    ? (...args: Args) => Promise<MixedLibServiceReturn<Value, Doc, DocObjectOfDoc>>
+    : MixedLibSrv[K];
+};
+
+export type DbRefName<Db extends DatabaseModel> = Db["refName"];
+export type DbInput<Db extends DatabaseModel> = Db["_Input"];
+export type DbDoc<Db extends DatabaseModel> = Db["_Doc"];
+export type DbObj<Db extends DatabaseModel> = Db["_Obj"];
+export type DbModel<Db extends DatabaseModel> = Db["_Model"];
+export type DbInsight<Db extends DatabaseModel> = Db["_Insight"];
+export type DbFilter<Db extends DatabaseModel> = Db["_Filter"];
+export type DbQuery<Db extends DatabaseModel> = Db["_Query"];
+export type DbSort<Db extends DatabaseModel> = Db["_Sort"];
+
 export type DatabaseService<
   T extends string = string,
   Input = any,
@@ -43,8 +83,8 @@ export type DatabaseService<
   Insight = any,
   Filter extends FilterInstance = FilterInstance,
   LibSrvs extends Cls[] = [],
-  _Query extends ExtractQuery<Filter> = ExtractQuery<Filter>,
-  _Sort extends ExtractSort<Filter> = ExtractSort<Filter>,
+  _Query = Filter extends FilterInstance ? any : never,
+  _Sort = Filter extends FilterInstance ? any : never,
   _CapitalizedRefName extends Capitalize<T> = Capitalize<T>,
   _DataInputOfDoc extends DataInputOf<Input, Doc> = DataInputOf<Input, Doc>,
   _QueryOfDoc extends QueryOf<Doc> = QueryOf<Doc>,
@@ -96,18 +136,18 @@ export type DatabaseService<
   [K in `update${_CapitalizedRefName}`]: (id: string, data: Partial<Doc>) => Promise<Doc>;
 } & {
   [K in `remove${_CapitalizedRefName}`]: (id: string) => Promise<Doc>;
-} & QueryMethodPart<_Query, _Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> & {
-    [K in keyof _MixedLibSrv]: _MixedLibSrv[K] extends (...args: infer Args) => Promise<infer Value>
-      ? Value extends (infer SingleValue)[]
-        ? SingleValue extends DatabaseInstance
-          ? _DocObjectOfDoc extends GetDocObject<SingleValue>
-            ? (...args: Args) => Promise<Doc[]>
-            : _MixedLibSrv[K]
-          : _MixedLibSrv[K]
-        : Value extends DbDoc<any>
-          ? _DocObjectOfDoc extends GetDocObject<Value>
-            ? (...args: Args) => Promise<Doc>
-            : _MixedLibSrv[K]
-          : _MixedLibSrv[K]
-      : _MixedLibSrv[K];
-  };
+} & DatabaseQueryMethods<_Query, _Sort, Obj, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> &
+  MixedLibServiceMethods<_MixedLibSrv, Doc, _DocObjectOfDoc>;
+
+export type DatabaseServiceForModel<Db extends DatabaseModel, LibSrvs extends Cls[] = []> = DatabaseService<
+  DbRefName<Db>,
+  DbInput<Db>,
+  DbDoc<Db>,
+  DbObj<Db>,
+  DbModel<Db>,
+  DbInsight<Db>,
+  DbFilter<Db>,
+  LibSrvs,
+  DbQuery<Db>,
+  DbSort<Db>
+>;

package/signal/endpoint.ts

@@ -3,6 +3,7 @@ import { ENDPOINT_META } from "akanjs/base";
 import { applyMixins } from "akanjs/common";
 import { type Adaptor, type AdaptorCls, dangerouslyAdapt, type ServiceModel } from "akanjs/service";
 import { buildEndpoint, type EndpointBuilder, type EndpointInfo } from "./endpointInfo";
+import type { SrvRefName } from "./types";
 
 export interface Endpoint extends Adaptor {}
 
@@ -10,7 +11,7 @@ export interface EndpointCls<
   SrvModule extends ServiceModel = ServiceModel,
   EndpointInfoObj extends { [key: string]: EndpointInfo } = { [key: string]: EndpointInfo },
 > extends AdaptorCls {
-  baseName: SrvModule["srv"]["refName"];
+  baseName: SrvRefName<SrvModule>;
   srv: SrvModule;
   [ENDPOINT_META]: EndpointInfoObj;
 }