@lossless.org/client 1.6.0 → 1.8.0

package/dist_ts/nosqldb/classes.db.d.ts

@@ -6,7 +6,7 @@ import { SmartdataSession } from './classes.session.js';
 import { collectionTopologyDbInspectionSymbol } from './classes.collectiontopology.js';
 import { type ISmartdataNamespaceInspectionOptions, type ISmartdataNamespaceInspection } from './classes.namespaceinspection.js';
 export { SmartdataSession } from './classes.session.js';
-export type { TSmartdataOrdinarySession } from './classes.session.js';
+export type { ISmartdataTransactionOptions, TSmartdataOrdinarySession } from './classes.session.js';
 import { type ISmartdataEngineIdentity } from './engineidentity.js';
 import type { ICapabilities } from '../core/interfaces.js';
 /**

package/dist_ts/nosqldb/classes.doc.d.ts

@@ -194,7 +194,14 @@ export interface ISmartdataOffsetPageOptions<T> {
     projection?: TSmartdataProjection<T>;
     hint?: string;
     maxTimeMS?: number;
-    /** Defaults to 5000ms; maximum 120000ms. Covers the cursor's entire lifetime. */
+    /**
+     * Defaults to 5000ms; maximum 120000ms. Covers the cursor up to its last
+     * reply. A page larger than the first batch that stalls in its `getMore`
+     * settles within about twice the deadline: the driver's `killCursors` runs
+     * on a fresh deadline of the same length before the error surfaces.
+     * Inside a transaction with its own deadline that deadline replaces the
+     * default, and an explicit value is refused.
+     */
     timeoutMS?: number;
     signal?: AbortSignal;
     session?: TSmartdataOrdinarySession;
