akanjs 3.1.1-rc.2 → 3.1.1-rc.3

package/document/database.ts

@@ -3,7 +3,7 @@ import type { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions, CacheValue } from "akanjs/service";
 import type { DataLoader } from "./dataLoader";
-import type { DocumentUpdateInput } from "./documentQuery";
+import type { DocumentTouchOptions, DocumentUpdateInput } from "./documentQuery";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta";
 import type { Mdl, SaveEventListener, SaveEventType, UpdateResult } from "./into";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types";
@@ -61,7 +61,7 @@ export class CacheDatabase<_T = unknown> {
 }
 /** What `update<Filter>` returns: the patch cannot trail a filter's optional args, so it lands on `.set()`. */
 export interface UpdateChain<Doc = any> {
-  set(update: DocumentUpdateInput<Doc>): Promise<UpdateResult>;
+  set(update: DocumentUpdateInput<Doc>, options?: DocumentTouchOptions): Promise<UpdateResult>;
 }
 
 type QueryMethodOfKey<
@@ -157,8 +157,16 @@ export type DatabaseInstanceWithQuerySort<
   __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
   __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
   __purgeMany: (query: _QueryOfDoc) => Promise<number>;
-  __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
-  __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+  __updateMany: (
+    query: _QueryOfDoc,
+    update: DocumentUpdateInput<Doc>,
+    options?: DocumentTouchOptions,
+  ) => Promise<UpdateResult>;
+  __updateOne: (
+    query: _QueryOfDoc,
+    update: DocumentUpdateInput<Doc>,
+    options?: DocumentTouchOptions,
+  ) => 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/documentQuery.ts

@@ -106,7 +106,12 @@ export interface DocumentScopeOptions {
   withRemoved?: boolean;
 }
 
