akanjs 3.0.0-beta.2 → 3.0.0-beta.20

package/server/resolver/CascadeRunner.ts

@@ -29,21 +29,17 @@ interface CascadePlan {
   readonly withEdges: WithEdge[];
 }
 
-/** One cascade in flight. Shared down the chain so a cycle is caught wherever it closes. */
 interface CascadeContext {
   readonly seen: Set<string>;
   readonly depth: number;
 }
 
-/** How deep one removal may cascade before the chain is treated as runaway and abandoned. */
 const maxDepth = 16;
-/** Ids taken per query while draining children one document at a time. */
 const drainSize = 200;
 
 export class CascadeRunner {
   readonly #modules = new Map<string, CascadeModule>();
   readonly #plans = new Map<string, CascadePlan>();
-  /** `removeWithAny` edges: the owner is unknowable at boot, so every model's removal has to sweep them. */
   readonly #anyEdges: WithEdge[] = [];
   readonly #bulk = new Set<string>();
   readonly #context = new AsyncLocalStorage<CascadeContext>();
@@ -54,19 +50,14 @@ export class CascadeRunner {
     this.#modules.set(constant.refName, { constant, schema, srvRef });
   }
 
-  /**
-   * Called once every service is live. A `_postRemove` and a `listenPost("remove")` registered during boot both
-   * count against bulk removal, so the strategy cannot be decided before the last service has initialized.
-   */
   seal(getService: (refName: string) => DatabaseService) {
     this.#getService = getService;
     for (const [refName, mod] of this.#modules) {
       this.#plans.set(refName, { refEdges: this.#collectRefEdges(refName, mod), withEdges: [] });
     }
     for (const [refName, mod] of this.#modules) this.#collectWithEdges(refName, mod);
-    for (const refName of this.#modules.keys()) {
-      if (this.#hasRemoveSideEffect(refName)) continue;
-      this.#bulk.add(refName);
+    for (const [refName, mod] of this.#modules) {
+      if (!this.#hasRemoveSideEffect(refName, mod)) this.#bulk.add(refName);
     }
     this.#report();
   }
@@ -103,7 +94,7 @@ export class CascadeRunner {
       await service.__removeMany({ id: documentQueryHelper.oneOf(ids) });
       return;
     }
-
+    
     for (const id of ids) await service.__remove(id);
   }
 
@@ -114,7 +105,7 @@ export class CascadeRunner {
       await service.__removeMany(query);
       return;
     }
-
+    
     for (;;) {
       const ids = await service.__listIds(query, { limit: drainSize });
       if (!ids.length) return;
@@ -131,7 +122,6 @@ export class CascadeRunner {
   #collectRefEdges(refName: string, mod: CascadeModule) {
     return [...mod.constant.full.cascade.removeRef].map(([key, modelRef]) => {
       const target = ConstantRegistry.getRefName(modelRef);
-
       if (!this.#modules.has(target)) {
         throw new Error(`Cascade field "${refName}.${key}" removes "${target}", which this app does not mount`);
       }
@@ -153,7 +143,7 @@ export class CascadeRunner {
 
   #resolveOwners(childRef: string, key: string, path: CascadeWithPath) {
     if (path.typeValues.length) {
-
+      
       const mounted = path.typeValues.filter((owner) => this.#modules.has(owner));
       for (const owner of path.typeValues) {
         if (mounted.includes(owner)) continue;
@@ -168,11 +158,8 @@ export class CascadeRunner {
     return [owner];
   }
 
-  /** Everything a bulk `removeMany` would skip. All of it absent means the two paths leave the same rows behind. */
-  #hasRemoveSideEffect(refName: string) {
-    const mod = this.#modules.get(refName);
-    if (!mod) return true;
-
+  #hasRemoveSideEffect(refName: string, mod: CascadeModule) {
+    
     if (this.#anyEdges.length) return true;
     if (mod.schema.preHooks.get("remove")?.length || mod.schema.postHooks.get("remove")?.length) return true;
     if ((mod.srvRef as unknown as { [LIBS_REMOVE_HOOK]?: boolean })[LIBS_REMOVE_HOOK]) return true;
@@ -182,8 +169,6 @@ export class CascadeRunner {
     return !!plan?.refEdges.length || !!plan?.withEdges.length;
   }
 
-  /** Neither the strategy nor the edge list is visible from the source, and adding a `_postRemove` to a target
-   * silently flips it from one query back to one per document. A quiet cascade is the one nobody can explain. */
   #report() {
     const lines: string[] = [];
     for (const [refName, plan] of this.#plans) {
@@ -202,7 +187,6 @@ export class CascadeRunner {
     const bulk = lines.filter((line) => line.endsWith("(bulk)")).length;
     this.#logger.verbose(`${lines.length} cascade edge(s), ${bulk} in one query`);
     for (const line of lines) this.#logger.verbose(line);
-
     if (!this.#anyEdges.length) return;
     const wildcards = this.#anyEdges.map((edge) => `${edge.refName}.${edge.key}`).join(", ");
     this.#logger.verbose(

package/server/resolver/database.resolver.ts

@@ -13,7 +13,6 @@ import {
   type DocumentUpdateInput,
   documentQueryHelper,
   type FindQueryOption,
-  getFilterInfoByKey,
   getFilterMeta,
   getFilterSortByKey,
   getLoaderInfos,
@@ -21,8 +20,6 @@ import {
   type Mdl,
   NoDocumentError,
   type SaveEventType,
-  splitFilterArgs,
-  type UpdateChain,
 } from "akanjs/document";
 import {
   type AdaptorCls,
@@ -31,13 +28,10 @@ import {
   type DatabaseAdaptor,
   DatabaseAdaptorRole,
   type DocumentStore,
+  ServiceModel,
 } from "akanjs/service";
 import { Exception, getCurrentTrace, traceDataLoaderBatch } from "akanjs/signal";
 
-/**
- * Times a store query and records it against the active request trace (no-op when
- * tracing is disabled). Used to surface "queries per request" and DB latency share.
- */
 const timedQuery = async <T>(fn: () => Promise<T>): Promise<T> => {
   const trace = getCurrentTrace();
   if (!trace) return await fn();
@@ -50,7 +44,15 @@ const timedQuery = async <T>(fn: () => Promise<T>): Promise<T> => {
 };
 
 export class DatabaseResolver {
-  /** Returns the schema alongside the adaptor: the cascade planner reads its `remove` hooks to pick a strategy. */
+  
+  static applyFilterMethods(prototype: object, database: DatabaseModel, className: string) {
+    Object.entries(getFilterMeta(database.filter).query).forEach(([queryKey, filterInfo]) => {
+      const filterMethods = ServiceModel.getFilterServiceMethods(queryKey, filterInfo);
+      assertFilterFitsCrud(database.refName, queryKey, className);
+      Object.assign(prototype, filterMethods);
+    });
+  }
+
   static resolveDatabase(
     constant: ConstantModel,
     database: DatabaseModel,
@@ -63,24 +65,22 @@ export class DatabaseResolver {
       if (!sort) throw new Exception.BadRequest(`Unknown sort key for ${modelName}: ${sortKey}`);
       return sort;
     };
-    const getListQuery = (query?: QueryOf<any>, queryOption?: ListQueryOption) => {
-      const find = query ?? {};
-      const sort = resolveSort(queryOption?.sort);
-      const skip = resolvePageSkip(queryOption?.skip);
+    const getListQuery = (query?: QueryOf<any>, queryOption?: ListQueryOption) => ({
+      find: query ?? {},
+      sort: resolveSort(queryOption?.sort),
+      skip: resolvePageSkip(queryOption?.skip),
 
-      const limit = queryOption?.limit === undefined ? 0 : resolvePageLimit(queryOption.limit);
-      const select = queryOption?.select;
-      const sample = queryOption?.sample;
-      return { find, sort, skip, limit, select, sample };
-    };
-    const getFindQuery = (query?: QueryOf<any>, queryOption?: FindQueryOption) => {
-      const find = query ?? {};
-      const sort = resolveSort(queryOption?.sort);
-      const skip = resolvePageSkip(queryOption?.skip);
-      const select = queryOption?.select;
-      const sample = queryOption?.sample ?? false;
-      return { find, sort, skip, select, sample };
-    };
+      limit: queryOption?.limit === undefined ? 0 : resolvePageLimit(queryOption.limit),
+      select: queryOption?.select,
+      sample: queryOption?.sample,
+    });
+    const getFindQuery = (query?: QueryOf<any>, queryOption?: FindQueryOption) => ({
+      find: query ?? {},
+      sort: resolveSort(queryOption?.sort),
+      skip: resolvePageSkip(queryOption?.skip),
+      select: queryOption?.select,
+      sample: queryOption?.sample ?? false,
+    });
     const schema = new DocumentSchema();
     database.model._onSchema(schema as any);
     database.model._libsOnSchema(schema as any);
@@ -96,7 +96,7 @@ export class DatabaseResolver {
       indexedSortFieldKeys.add(key);
       schema.index(fields);
     }
-
+    
     for (const path of constant.full.cascade.removeWith.values()) {
       const fields = path.typeKey
         ? { removedAt: 1, [path.typeKey]: 1, [path.key]: 1 }
@@ -155,37 +155,40 @@ export class DatabaseResolver {
         });
         Object.entries(getLoaderInfos(database.model)).forEach(([key, loaderInfo]) => {
           Object.assign(this, {
-            [key]: new DataLoader<any, any>(async (keys) => {
-              traceDataLoaderBatch(keys.length);
-              if (loaderInfo.type === "query") {
-                const fields = loaderInfo.field as string[];
-                const query = { kind: "any", queries: keys } as QueryOf<unknown>;
+            [key]: new DataLoader<any, any>(
+              async (keys) => {
+                traceDataLoaderBatch(keys.length);
+                if (loaderInfo.type === "query") {
+                  const fields = loaderInfo.field as string[];
+                  const query = { kind: "any", queries: keys } as QueryOf<unknown>;
+                  const docs = await timedQuery(() =>
+                    this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
+                  );
+                  const keyOf = (row: Record<string, unknown>) =>
+                    JSON.stringify(fields.map((field) => String(row[field])));
+                  const byKey = new Map(docs.map((doc) => [keyOf(doc), doc]));
+                  return keys.map((queryKey) => byKey.get(keyOf(queryKey)) ?? null);
+                }
+                const field = loaderInfo.field as string;
+                const query = {
+                  [field]: documentQueryHelper.oneOf([...keys]),
+                };
                 const docs = await timedQuery(() =>
                   this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
                 );
-                const byKey = new Map(docs.map((doc) => [fields.map((field) => String(doc[field])).join(""), doc]));
-                return keys.map(
-                  (queryKey) => byKey.get(fields.map((field) => String(queryKey[field])).join("")) ?? null,
-                );
-              }
-              const field = loaderInfo.field as string;
-              const query = {
-                [field]: documentQueryHelper.oneOf([...keys]),
-              };
-              const docs = await timedQuery(() =>
-                this.__store.find(documentQueryHelper.all(loaderInfo.defaultQuery, query)),
-              );
-              if (loaderInfo.type === "arrayField") {
-                const byKey = new Map<string, unknown>();
-                for (const doc of docs) {
-                  const values = Array.isArray(doc[field]) ? doc[field] : [];
-                  for (const value of values) if (!byKey.has(String(value))) byKey.set(String(value), doc);
+                if (loaderInfo.type === "arrayField") {
+                  const byKey = new Map<string, unknown>();
+                  for (const doc of docs) {
+                    const values = Array.isArray(doc[field]) ? doc[field] : [];
+                    for (const value of values) if (!byKey.has(String(value))) byKey.set(String(value), doc);
+                  }
+                  return keys.map((key) => byKey.get(String(key)) ?? null);
                 }
+                const byKey = new Map(docs.map((doc) => [String(doc[field]), doc]));
                 return keys.map((key) => byKey.get(String(key)) ?? null);
-              }
-              const byKey = new Map(docs.map((doc) => [String(doc[field]), doc]));
-              return keys.map((key) => byKey.get(String(key)) ?? null);
-            }),
+              },
+              { name: key, cache: loaderInfo.cache },
+            ),
           });
         });
       }
@@ -254,7 +257,7 @@ export class DatabaseResolver {
           pickOne: (query: QueryOf<any>, projection?: any) =>
             timedQuery(() => store.pickOne(query, { select: projection })),
           pickById,
-
+          
           pickAndWrite: async (id: string, rawData: any) => await (await pickById(id)).set(rawData).save(),
           pickOneAndWrite: async (query: QueryOf<any>, rawData: any) =>
             await (await timedQuery(() => store.pickOne(query))).set(rawData).save(),
@@ -387,76 +390,7 @@ export class DatabaseResolver {
       }
     }
 
-    const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
-      const filterInfo = getFilterInfoByKey(database.filter, queryKey);
-      const queryFn = filterInfo.queryFn;
-      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
-      const { queryArgs, queryOption } = splitFilterArgs(filterInfo, args);
-      return { query: queryFn(...queryArgs, documentQueryHelper), queryOption };
-    };
-    Object.entries(filterMeta.query).forEach(([queryKey, filterInfo]) => {
-      const queryFn = filterInfo.queryFn;
-      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
-      assertFilterFitsCrud(modelName, queryKey, className);
-      Object.assign(DatabaseModelInstance.prototype, {
-        [`list${capitalize(queryKey)}`]: async function (...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return (this as unknown as DatabaseInstance).__list(query, queryOption);
-        },
-        [`listIds${capitalize(queryKey)}`]: async function (...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return (this as unknown as DatabaseInstance).__listIds(query, queryOption);
-        },
-        [`find${capitalize(queryKey)}`]: async function (...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return (this as unknown as DatabaseInstance).__find(query, queryOption);
-        },
-        [`findId${capitalize(queryKey)}`]: async function (...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return (this as unknown as DatabaseInstance).__findId(query, queryOption);
-        },
-        [`pick${capitalize(queryKey)}`]: async function (...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return (this as unknown as DatabaseInstance).__pick(query, queryOption);
-        },
-        [`pickId${capitalize(queryKey)}`]: async function (...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return (this as unknown as DatabaseInstance).__pickId(query, queryOption);
-        },
-        [`exists${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-          return (this as unknown as DatabaseInstance).__exists(query);
-        },
-        [`count${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-          return (this as unknown as DatabaseInstance).__count(query);
-        },
-        [`insight${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-          return (this as unknown as DatabaseInstance).__insight(query);
-        },
-        [`query${capitalize(queryKey)}`]: (...args: any) =>
-          queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper),
-        [`remove${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-          return (this as unknown as DatabaseInstance).__removeMany(query);
-        },
-        [`removeOne${capitalize(queryKey)}`]: async function (...args: any) {
-          const query = queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-          return (this as unknown as DatabaseInstance).__removeOne(query);
-        },
-        [`update${capitalize(queryKey)}`]: function (...args: any): UpdateChain {
-          const instance = this as unknown as DatabaseInstance;
-          const query = queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-          return { set: (update) => instance.__updateMany(query, update) };
-        },
-        [`updateOne${capitalize(queryKey)}`]: function (...args: any): UpdateChain {
-          const instance = this as unknown as DatabaseInstance;
-          const query = queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-          return { set: (update) => instance.__updateOne(query, update) };
-        },
-      });
-    });
+    DatabaseResolver.applyFilterMethods(DatabaseModelInstance.prototype, database, className);
     applyMixins(DatabaseModelInstance, [database.model]);
     return {
       adaptor: DatabaseModelInstance as unknown as AdaptorCls<DatabaseInstance<any, any, any, any, any, any>>,

package/server/resolver/service.resolver.ts

@@ -1,103 +1,27 @@
-import type { PromiseOrObject } from "akanjs/base";
 import { capitalize } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
-import {
-  assertFilterFitsCrud,
-  type CRUDEventType,
-  type DatabaseModel,
-  type DataInputOf,
-  type Doc,
-  type DocumentUpdateInput,
-  documentQueryHelper,
-  type FindQueryOption,
-  getFilterInfoByKey,
-  getFilterMeta,
-  type ListQueryOption,
-  type SaveEventType,
-  splitFilterArgs,
-  type UpdateChain,
-} from "akanjs/document";
-import type { DatabaseService, ServiceCls } from "akanjs/service";
+import type { DatabaseModel, DataInputOf, Doc, DocumentUpdateInput } from "akanjs/document";
+import { type DatabaseService, type ServiceCls, ServiceModel } from "akanjs/service";
 import type { CascadeRunner } from "./CascadeRunner";
+import { DatabaseResolver } from "./database.resolver";
 
 export class ServiceResolver {
   static #getDefaultDbServiceMethods(refName: string, className: string, cascade: CascadeRunner) {
-    const dbServiceMethods = {
-      async __get(this: DatabaseService, id: string) {
-        return await this.__databaseModel.__get(id);
-      },
-      async [`get${className}`](this: DatabaseService, id: string) {
-        return this.__get(id);
-      },
-      async __load(this: DatabaseService, id?: string) {
-        return await this.__databaseModel.__load(id);
-      },
-      async [`load${className}`](this: DatabaseService, id?: string) {
-        return this.__load(id);
-      },
-      async __loadMany(this: DatabaseService, ids: string[]) {
-        return await this.__databaseModel.__loadMany(ids);
-      },
-      async [`load${className}Many`](this: DatabaseService, ids: string[]) {
-        return this.__loadMany(ids);
-      },
-      async __list(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
-        return await this.__databaseModel.__list(query, queryOption);
-      },
-      async __listIds(this: DatabaseService, query: QueryOf<any>, queryOption?: ListQueryOption) {
-        return await this.__databaseModel.__listIds(query, queryOption);
-      },
-      async __find(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__find(query, queryOption);
-      },
-      async __findId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__findId(query, queryOption);
-      },
-      async __pick(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__pick(query, queryOption);
-      },
-      async __pickId(this: DatabaseService, query: QueryOf<any>, queryOption?: FindQueryOption) {
-        return await this.__databaseModel.__pickId(query, queryOption);
-      },
-      async __exists(this: DatabaseService, query: QueryOf<any>) {
-        return await this.__databaseModel.__exists(query);
-      },
-      async __count(this: DatabaseService, query: QueryOf<any>) {
-        return await this.__databaseModel.__count(query);
-      },
-      async __insight(this: DatabaseService, query: QueryOf<any>) {
-        return await this.__databaseModel.__insight(query);
-      },
-      listenPre(
-        this: DatabaseService,
-        type: SaveEventType,
-        listener: (doc: Doc, type: CRUDEventType, previous?: Doc) => PromiseOrObject<void>,
-      ) {
-        return this.__databaseModel.listenPre(type, listener);
-      },
-      listenPost(
-        this: DatabaseService,
-        type: SaveEventType,
-        listener: (doc: Doc, type: CRUDEventType, previous?: Doc) => PromiseOrObject<void>,
-      ) {
-        return this.__databaseModel.listenPost(type, listener);
-      },
+    
+    const { _preCreate, _postCreate, _preUpdate, _postUpdate, _preRemove, _postRemove, ...methods } =
+      ServiceModel.getDefaultDbServiceMethods(className);
+    return {
+      ...methods,
       async __create(this: DatabaseService, data: DataInputOf) {
         const input = await this.__libsPreCreate(data);
         const doc = await this.__databaseModel.__create(input);
         return await this.__libsPostCreate(doc);
       },
-      async [`create${className}`](this: DatabaseService, data: DataInputOf) {
-        return this.__create(data);
-      },
       async __update(this: DatabaseService, id: string, data: DataInputOf) {
         const input = await this.__libsPreUpdate(id, data);
         const doc = await this.__databaseModel.__update(id, input);
         return await this.__libsPostUpdate(doc);
       },
-      async [`update${className}`](this: DatabaseService, id: string, data: DataInputOf) {
-        return this.__update(id, data);
-      },
       async __remove(this: DatabaseService, id: string): Promise<Doc> {
         await this.__libsPreRemove(id);
         const doc = await this.__databaseModel.__remove(id);
@@ -105,9 +29,6 @@ export class ServiceResolver {
         await cascade.run(refName, removed as Record<string, unknown>);
         return removed;
       },
-      async [`remove${className}`](this: DatabaseService, id: string): Promise<Doc> {
-        return this.__remove(id);
-      },
       async __removeMany(this: DatabaseService, query: QueryOf<any>) {
         return await this.__databaseModel.__removeMany(query);
       },
@@ -121,84 +42,11 @@ export class ServiceResolver {
         return await this.__databaseModel.__updateOne(query, update);
       },
     };
-    return dbServiceMethods;
   }
   static resolveDatabaseService(database: DatabaseModel, srvRef: ServiceCls, cascade: CascadeRunner): ServiceCls {
     const className = capitalize(database.refName);
     Object.assign(srvRef.prototype, ServiceResolver.#getDefaultDbServiceMethods(database.refName, className, cascade));
-    const getQueryDataFromKey = (queryKey: string, args: any): { query: any; queryOption: any } => {
-      const filterInfo = getFilterInfoByKey(database.filter, queryKey);
-      const queryFn = filterInfo.queryFn;
-      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
-      const { queryArgs, queryOption } = splitFilterArgs(filterInfo, args);
-      return { query: queryFn(...queryArgs, documentQueryHelper), queryOption };
-    };
-    const filterMeta = getFilterMeta(database.filter);
-    const queryKeys = Object.keys(filterMeta.query);
-    queryKeys.forEach((queryKey) => {
-      const filterInfo = getFilterInfoByKey(database.filter, queryKey);
-      const queryFn = filterInfo.queryFn;
-      if (!queryFn) throw new Error(`No query function for key: ${queryKey}`);
-      const capitalizedQueryKey = capitalize(queryKey);
-      assertFilterFitsCrud(database.refName, queryKey, className);
-      Object.assign(srvRef.prototype, {
-        [`list${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__list(query, queryOption);
-        },
-        [`listIds${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__listIds(query, queryOption);
-        },
-        [`find${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__find(query, queryOption);
-        },
-        [`findId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__findId(query, queryOption);
-        },
-        [`pick${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__pick(query, queryOption);
-        },
-        [`pickId${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-          return this.__pickId(query, queryOption);
-        },
-        [`exists${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__exists(query);
-        },
-        [`count${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__count(query);
-        },
-        [`insight${capitalize(queryKey)}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__insight(query);
-        },
-        [`query${capitalize(queryKey)}`]: function (this: DatabaseService, ...args: any) {
-          return queryFn(...splitFilterArgs(filterInfo, args).queryArgs, documentQueryHelper);
-        },
-        [`remove${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__removeMany(query);
-        },
-        [`removeOne${capitalizedQueryKey}`]: async function (this: DatabaseService, ...args: any) {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return this.__removeOne(query);
-        },
-        [`update${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any): UpdateChain {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return { set: (update) => this.__updateMany(query, update) };
-        },
-        [`updateOne${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any): UpdateChain {
-          const { query } = getQueryDataFromKey(queryKey, args);
-          return { set: (update) => this.__updateOne(query, update) };
-        },
-      });
-    });
+    DatabaseResolver.applyFilterMethods(srvRef.prototype, database, className);
     return srvRef;
   }
 }