@@ -202,6 +209,8 @@ export interface ISmartdataOffsetPageOptions<T> {
 export interface ISmartdataFindOneOptions<T> {
     projection?: TSmartdataProjection<T>;
     maxTimeMS?: number;
+    /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+    timeoutMS?: number;
     session?: TSmartdataOrdinarySession;
 }
 type TSmartdataAtomicSet<T> = Partial<Pick<T, TSmartdataDocumentPath<T>>> & Partial<Record<TSmartdataAtomicNestedDocumentPath<T>, unknown>>;
@@ -260,7 +269,12 @@ export interface ISmartdataGroupedTotalsOptions<T> {
      */
     limit: number;
     maxTimeMS?: number;
-    /** Client-side deadline for the complete aggregation cursor lifetime. */
+    /**
+     * Client-side deadline for the aggregation cursor up to its last reply. More
+     * groups than the first batch holds need a `getMore`; when that times out the
+     * driver's `killCursors` runs on a fresh deadline of the same length, so a
+     * stalled database settles the call within about twice the deadline.
+     */
     timeoutMS?: number;
     signal?: AbortSignal;
     session?: TSmartdataOrdinarySession;
@@ -361,6 +375,8 @@ export type TSmartdataAtomicFilter<T> = TSmartdataAtomicFilterBranch<T> & {
 export interface ISmartdataAtomicUpdateOptions {
     upsert?: boolean;
     session?: TSmartdataOrdinarySession;
+    /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+    timeoutMS?: number;
 }
 export interface ISmartdataAtomicUpdateResult {
     acknowledged: boolean;
@@ -381,6 +397,8 @@ export interface ISmartdataAtomicFindOneAndUpdateOptions<TReturnDocument extends
      */
     sort?: TSmartdataSort<TModel>;
     session?: TSmartdataOrdinarySession;
+    /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+    timeoutMS?: number;
 }
 export type TSmartdataAtomicFindOneAndUpdateResult<T, TReturnDocument extends TSmartdataAtomicReturnDocument> = {
     status: 'matched';
@@ -399,12 +417,21 @@ export interface ISmartdataAtomicFindOneAndReplaceOptions {
      */
     returnDocument?: TSmartdataAtomicReturnDocument;
     session?: TSmartdataOrdinarySession;
+    /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+    timeoutMS?: number;
 }
 export interface ISmartdataAtomicDeleteOptions {
     session?: TSmartdataOrdinarySession;
     /** Client-side operation deadline, including server selection and pool waits. */
     timeoutMS?: number;
 }
+export interface ISmartdataAtomicDeleteManyOptions extends ISmartdataAtomicDeleteOptions {
+    /**
+     * Cancels the call. An abort before the delete is sent deletes nothing; an
+     * abort in flight closes the connection and leaves the outcome unknown.
+     */
+    signal?: AbortSignal;
+}
 export interface ISmartdataInsertManyIfAbsentOptions<T> {
     /** A declared, non-serialized @unI identity field. */
     identityField: TSmartdataDocumentPath<T>;
@@ -422,6 +449,8 @@ export interface ISmartdataAtomicDeleteResult {
 }
 export interface ISmartdataAtomicUpdateManyOptions {
     session?: TSmartdataOrdinarySession;
+    /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+    timeoutMS?: number;
 }
 export interface ISmartdataAtomicUpdateManyResult {
     acknowledged: boolean;
@@ -461,6 +490,8 @@ export interface ISmartdataSaveIfOptions {
     session?: TSmartdataOrdinarySession;
     /** Defaults to `'ignore'`. */
     absentDeclaredFields?: TSmartdataAbsentDeclaredFields;
+    /** Client-side deadline for the write (1..120000 ms); `beforeSave()` and `afterSave()` run outside it. */
+    timeoutMS?: number;
 }
 export interface ISmartdataSaveIfResult {
     acknowledged: boolean;
@@ -548,6 +579,8 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
      */
     static insert<T extends SmartDataDbDoc<any, any>>(this: plugins.tsclass.typeFest.Class<T>, documentArg: T, opts?: {
         session?: TSmartdataOrdinarySession;
+        /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+        timeoutMS?: number;
     }): Promise<plugins.mongodb.InsertOneResult<{
         _id: TSmartdataPrimaryId<T>;
     }>>;
@@ -562,6 +595,8 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
     static insertMany<T extends SmartDataDbDoc<any, any>>(this: plugins.tsclass.typeFest.Class<T>, documentsArg: T[], opts?: {
         session?: TSmartdataOrdinarySession;
         ordered?: boolean;
+        /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+        timeoutMS?: number;
     }): Promise<plugins.mongodb.InsertManyResult<{
         _id: TSmartdataPrimaryId<T>;
     }>>;
@@ -633,7 +668,7 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
      * still requires declared fields and at least one top-level equality
      * anchor.
      */
-    static atomicDeleteMany<T>(this: plugins.tsclass.typeFest.Class<T>, filterArg: TSmartdataAtomicFilter<T>, opts?: ISmartdataAtomicDeleteOptions): Promise<ISmartdataAtomicDeleteResult>;
+    static atomicDeleteMany<T>(this: plugins.tsclass.typeFest.Class<T>, filterArg: TSmartdataAtomicFilter<T>, opts?: ISmartdataAtomicDeleteManyOptions): Promise<ISmartdataAtomicDeleteResult>;
     /**
      * Atomically updates every ordinary model document matching a strict
      * selector. Each matched document is updated atomically; the batch as a
@@ -672,6 +707,14 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
      */
     static getInstances<T>(this: plugins.tsclass.typeFest.Class<T>, filterArg: MongoFilter<T>, opts?: {
         session?: TSmartdataOrdinarySession;
+        /**
+         * Client-side deadline for the read (1..120000 ms), from model
+         * initialization to the cursor's last reply. A timed-out `getMore` is
+         * followed by the driver's `killCursors` on a fresh deadline of the same
+         * length, so a read that needs more than one batch settles within about
+         * twice `timeoutMS` against a stalled database.
+         */
+        timeoutMS?: number;
     }): Promise<T[]>;
     /**
      * Cursor-paged query with stable seek pagination — the org-standard way to
@@ -698,6 +741,14 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
         /** Also count all filter matches (extra query). */
         withTotal?: boolean;
         session?: TSmartdataOrdinarySession;
+        /**
+         * Client-side deadline for the page and its optional count together
+         * (1..120000 ms). A page that needs more than one batch can settle
+         * within about twice `timeoutMS` against a stalled database: the
+         * driver's `killCursors` after a timed-out `getMore` gets a fresh
+         * deadline of the same length.
+         */
+        timeoutMS?: number;
     }): Promise<{
         documents: T[];
         nextCursor?: {
@@ -715,6 +766,8 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
     static getInstance<T>(this: plugins.tsclass.typeFest.Class<T>, filterArg: MongoFilter<T>, opts?: ISmartdataFindOneOptions<T>): Promise<T>;
     static exists<T>(this: plugins.tsclass.typeFest.Class<T>, filterArg: MongoFilter<T>, opts?: {
         maxTimeMS?: number;
+        /** Client-side deadline for the call's database work (1..120000 ms), including model initialization, server selection and pool waits. */
+        timeoutMS?: number;
         session?: TSmartdataOrdinarySession;
     }): Promise<boolean>;
     /**
@@ -856,6 +909,8 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
      */
     save(opts?: {
         session?: TSmartdataOrdinarySession;
+        /** Client-side deadline for the write (1..120000 ms); `beforeSave()` and `afterSave()` run outside it. */
+        timeoutMS?: number;
     }): Promise<any>;
     /**
      * Saves this instance only while the stored document still matches `fence`.
@@ -885,6 +940,8 @@ export declare class SmartDataDbDoc<T extends TImplements, TImplements, TManager
      */
     delete(opts?: {
         session?: TSmartdataOrdinarySession;
+        /** Client-side deadline for the write (1..120000 ms); `beforeDelete()` and `afterDelete()` run outside it. */
+        timeoutMS?: number;
     }): Promise<any>;
     /**
      * also store any referenced objects to DB