akanjs 3.0.0-alpha.2 → 3.0.0-alpha.3

package/document/database.ts

@@ -3,6 +3,7 @@ import { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions } from "akanjs/service";
 import type { DataLoader } from "./dataLoader";
+import type { DocumentUpdateInput } from "./documentQuery";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
 import type { CRUDEventType, Mdl, SaveEventType, UpdateResult } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
@@ -25,6 +26,15 @@ export class CacheDatabase<T = unknown> {
     await this.cache.delete(this.refName, `${topic}:${key}`);
   }
 }
+/**
+ * What `update<Filter>` returns. The patch cannot be a trailing parameter — a filter's own args may be optional,
+ * and no tuple type puts a required element after those — and leading it reads backwards. So it lands here, on a
+ * terminal `.set()` that mirrors the `UPDATE … SET …` it compiles to.
+ */
+export interface UpdateChain<Doc = any> {
+  set(update: DocumentUpdateInput<Doc>): Promise<UpdateResult>;
+}
+
 type QueryMethodOfKey<
   CapitalizedK extends string,
   Doc,
@@ -53,6 +63,14 @@ type QueryMethodOfKey<
   [K in `insight${CapitalizedK}`]: (...args: _Args) => Promise<Insight>;
 } & {
   [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
+} & {
+  [K in `remove${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+  [K in `removeOne${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+  [K in `update${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
+} & {
+  [K in `updateOne${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
 };
 type QueryMethodMap<Query, Doc, Insight, _FindQueryOption, _ListQueryOption, _QueryOfDoc> = {
   [K in keyof Query]: K extends string
@@ -106,6 +124,9 @@ type DatabaseModelWithQuerySort<
   __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
   __remove: (id: string) => Promise<Doc>;
   __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+  __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
   __listIds(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
   __find(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;

package/document/filterMeta.ts

@@ -98,6 +98,13 @@ export const fillMissingFilterArgs = (filterInfo: FilterInfo, args: unknown[]) =
   return [...args, ...Array(filterInfo.args.length - args.length).fill(undefined)];
 };
 
+export const assertFilterFitsCrud = (refName: string, queryKey: string, className: string) => {
+  if (queryKey.toLowerCase() !== refName.toLowerCase()) return;
+  throw new Error(
+    `Filter "${queryKey}" on "${refName}" generates remove${className}/update${className}, which are the generated CRUD methods; rename the filter`,
+  );
+};
+
 export type BaseFilterSortKey = "latest" | "oldest" | "relevance";
 export type BaseFilterQueryKey = "any";
 export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;

package/document/into.ts

@@ -77,16 +77,20 @@ export type Mdl<
   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>;
+  count(query: _RawQuery): Promise<number>;
   exists(query: _RawQuery): Promise<string | null>;
+
   updateOne(
     query: _RawQuery,
     update: DocumentUpdateInput<_RawDoc>,
     options?: DocumentUpdateOptions,
   ): Promise<UpdateResult>;
   updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>): Promise<UpdateResult>;
+  removeOne(query: _RawQuery): Promise<UpdateResult>;
   removeMany(query: _RawQuery): Promise<UpdateResult>;
   bulkWrite(operations: BulkWriteOperation<Raw, _RawDoc, _RawQuery>[]): Promise<UpdateResult>;
+  /** @deprecated Renamed to `count`. */
+  countDocuments(query: _RawQuery): Promise<number>;
 };
 
 interface IntoConstantModel<T extends string, _CapitalizedRefName extends string, Raw, Insight> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akanjs",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.3",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {

package/server/resolver/database.resolver.ts

@@ -2,6 +2,7 @@ import type { PromiseOrObject } from "akanjs/base";
 import { applyMixins, capitalize } from "akanjs/common";
 import { type ConstantModel, DEFAULT_PAGE_SIZE, type QueryOf } from "akanjs/constant";
 import {
+  assertFilterFitsCrud,
   CacheDatabase,
   type CRUDEventType,
   type DatabaseInstance,
@@ -20,6 +21,7 @@ import {
   type ListQueryOption,
   type Mdl,
   type SaveEventType,
+  type UpdateChain,
 } from "akanjs/document";
 import {
   type AdaptorCls,
@@ -232,11 +234,14 @@ export class DatabaseResolver {
           find: (query: QueryOf<any>) => createFindManyChain(query),
           findOne: (query: QueryOf<any>) => createFindOneChain(query),
           findById: (id: string | undefined) => (id ? store.findOne({ id }) : Promise.resolve(null)),
-          countDocuments: (query: QueryOf<any>) => store.count(query),
+          count: (query: QueryOf<any>) => store.count(query),
           updateOne: (query: QueryOf<any>, update: DocumentUpdateInput, options?: { upsert?: boolean }) =>
             store.updateOneByQuery(query, update, options),
           updateMany: (query: QueryOf<any>, update: DocumentUpdateInput) => store.updateManyByQuery(query, update),
+          removeOne: (query: QueryOf<any>) => store.removeOneByQuery(query),
           removeMany: (query: QueryOf<any>) => store.removeManyByQuery(query),
+          
+          countDocuments: (query: QueryOf<any>) => store.count(query),
           bulkWrite: (
             operations: { updateOne: { filter: QueryOf<any>; update: DocumentUpdateInput; upsert?: boolean } }[],
           ) => store.bulkWrite(operations),
@@ -339,6 +344,15 @@ export class DatabaseResolver {
       async __removeMany(query: QueryOf<any>) {
         return await timedQuery(() => this.__store.removeManyByQuery(query));
       }
+      async __removeOne(query: QueryOf<any>) {
+        return await timedQuery(() => this.__store.removeOneByQuery(query));
+      }
+      async __updateMany(query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await timedQuery(() => this.__store.updateManyByQuery(query, update));
+      }
+      async __updateOne(query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await timedQuery(() => this.__store.updateOneByQuery(query, update));
+      }
       async [`remove${className}`](id: string) {
         return this.__remove(id);
       }
@@ -364,6 +378,7 @@ export class DatabaseResolver {
     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);
@@ -403,6 +418,24 @@ export class DatabaseResolver {
         },
         [`query${capitalize(queryKey)}`]: (...args: any) =>
           queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper),
+        [`remove${capitalize(queryKey)}`]: async function (...args: any) {
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
+          return (this as unknown as DatabaseInstance).__removeMany(query);
+        },
+        [`removeOne${capitalize(queryKey)}`]: async function (...args: any) {
+          const query = queryFn(...fillMissingFilterArgs(filterInfo, args), 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(...fillMissingFilterArgs(filterInfo, args), 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(...fillMissingFilterArgs(filterInfo, args), documentQueryHelper);
+          return { set: (update) => instance.__updateOne(query, update) };
+        },
       });
     });
     applyMixins(DatabaseModelInstance, [database.model]);

package/server/resolver/service.resolver.ts

@@ -2,10 +2,12 @@ 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,
   fillMissingFilterArgs,
@@ -13,6 +15,7 @@ import {
   getFilterMeta,
   type ListQueryOption,
   type SaveEventType,
+  type UpdateChain,
 } from "akanjs/document";
 import type { DatabaseService, ServiceCls } from "akanjs/service";
 import type { CascadeRunner } from "./CascadeRunner";
@@ -108,6 +111,15 @@ export class ServiceResolver {
       async __removeMany(this: DatabaseService, query: QueryOf<any>) {
         return await this.__databaseModel.__removeMany(query);
       },
+      async __removeOne(this: DatabaseService, query: QueryOf<any>) {
+        return await this.__databaseModel.__removeOne(query);
+      },
+      async __updateMany(this: DatabaseService, query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await this.__databaseModel.__updateMany(query, update);
+      },
+      async __updateOne(this: DatabaseService, query: QueryOf<any>, update: DocumentUpdateInput) {
+        return await this.__databaseModel.__updateOne(query, update);
+      },
     };
     return dbServiceMethods;
   }
@@ -138,6 +150,7 @@ export class ServiceResolver {
       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);
@@ -178,6 +191,22 @@ export class ServiceResolver {
         [`query${capitalize(queryKey)}`]: function (this: DatabaseService, ...args: any) {
           return queryFn(...fillMissingFilterArgs(filterInfo, args), 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) };
+        },
       });
     });
     return srvRef;

package/service/predefinedAdaptor/database.adaptor.ts

@@ -98,6 +98,9 @@ export interface DocumentStore {
   removeManyByQuery(
     query: DocumentQuery,
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number }>;
+  removeOneByQuery(
+    query: DocumentQuery,
+  ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number; upsertedId: string | null }>;
   bulkWrite(
     operations: { updateOne: { filter: DocumentQuery; update: DocumentUpdateInput; upsert?: boolean } }[],
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number; upsertedId: string | null }>;
@@ -1086,6 +1089,11 @@ export class SqlDocumentStore {
     return this.updateManyByQuery(query, { removedAt: dayjs() });
   }
 
+  async removeOneByQuery(query: DocumentQuery) {
+
+    return this.updateOneByQuery(query, { removedAt: dayjs() });
+  }
+
   private compiledUpdate(update: DocumentUpdate) {
     const compiled = this.updateCompiler.compile(update);
     return {

package/service/serviceModule.ts

@@ -9,6 +9,7 @@ import type {
   FindQueryOption,
   ListQueryOption,
   SaveEventType,
+  UpdateChain,
 } from "akanjs/document";
 import type { ServiceCls } from "./serve";
 import type { DatabaseService } from "./types";
@@ -210,6 +211,22 @@ export class ServiceModel<
       [`query${capitalizedQueryKey}`]: function (this: DatabaseService, ...args: any) {
         return queryFn(...args);
       },
+      [`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) };
+      },
     };
     return filterServiceMethods;
   }

package/service/types.ts

@@ -5,6 +5,7 @@ import type {
   CRUDEventType,
   DatabaseModel,
   DataInputOf,
+  DocumentUpdateInput,
   FilterInstance,
   FindQueryOption,
   GetDocObject,
@@ -103,6 +104,9 @@ export type DatabaseService<
   __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
   __remove: (id: string) => Promise<Doc>;
   __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+  __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+  __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
   __list(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
   __listIds(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
   __find(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;

package/types/document/database.d.ts

@@ -3,6 +3,7 @@ import { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions } from "akanjs/service";
 import type { DataLoader } from "./dataLoader.d.ts";
+import type { DocumentUpdateInput } from "./documentQuery.d.ts";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta.d.ts";
 import type { CRUDEventType, Mdl, SaveEventType, UpdateResult } from "./into.d.ts";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types.d.ts";
@@ -15,6 +16,14 @@ export declare class CacheDatabase<T = unknown> {
     get<T extends string | number | Buffer>(topic: string, key: string): Promise<T | undefined>;
     delete(topic: string, key: string): Promise<void>;
 }
+/**
+ * What `update<Filter>` returns. The patch cannot be a trailing parameter — a filter's own args may be optional,
+ * and no tuple type puts a required element after those — and leading it reads backwards. So it lands here, on a
+ * terminal `.set()` that mirrors the `UPDATE … SET …` it compiles to.
+ */
+export interface UpdateChain<Doc = any> {
+    set(update: DocumentUpdateInput<Doc>): Promise<UpdateResult>;
+}
 type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends any[], _ListArgs extends any[], _FindArgs extends any[], _QueryOfDoc = QueryOf<Doc>> = {
     [K in `list${CapitalizedK}`]: (...args: _ListArgs) => Promise<Doc[]>;
 } & {
@@ -35,6 +44,14 @@ type QueryMethodOfKey<CapitalizedK extends string, Doc, Insight, _Args extends a
     [K in `insight${CapitalizedK}`]: (...args: _Args) => Promise<Insight>;
 } & {
     [K in `query${CapitalizedK}`]: (...args: _Args) => _QueryOfDoc;
+} & {
+    [K in `remove${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+    [K in `removeOne${CapitalizedK}`]: (...args: _Args) => Promise<UpdateResult>;
+} & {
+    [K in `update${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
+} & {
+    [K in `updateOne${CapitalizedK}`]: (...args: _Args) => UpdateChain<Doc>;
 };
 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, [
@@ -58,6 +75,9 @@ type DatabaseModelWithQuerySort<T extends string, Input, Doc, Obj, Insight, Quer
     __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
     __remove: (id: string) => Promise<Doc>;
     __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
+    __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+    __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+    __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
     __list(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
     __listIds(query: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
     __find(query: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;

package/types/document/filterMeta.d.ts

@@ -19,6 +19,7 @@ export declare const getFilterInfoByKey: <ArgNames extends string[] = [], Args e
 export declare const setFilterInfoByKey: <ArgNames extends string[] = [], Args extends any[] = any[], Model = any>(modelRef: Cls<Model>, key: string, filterInfo: FilterInfo<ArgNames, Args, Model>) => void;
 export declare const getFilterSortByKey: (modelRef: FilterCls, key: string) => unknown;
 export declare const fillMissingFilterArgs: (filterInfo: FilterInfo, args: unknown[]) => any[];
+export declare const assertFilterFitsCrud: (refName: string, queryKey: string, className: string) => void;
 export type BaseFilterSortKey = "latest" | "oldest" | "relevance";
 export type BaseFilterQueryKey = "any";
 export type BaseFilterKey = BaseFilterSortKey | BaseFilterQueryKey;

package/types/document/into.d.ts

@@ -56,12 +56,15 @@ export type Mdl<Doc, Raw, _RawDoc = DocumentModel<Raw>, _RawQuery extends Docume
     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>;
+    count(query: _RawQuery): Promise<number>;
     exists(query: _RawQuery): Promise<string | null>;
     updateOne(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>, options?: DocumentUpdateOptions): Promise<UpdateResult>;
     updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>): Promise<UpdateResult>;
+    removeOne(query: _RawQuery): Promise<UpdateResult>;
     removeMany(query: _RawQuery): Promise<UpdateResult>;
     bulkWrite(operations: BulkWriteOperation<Raw, _RawDoc, _RawQuery>[]): Promise<UpdateResult>;
+    /** @deprecated Renamed to `count`. */
+    countDocuments(query: _RawQuery): Promise<number>;
 };
 interface IntoConstantModel<T extends string, _CapitalizedRefName extends string, Raw, Insight> {
     refName: T;

package/types/service/predefinedAdaptor/database.adaptor.d.ts

@@ -61,6 +61,12 @@ export interface DocumentStore {
         matchedCount: number;
         modifiedCount: number;
     }>;
+    removeOneByQuery(query: DocumentQuery): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedId: string | null;
+    }>;
     bulkWrite(operations: {
         updateOne: {
             filter: DocumentQuery;
@@ -314,6 +320,12 @@ export declare class SqlDocumentStore {
         matchedCount: number;
         modifiedCount: number;
     }>;
+    removeOneByQuery(query: DocumentQuery): Promise<{
+        acknowledged: boolean;
+        matchedCount: number;
+        modifiedCount: number;
+        upsertedId: any;
+    }>;
     private compiledUpdate;
     bulkWrite(operations: {
         updateOne: {

package/types/service/types.d.ts

@@ -1,7 +1,7 @@
 import type { Cls, MergeAllTypes, PromiseOrObject } from "akanjs/base";
 import type { Logger } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
-import type { CRUDEventType, DatabaseModel, DataInputOf, FilterInstance, FindQueryOption, GetDocObject, ListQueryOption, QueryMethodPart, SaveEventType, UpdateResult } from "akanjs/document";
+import type { CRUDEventType, DatabaseModel, DataInputOf, DocumentUpdateInput, FilterInstance, FindQueryOption, GetDocObject, ListQueryOption, QueryMethodPart, SaveEventType, UpdateResult } from "akanjs/document";
 type ServiceMixinOmitKey = "onInit" | "onDestroy" | "_libsOnInit" | "_libsOnDestroy" | "_preCreate" | "_postCreate" | "_preUpdate" | "_postUpdate" | "_preRemove" | "_postRemove" | "_libsPreCreate" | "_libsPostCreate" | "_libsPreUpdate" | "_libsPostUpdate" | "_libsPreRemove" | "_libsPostRemove";
 type DatabaseQueryMethods<Query, Sort, Obj, Doc, Insight, FindQueryOption, ListQueryOption, DocQuery> = QueryMethodPart<Query, Sort, Obj, Doc, Insight, FindQueryOption, ListQueryOption, DocQuery>;
 type DocumentLike = {
@@ -32,6 +32,9 @@ export type DatabaseService<T extends string = string, Input = any, Doc = any, O
     __update: (id: string, data: Partial<Doc>) => Promise<Doc>;
     __remove: (id: string) => Promise<Doc>;
     __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
+    __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
+    __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+    __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
     __list(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
     __listIds(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
     __find(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;