-export interface DocumentUpdateOptions extends DocumentScopeOptions {
+export interface DocumentTouchOptions {
+  /** `false` leaves `updatedAt` as stored, for bookkeeping that is no edit: a lease heartbeat, a mirrored snapshot. */
+  touch?: boolean;
+}
+
+export interface DocumentUpdateOptions extends DocumentScopeOptions, DocumentTouchOptions {
   upsert?: boolean;
 }
 

package/document/into.ts

@@ -4,7 +4,13 @@ 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 { DocumentQuery, DocumentScopeOptions, DocumentUpdateInput, DocumentUpdateOptions } from "./documentQuery";
+import type {
+  DocumentQuery,
+  DocumentScopeOptions,
+  DocumentTouchOptions,
+  DocumentUpdateInput,
+  DocumentUpdateOptions,
+} from "./documentQuery";
 import { type LoaderBuilder, type ModelCls, makeLoaderBuilder } from "./loaderInfo";
 import type { DocumentProjection } from "./types";
 
@@ -79,7 +85,7 @@ export type Mdl<
   updateMany(
     query: _RawQuery,
     update: DocumentUpdateInput<_RawDoc>,
-    options?: DocumentScopeOptions,
+    options?: DocumentScopeOptions & DocumentTouchOptions,
   ): Promise<UpdateResult>;
   removeOne(query: _RawQuery): Promise<UpdateResult>;
   removeMany(query: _RawQuery): Promise<UpdateResult>;

package/package.json

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

package/server/di/diLifecycle.ts

@@ -1,4 +1,4 @@
-import { type BackendEnv, DatabaseModes, getEnv } from "akanjs/base";
+import { type BackendEnv, DatabaseModes, getEnv, INTERNAL_META } from "akanjs/base";
 import { Logger } from "akanjs/common";
 import { ConstantRegistry } from "akanjs/constant";
 import {
@@ -195,6 +195,7 @@ export class DiLifecycle {
       this.logger.info("agent relay is provided by a lib module — the framework's is skipped");
     if (!this.#scalar.has("agentTurn"))
       this.#scalar.set("agentTurn", { constant: agentTurnConstant, database: agentTurnDocument });
+    this.#assertUniqueInternalJobs();
     const adaptorClaims = new Map<string, AdaptorCls>();
     const adaptorRegistrations: Registration[] = [];
     const claimAdaptor = (adaptorCls: AdaptorCls, owner: string) => {
@@ -460,6 +461,15 @@ export class DiLifecycle {
     this.logger.verbose(`${doneLabel} in ${Date.now() - now}ms`);
   }
 
+  #assertUniqueInternalJobs() {
+    const jobs = this.#allModules().flatMap(({ signal: { internal } }) =>
+      Object.entries(internal[INTERNAL_META])
+        .filter(([, { type }]) => type !== "resolveField")
+        .map(([key, { type }]) => ({ key, owner: `the ${type} of "${internal.refName}"` })),
+    );
+    assertUniqueRegistrations("internal", jobs);
+  }
+
   registerSchedule(serverMode: "federation" | "batch" | "all") {
     const internals = this.#allModules().map((mod) => mod.signal.internal);
     const failures: { label: string; reason: unknown }[] = [];

package/server/resolver/database.resolver.ts

@@ -11,6 +11,7 @@ import {
   DataLoader,
   DocumentSchema,
   type DocumentScopeOptions,
+  type DocumentTouchOptions,
   type DocumentUpdateInput,
   type DocumentUpdateOptions,
   documentQueryHelper,
@@ -45,6 +46,9 @@ const timedQuery = async <T>(fn: () => Promise<T>): Promise<T> => {
     trace.countDbQuery(performance.now() - start);
   }
 };
+const touchOf = (options?: DocumentTouchOptions) => (options?.touch === false ? { touch: false } : {});
+const touchArgs = (options?: DocumentTouchOptions): [] | [DocumentTouchOptions] =>
+  options?.touch === false ? [{ touch: false }] : [];
 
 export class DatabaseResolver {
   
@@ -205,6 +209,12 @@ export class DatabaseResolver {
         const scopeOf = (options?: DocumentScopeOptions) => (options?.withRemoved ? { withRemoved: true } : {});
         const scopeArgs = (options?: DocumentScopeOptions): [] | [DocumentScopeOptions] =>
           options?.withRemoved ? [{ withRemoved: true }] : [];
+        const updateManyArgs = (
+          options?: DocumentScopeOptions & DocumentTouchOptions,
+        ): [] | [DocumentScopeOptions & DocumentTouchOptions] => {
+          const narrowed = { ...scopeOf(options), ...touchOf(options) };
+          return Object.keys(narrowed).length ? [narrowed] : [];
+        };
         const createFindManyChain = (
           query: QueryOf<any>,
           options: { sort?: any; skip?: number; limit?: number; select?: any; withRemoved?: boolean } = {},
@@ -287,8 +297,11 @@ export class DatabaseResolver {
             timedQuery(() => store.count(query, ...scopeArgs(options))),
           updateOne: (query: QueryOf<any>, update: DocumentUpdateInput, options?: DocumentUpdateOptions) =>
             timedQuery(() => store.updateOneByQuery(query, update, options)),
-          updateMany: (query: QueryOf<any>, update: DocumentUpdateInput, options?: DocumentScopeOptions) =>
-            timedQuery(() => store.updateManyByQuery(query, update, ...scopeArgs(options))),
+          updateMany: (
+            query: QueryOf<any>,
+            update: DocumentUpdateInput,
+            options?: DocumentScopeOptions & DocumentTouchOptions,
+          ) => timedQuery(() => store.updateManyByQuery(query, update, ...updateManyArgs(options))),
           removeOne: (query: QueryOf<any>) => timedQuery(() => store.removeOneByQuery(query)),
           removeMany: (query: QueryOf<any>) => timedQuery(() => store.removeManyByQuery(query)),
           purgeMany: (query: QueryOf<any>) => timedQuery(() => store.purgeManyByQuery(query)),
@@ -401,11 +414,11 @@ export class DatabaseResolver {
       async __purgeMany(query: QueryOf<any>) {
         return await timedQuery(() => this.__store.purgeManyByQuery(query));
       }
-      async __updateMany(query: QueryOf<any>, update: DocumentUpdateInput) {
-        return await timedQuery(() => this.__store.updateManyByQuery(query, update));
+      async __updateMany(query: QueryOf<any>, update: DocumentUpdateInput, options?: DocumentTouchOptions) {
+        return await timedQuery(() => this.__store.updateManyByQuery(query, update, ...touchArgs(options)));
       }
-      async __updateOne(query: QueryOf<any>, update: DocumentUpdateInput) {
-        return await timedQuery(() => this.__store.updateOneByQuery(query, update));
+      async __updateOne(query: QueryOf<any>, update: DocumentUpdateInput, options?: DocumentTouchOptions) {
+        return await timedQuery(() => this.__store.updateOneByQuery(query, update, ...touchArgs(options)));
       }
       async [`remove${className}`](id: string) {
         return this.__remove(id);

package/server/resolver/service.resolver.ts

@@ -1,6 +1,6 @@
 import { capitalize } from "akanjs/common";
 import type { QueryOf } from "akanjs/constant";
-import type { DatabaseModel, DataInputOf, Doc, DocumentUpdateInput } from "akanjs/document";
+import type { DatabaseModel, DataInputOf, Doc, DocumentTouchOptions, DocumentUpdateInput } from "akanjs/document";
 import { type DatabaseService, type ServiceCls, ServiceModel } from "akanjs/service";
 import type { CascadeRunner } from "./CascadeRunner";
 import { DatabaseResolver } from "./database.resolver";
@@ -38,11 +38,19 @@ export class ServiceResolver {
       async __purgeMany(this: DatabaseService, query: QueryOf<any>) {
         return await this.__databaseModel.__purgeMany(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);
+      async __updateMany(
+        this: DatabaseService,
+        query: QueryOf<any>,
+        ...set: [DocumentUpdateInput, DocumentTouchOptions?]
+      ) {
+        return await this.__databaseModel.__updateMany(query, ...set);
+      },
+      async __updateOne(
+        this: DatabaseService,
+        query: QueryOf<any>,
+        ...set: [DocumentUpdateInput, DocumentTouchOptions?]
+      ) {
+        return await this.__databaseModel.__updateOne(query, ...set);
       },
     };
   }

package/service/predefinedAdaptor/sql/SqlDocumentStore.ts

@@ -9,6 +9,7 @@ import {
   type DocumentQuery,
   type DocumentSchema,
   type DocumentScopeOptions,
+  type DocumentTouchOptions,
   type DocumentUpdate,
   type DocumentUpdateInput,
   type DocumentUpdateNode,
@@ -471,7 +472,7 @@ export class SqlDocumentStore {
     operation: string,
   ) {
     const resolved = resolveDocumentUpdate(update);
-    const { assignments, params } = this.compiledUpdate(resolved);
+    const { assignments, params } = this.compiledUpdate(resolved, options);
     const { where, params: whereParams } = this.writeQuery(query, operation, options);
     const subquery = `SELECT ${quoteIdent("id")} FROM ${quoteIdent(this.table)} WHERE ${where} ORDER BY ${this.compiler.orderBy()} LIMIT 1`;
 
@@ -490,17 +491,21 @@ export class SqlDocumentStore {
     return { acknowledged: true, matchedCount: 0, modifiedCount: 1, upsertedId: inserted.id };
   }
 
-  async updateManyByQuery(query: DocumentQuery, update: DocumentUpdateInput, options: DocumentScopeOptions = {}) {
+  async updateManyByQuery(
+    query: DocumentQuery,
+    update: DocumentUpdateInput,
+    options: DocumentScopeOptions & DocumentTouchOptions = {},
+  ) {
     return await this.#updateMany(query, update, options, "updateManyByQuery");
   }
 
   async #updateMany(
     query: DocumentQuery,
     update: DocumentUpdateInput,
-    options: DocumentScopeOptions,
+    options: DocumentScopeOptions & DocumentTouchOptions,
     operation: string,
   ) {
-    const { assignments, params } = this.compiledUpdate(resolveDocumentUpdate(update));
+    const { assignments, params } = this.compiledUpdate(resolveDocumentUpdate(update), options);
     const { where, params: whereParams } = this.writeQuery(query, operation, options);
     const sql = `UPDATE ${quoteIdent(this.table)} SET ${assignments.join(", ")} WHERE ${where}`;
     const changes = this.dialect.affectedRows(
@@ -559,14 +564,14 @@ export class SqlDocumentStore {
     return false;
   }
 
-  private compiledUpdate(update: DocumentUpdate) {
+  private compiledUpdate(update: DocumentUpdate, { touch = true }: DocumentTouchOptions = {}) {
     for (const raw of Object.values(update))
       assertStorableJson(jsonStr(isDocumentUpdateNode(raw) ? raw.value : raw), this.table);
-    const compiled = this.updateCompiler.compile(update);
-    return {
-      assignments: [`${quoteIdent("updatedAt")} = ?`, ...compiled.assignments],
-      params: [Date.now(), ...compiled.params],
-    };
+    const { assignments, params } = this.updateCompiler.compile(update);
+    const updatedAt = quoteIdent("updatedAt");
+    if (touch) return { assignments: [`${updatedAt} = ?`, ...assignments], params: [Date.now(), ...params] };
+    
+    return { assignments: assignments.length ? assignments : [`${updatedAt} = ${updatedAt}`], params };
   }
 
   async bulkWrite(

package/service/predefinedAdaptor/sql/types.ts

@@ -6,6 +6,7 @@ import type {
   DocumentQueryNode,
   DocumentSchema,
   DocumentScopeOptions,
+  DocumentTouchOptions,
   DocumentUpdateInput,
   DocumentUpdateOperator,
   DocumentUpdateOptions,
@@ -66,7 +67,7 @@ export interface DocumentStore {
   updateManyByQuery(
     query: DocumentQuery,
     update: DocumentUpdateInput,
-    options?: DocumentScopeOptions,
+    options?: DocumentScopeOptions & DocumentTouchOptions,
   ): Promise<{ acknowledged: boolean; matchedCount: number; modifiedCount: number }>;
   removeManyByQuery(
     query: DocumentQuery,

package/service/serviceModule.ts

@@ -207,11 +207,11 @@ export class ServiceModel<
       },
       [`update${key}`]: function (this: DatabaseService, ...args: any): UpdateChain {
         const query = queryOf(args);
-        return { set: (update) => this.__updateMany(query, update) };
+        return { set: (...set) => this.__updateMany(query, ...set) };
       },
       [`updateOne${key}`]: function (this: DatabaseService, ...args: any): UpdateChain {
         const query = queryOf(args);
-        return { set: (update) => this.__updateOne(query, update) };
+        return { set: (...set) => this.__updateOne(query, ...set) };
       },
     };
   }

package/service/types.ts

@@ -4,6 +4,7 @@ import type { QueryOf } from "akanjs/constant";
 import type {
   DatabaseModel,
   DataInputOf,
+  DocumentTouchOptions,
   DocumentUpdateInput,
   FilterInstance,
   FindQueryOption,
@@ -106,8 +107,16 @@ export type DatabaseService<
   __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
   __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
   __purgeMany: (query: _QueryOfDoc) => Promise<number>;
-  __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
-  __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+  __updateMany: (
+    query: _QueryOfDoc,
+    update: DocumentUpdateInput<Doc>,
+    options?: DocumentTouchOptions,
+  ) => Promise<UpdateResult>;
+  __updateOne: (
+    query: _QueryOfDoc,
+    update: DocumentUpdateInput<Doc>,
+    options?: DocumentTouchOptions,
+  ) => 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,7 +3,7 @@ import type { Logger } from "akanjs/common";
 import type { DocumentModel, QueryOf } from "akanjs/constant";
 import type { CacheAdaptor, CacheSetOptions, CacheValue } from "akanjs/service";
 import type { DataLoader } from "./dataLoader.d.ts";
-import type { DocumentUpdateInput } from "./documentQuery.d.ts";
+import type { DocumentTouchOptions, DocumentUpdateInput } from "./documentQuery.d.ts";
 import type { ExtractQuery, ExtractSort, FilterInstance } from "./filterMeta.d.ts";
 import type { Mdl, SaveEventListener, SaveEventType, UpdateResult } from "./into.d.ts";
 import type { DataInputOf, FindQueryOption, ListQueryOption } from "./types.d.ts";
@@ -29,7 +29,7 @@ export declare class CacheDatabase<_T = unknown> {
 }
 /** What `update<Filter>` returns: the patch cannot trail a filter's optional args, so it lands on `.set()`. */
 export interface UpdateChain<Doc = any> {
-    set(update: DocumentUpdateInput<Doc>): Promise<UpdateResult>;
+    set(update: DocumentUpdateInput<Doc>, options?: DocumentTouchOptions): 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[]>;
@@ -86,8 +86,8 @@ export type DatabaseInstanceWithQuerySort<T extends string = string, Input = any
     __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
     __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
     __purgeMany: (query: _QueryOfDoc) => Promise<number>;
-    __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
-    __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+    __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>, options?: DocumentTouchOptions) => Promise<UpdateResult>;
+    __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>, options?: DocumentTouchOptions) => 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/documentQuery.d.ts

@@ -55,7 +55,11 @@ export type DocumentUpdate<T = any> = {
 export interface DocumentScopeOptions {
     withRemoved?: boolean;
 }
-export interface DocumentUpdateOptions extends DocumentScopeOptions {
+export interface DocumentTouchOptions {
+    /** `false` leaves `updatedAt` as stored, for bookkeeping that is no edit: a lease heartbeat, a mirrored snapshot. */
+    touch?: boolean;
+}
+export interface DocumentUpdateOptions extends DocumentScopeOptions, DocumentTouchOptions {
     upsert?: boolean;
 }
 export declare const createDocumentUpdateHelper: () => {

package/types/document/into.d.ts

@@ -3,7 +3,7 @@ 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 { DocumentQuery, DocumentScopeOptions, DocumentUpdateInput, DocumentUpdateOptions } from "./documentQuery.d.ts";
+import type { DocumentQuery, DocumentScopeOptions, DocumentTouchOptions, DocumentUpdateInput, 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";
@@ -52,7 +52,7 @@ export type Mdl<Doc, Raw, _RawDoc = DocumentModel<Raw>, _RawQuery extends Docume
     count(query: _RawQuery, options?: DocumentScopeOptions): Promise<number>;
     exists(query: _RawQuery, options?: DocumentScopeOptions): Promise<string | null>;
     updateOne(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>, options?: DocumentUpdateOptions): Promise<UpdateResult>;
-    updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>, options?: DocumentScopeOptions): Promise<UpdateResult>;
+    updateMany(query: _RawQuery, update: DocumentUpdateInput<_RawDoc>, options?: DocumentScopeOptions & DocumentTouchOptions): Promise<UpdateResult>;
     removeOne(query: _RawQuery): Promise<UpdateResult>;
     removeMany(query: _RawQuery): Promise<UpdateResult>;
     /** Deletes every row the query matches, removed ones too, and answers how many: no hook, cascade or undo. */

package/types/service/predefinedAdaptor/sql/SqlDocumentStore.d.ts

@@ -1,5 +1,5 @@
 import { type ConstantModel } from "akanjs/constant";
-import { type DatabaseModel, type DocumentQuery, type DocumentSchema, type DocumentScopeOptions, type DocumentUpdateInput, type DocumentUpdateOptions } from "akanjs/document";
+import { type DatabaseModel, type DocumentQuery, type DocumentSchema, type DocumentScopeOptions, type DocumentTouchOptions, type DocumentUpdateInput, type DocumentUpdateOptions } from "akanjs/document";
 import { QueryCompiler } from "./QueryCompiler.d.ts";
 import { type DocumentDatabaseOwner, type DocumentRecord, type FindIdOptions, type FindManyOptions, type FindOneOptions, type SqlDialect, type TransferRow, type UpsertByIdOptions, type WriteHookOptions } from "./types.d.ts";
 import { UpdateCompiler } from "./UpdateCompiler.d.ts";
@@ -34,7 +34,7 @@ export declare class SqlDocumentStore {
         modifiedCount: number;
         upsertedId: any;
     }>;
-    updateManyByQuery(query: DocumentQuery, update: DocumentUpdateInput, options?: DocumentScopeOptions): Promise<{
+    updateManyByQuery(query: DocumentQuery, update: DocumentUpdateInput, options?: DocumentScopeOptions & DocumentTouchOptions): Promise<{
         acknowledged: boolean;
         matchedCount: number;
         modifiedCount: number;

package/types/service/predefinedAdaptor/sql/types.d.ts

@@ -1,6 +1,6 @@
 import type { PromiseOrObject } from "akanjs/base";
 import type { ConstantModel } from "akanjs/constant";
-import type { DatabaseModel, DocumentQuery, DocumentQueryNode, DocumentSchema, DocumentScopeOptions, DocumentUpdateInput, DocumentUpdateOperator, DocumentUpdateOptions } from "akanjs/document";
+import type { DatabaseModel, DocumentQuery, DocumentQueryNode, DocumentSchema, DocumentScopeOptions, DocumentTouchOptions, DocumentUpdateInput, DocumentUpdateOperator, DocumentUpdateOptions } from "akanjs/document";
 import type { SearchIndex } from "../searchIndex.d.ts";
 import type { SqlDocumentStore } from "./SqlDocumentStore.d.ts";
 export interface SqliteDatabaseConfig {
@@ -52,7 +52,7 @@ export interface DocumentStore {
         modifiedCount: number;
         upsertedId: string | null;
     }>;
-    updateManyByQuery(query: DocumentQuery, update: DocumentUpdateInput, options?: DocumentScopeOptions): Promise<{
+    updateManyByQuery(query: DocumentQuery, update: DocumentUpdateInput, options?: DocumentScopeOptions & DocumentTouchOptions): Promise<{
         acknowledged: boolean;
         matchedCount: number;
         modifiedCount: number;

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 { DatabaseModel, DataInputOf, DocumentUpdateInput, FilterInstance, FindQueryOption, GetDocObject, ListQueryOption, QueryMethodPart, SaveEventListener, SaveEventType, UpdateResult } from "akanjs/document";
+import type { DatabaseModel, DataInputOf, DocumentTouchOptions, DocumentUpdateInput, FilterInstance, FindQueryOption, GetDocObject, ListQueryOption, QueryMethodPart, SaveEventListener, 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 = {
@@ -34,8 +34,8 @@ export type DatabaseService<T extends string = string, Input = any, Doc = any, O
     __removeMany: (query: _QueryOfDoc) => Promise<UpdateResult>;
     __removeOne: (query: _QueryOfDoc) => Promise<UpdateResult>;
     __purgeMany: (query: _QueryOfDoc) => Promise<number>;
-    __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
-    __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>) => Promise<UpdateResult>;
+    __updateMany: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>, options?: DocumentTouchOptions) => Promise<UpdateResult>;
+    __updateOne: (query: _QueryOfDoc, update: DocumentUpdateInput<Doc>, options?: DocumentTouchOptions) => Promise<UpdateResult>;
     __list(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<Doc[]>;
     __listIds(query?: _QueryOfDoc, queryOption?: _ListQueryOption): Promise<string[]>;
     __find(query?: _QueryOfDoc, queryOption?: _FindQueryOption): Promise<Doc | null>;