@lossless.org/client 1.6.0 → 1.8.0

package/ts/nosqldb/classes.collection.ts

@@ -28,6 +28,7 @@ import {
   normalizeOrdinaryPersistenceError,
 } from './classes.persistence.js';
 import { notifyCollectionReconnect } from './classes.collectionlifecycle.js';
+import type { SmartdataOperationDeadline } from './classes.operationdeadline.js';
 import {
   leaseOrdinarySmartdataSession,
   runWithOrdinarySmartdataSession,
@@ -1803,18 +1804,21 @@ export class SmartdataCollection<T> {
 
   private runWithOrdinarySession<TResult>(
     sessionArg: TSmartdataOrdinarySession | undefined,
-    ordinaryWriteArg: boolean,
+    optionsArg: { ordinaryWrite: boolean; timeoutMS?: number; signal?: AbortSignal },
     operationArg: (
       rawSessionArg: plugins.mongodb.ClientSession | undefined,
+      deadlineArg: SmartdataOperationDeadline,
     ) => Promise<TResult>,
   ): Promise<TResult> {
     return runWithOrdinarySmartdataSession(
       sessionArg,
       this.smartdataDb,
       {
-        ordinaryWrite: ordinaryWriteArg,
+        ordinaryWrite: optionsArg.ordinaryWrite,
         prepared: this.isInitializedForCurrentDatabase(),
         collectionName: this.collectionName,
+        timeoutMS: optionsArg.timeoutMS,
+        signal: optionsArg.signal,
       },
       operationArg,
     );
@@ -2141,9 +2145,13 @@ export class SmartdataCollection<T> {
   }
 
   /**
-   * mark unique index
+   * Creates the single-field unique indexes the collection has not built yet,
+   * each within the time the calling operation's deadline has left.
    */
-  public async markUniqueIndexes(keyArrayArg: string[] = []) {
+  public async markUniqueIndexes(
+    keyArrayArg: string[] = [],
+    deadlineArg?: SmartdataOperationDeadline,
+  ) {
     for (const key of keyArrayArg) {
       if (key === this.modelSchema?.identityAsDocumentId) {
         // The primary key already enforces this identity; building a second
@@ -2157,6 +2165,7 @@ export class SmartdataCollection<T> {
             // A bound model may back its identity with a differently named
             // index; creating `<field>_1` would duplicate that key.
             name: getIdentityIndexName(this.modelSchema, key) ?? `${key}_1`,
+            ...deadlineArg?.commandOptions(),
           });
           this.uniqueIndexes.push(key);
         } catch (err: any) {
@@ -2178,9 +2187,13 @@ export class SmartdataCollection<T> {
   }
 
   /**
-   * creates regular indexes for the collection
+   * Creates the regular indexes the collection has not built yet, each within
+   * the time the calling operation's deadline has left.
    */
-  public async createRegularIndexes(indexesArg: Array<{field: string, options: IIndexOptions}> = []) {
+  public async createRegularIndexes(
+    indexesArg: Array<{field: string, options: IIndexOptions}> = [],
+    deadlineArg?: SmartdataOperationDeadline,
+  ) {
     for (const indexDef of indexesArg) {
       // Check if we've already created this index
       const indexKey = indexDef.field;
@@ -2188,7 +2201,7 @@ export class SmartdataCollection<T> {
         try {
           await this.mongoDbCollection.createIndex(
             { [indexDef.field]: 1 }, // Simple single-field index
-            indexDef.options
+            { ...indexDef.options, ...deadlineArg?.commandOptions() },
           );
           this.regularIndexes.push(indexDef);
         } catch (err: any) {
@@ -2260,18 +2273,20 @@ export class SmartdataCollection<T> {
     opts?: {
       projection?: plugins.mongodb.Document;
       maxTimeMS?: number;
+      timeoutMS?: number;
       session?: TSmartdataOrdinarySession;
     },
   ): Promise<any> {
     return this.runWithOrdinarySession(
       opts?.session,
-      false,
-      async (rawSessionArg) => {
-        await this.init();
+      { ordinaryWrite: false, timeoutMS: opts?.timeoutMS },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         return this.mongoDbCollection.findOne(filterObject, {
           projection: opts?.projection,
           maxTimeMS: opts?.maxTimeMS,
           session: rawSessionArg,
+          ...deadlineArg.commandOptions(),
         });
       },
     );
@@ -2308,32 +2323,25 @@ export class SmartdataCollection<T> {
    */
   public async findAll(
     filterObject: any,
-    opts?: { session?: TSmartdataOrdinarySession }
+    opts?: { session?: TSmartdataOrdinarySession; timeoutMS?: number }
   ): Promise<any[]> {
     return this.runWithOrdinarySession(
       opts?.session,
-      false,
-      async (rawSessionArg) => {
-        await this.init();
+      { ordinaryWrite: false, timeoutMS: opts?.timeoutMS },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         const cursor = this.mongoDbCollection.find(filterObject, {
           session: rawSessionArg,
+          ...deadlineArg.cursorOptions(),
         });
-        let result!: any[];
-        let operationFailed = false;
-        try {
-          result = await cursor.toArray();
-        } catch (errorArg) {
-          operationFailed = true;
-          throw errorArg;
-        } finally {
-          try {
-            await cursor.close();
-          } catch (closeError) {
-            if (!operationFailed) {
-              throw closeError;
-            }
-          }
-        }
+        // An enclosing transaction's signal reaches this cursor, and the
+        // driver's abort listener does not await its close, so every close
+        // joins one native cleanup before the session lease is released.
+        const result: any[] = await runCursorOperation(
+          cursor,
+          (cursorArg) => cursorArg.toArray(),
+          deadlineArg.signal,
+        );
 
         // In-memory check for duplicate _id values (should never happen)
         if (result.length > 0) {
@@ -2453,27 +2461,28 @@ export class SmartdataCollection<T> {
 
   public async insert(
     dbDocArg: T & SmartDataDbDoc<T, unknown>,
-    opts?: { session?: TSmartdataOrdinarySession }
+    opts?: { session?: TSmartdataOrdinarySession; timeoutMS?: number }
   ): Promise<any> {
     const preparedObject = this.preparesStoredDocuments
       ? this.prepareOrdinaryInsert(await dbDocArg.createSavableObject()) : undefined;
     return this.runWithOrdinarySession(
       opts?.session,
-      true,
-      async (rawSessionArg) => {
-        await this.init();
+      { ordinaryWrite: true, timeoutMS: opts?.timeoutMS },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         await this.checkDoc(dbDocArg);
-        await this.markUniqueIndexes(dbDocArg.uniqueIndexes);
+        await this.markUniqueIndexes(dbDocArg.uniqueIndexes, deadlineArg);
 
         // Create regular indexes if available
         if (dbDocArg.regularIndexes && dbDocArg.regularIndexes.length > 0) {
-          await this.createRegularIndexes(dbDocArg.regularIndexes);
+          await this.createRegularIndexes(dbDocArg.regularIndexes, deadlineArg);
         }
 
         const saveableObject = preparedObject ?? await dbDocArg.createSavableObject();
         try {
           return await this.mongoDbCollection.insertOne(saveableObject, {
             session: rawSessionArg,
+            ...deadlineArg.commandOptions(),
           });
         } catch (err: any) {
           return normalizeOrdinaryPersistenceError(
@@ -2497,35 +2506,32 @@ export class SmartdataCollection<T> {
     limitArg: number,
     opts?: { session?: TSmartdataOrdinarySession; maxTimeMS?: number; timeoutMS?: number; signal?: AbortSignal }
   ): Promise<plugins.mongodb.Document[]> {
-    opts?.signal?.throwIfAborted();
     return this.runWithOrdinarySession(
       opts?.session,
-      false,
-      async (rawSessionArg) => {
-        await this.init();
+      { ordinaryWrite: false, timeoutMS: opts?.timeoutMS, signal: opts?.signal },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         const pipeline: plugins.mongodb.Document[] = [];
         if (matchArg && Object.keys(matchArg).length > 0) {
           pipeline.push({ $match: matchArg });
         }
         pipeline.push({ $group: groupArg });
         pipeline.push({ $limit: limitArg });
-        opts?.signal?.throwIfAborted();
         const cursor = this.mongoDbCollection.aggregate(pipeline, {
           session: rawSessionArg,
-          ...(opts?.timeoutMS !== undefined ? { timeoutMS: opts.timeoutMS, timeoutMode: 'cursorLifetime' } : {}),
-          signal: opts?.signal,
+          ...deadlineArg.cursorOptions(),
           ...(opts?.maxTimeMS !== undefined
             ? { maxTimeMS: opts.maxTimeMS }
             : {}),
         });
-        return runCursorOperation(cursor, (cursorArg) => cursorArg.toArray(), opts?.signal);
+        return runCursorOperation(cursor, (cursorArg) => cursorArg.toArray(), deadlineArg.signal);
       },
     );
   }
 
   public async insertMany(
     dbDocsArg: Array<T & SmartDataDbDoc<T, unknown>>,
-    opts?: { session?: TSmartdataOrdinarySession; ordered?: boolean }
+    opts?: { session?: TSmartdataOrdinarySession; ordered?: boolean; timeoutMS?: number }
   ): Promise<plugins.mongodb.InsertManyResult> {
     if (!Array.isArray(dbDocsArg) || dbDocsArg.length === 0) {
       throw new SmartdataPersistenceError(
@@ -2541,19 +2547,19 @@ export class SmartdataCollection<T> {
     }
     return this.runWithOrdinarySession(
       opts?.session,
-      true,
-      async (rawSessionArg) => {
-        await this.init();
+      { ordinaryWrite: true, timeoutMS: opts?.timeoutMS },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         for (const dbDocArg of dbDocsArg) {
           await this.checkDoc(dbDocArg);
         }
         const firstDocument = dbDocsArg[0];
-        await this.markUniqueIndexes(firstDocument.uniqueIndexes);
+        await this.markUniqueIndexes(firstDocument.uniqueIndexes, deadlineArg);
         if (
           firstDocument.regularIndexes
           && firstDocument.regularIndexes.length > 0
         ) {
-          await this.createRegularIndexes(firstDocument.regularIndexes);
+          await this.createRegularIndexes(firstDocument.regularIndexes, deadlineArg);
         }
         const saveableObjects: any[] = preparedObjects ?? [];
         if (!preparedObjects) {
@@ -2565,6 +2571,7 @@ export class SmartdataCollection<T> {
           return await this.mongoDbCollection.insertMany(saveableObjects, {
             session: rawSessionArg,
             ordered: opts?.ordered !== false,
+            ...deadlineArg.commandOptions(),
           });
         } catch (err: any) {
           return normalizeOrdinaryPersistenceError(
@@ -2597,11 +2604,14 @@ export class SmartdataCollection<T> {
       }
       prepared.push(plugins.mongodb.BSON.deserialize(bson));
     }
-    return this.runWithOrdinarySession(optsArg.session, true, async (rawSessionArg) => {
-      await this.init();
+    return this.runWithOrdinarySession(optsArg.session, {
+      ordinaryWrite: true,
+      timeoutMS: optsArg.timeoutMS,
+    }, async (rawSessionArg, deadlineArg) => {
+      await deadlineArg.join(this.init());
       const first = documentsArg[0];
-      await this.markUniqueIndexes(first.uniqueIndexes);
-      await this.createRegularIndexes(first.regularIndexes || []);
+      await this.markUniqueIndexes(first.uniqueIndexes, deadlineArg);
+      await this.createRegularIndexes(first.regularIndexes || [], deadlineArg);
       // A document keyed by its identity is addressed through _id, and the
       // seeded body must not repeat the immutable primary key: MongoDB derives
       // it from the filter's equality condition on the insert branch.
@@ -2618,7 +2628,7 @@ export class SmartdataCollection<T> {
               upsert: true,
             },
           };
-        }), { ordered: false, session: rawSessionArg, timeoutMS: optsArg.timeoutMS });
+        }), { ordered: false, session: rawSessionArg, ...deadlineArg.commandOptions() });
         if (result.upsertedCount + result.matchedCount !== prepared.length) {
           throw new SmartdataPersistenceError('unsupported_operation',
             'insertManyIfAbsent requires an acknowledged result for every identity.');
@@ -2636,7 +2646,7 @@ export class SmartdataCollection<T> {
    */
   public async update(
     dbDocArg: T & SmartDataDbDoc<T, unknown>,
-    opts?: { session?: TSmartdataOrdinarySession }
+    opts?: { session?: TSmartdataOrdinarySession; timeoutMS?: number }
   ): Promise<any> {
     if (this.modelSchema?.ordinaryPersistence) {
       throw new SmartdataPersistenceError('unsupported_operation',
@@ -2644,13 +2654,13 @@ export class SmartdataCollection<T> {
     }
     return this.runWithOrdinarySession(
       opts?.session,
-      true,
-      async (rawSessionArg) => {
-        await this.init();
+      { ordinaryWrite: true, timeoutMS: opts?.timeoutMS },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         await this.checkDoc(dbDocArg);
-        await this.markUniqueIndexes(dbDocArg.uniqueIndexes);
+        await this.markUniqueIndexes(dbDocArg.uniqueIndexes, deadlineArg);
         if (dbDocArg.regularIndexes && dbDocArg.regularIndexes.length > 0) {
-          await this.createRegularIndexes(dbDocArg.regularIndexes);
+          await this.createRegularIndexes(dbDocArg.regularIndexes, deadlineArg);
         }
         const identifiableObject = await dbDocArg.createIdentifiableObject();
         this.assertConstrainingIdentifiableObject(identifiableObject, 'update');
@@ -2683,7 +2693,7 @@ export class SmartdataCollection<T> {
                 ? { $setOnInsert: insertOnlyObject }
                 : {}),
             },
-            { upsert: true, session: rawSessionArg },
+            { upsert: true, session: rawSessionArg, ...deadlineArg.commandOptions() },
           );
         } catch (errorArg) {
           return normalizeOrdinaryPersistenceError(
@@ -2697,18 +2707,19 @@ export class SmartdataCollection<T> {
 
   public async delete(
     dbDocArg: T & SmartDataDbDoc<T, unknown>,
-    opts?: { session?: TSmartdataOrdinarySession }
+    opts?: { session?: TSmartdataOrdinarySession; timeoutMS?: number }
   ): Promise<any> {
     return this.runWithOrdinarySession(
       opts?.session,
-      true,
-      async (rawSessionArg) => {
-        await this.init();
+      { ordinaryWrite: true, timeoutMS: opts?.timeoutMS },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         await this.checkDoc(dbDocArg);
         const identifiableObject = await dbDocArg.createIdentifiableObject();
         this.assertConstrainingIdentifiableObject(identifiableObject, 'delete');
         return this.mongoDbCollection.deleteOne(identifiableObject, {
           session: rawSessionArg,
+          ...deadlineArg.commandOptions(),
         });
       },
     );
@@ -2755,10 +2766,9 @@ export class SmartdataCollection<T> {
     }
     return this.runWithOrdinarySession(
       opts?.session,
-      false,
-      async (rawSessionArg) => {
-        await this.init();
-        opts?.signal?.throwIfAborted();
+      { ordinaryWrite: false, timeoutMS: opts?.timeoutMS, signal: opts?.signal },
+      async (rawSessionArg, deadlineArg) => {
+        await deadlineArg.join(this.init());
         const pipeline: plugins.mongodb.Document[] = [{ $match: filterObject }];
         if (opts?.limit !== undefined) {
           pipeline.push({ $limit: opts.limit });
@@ -2767,13 +2777,12 @@ export class SmartdataCollection<T> {
         const cursor = this.mongoDbCollection.aggregate<{ count: number }>(pipeline, {
           hint: opts?.hint,
           maxTimeMS: opts?.maxTimeMS,
-          timeoutMS: opts?.timeoutMS,
-          signal: opts?.signal,
+          ...deadlineArg.commandOptions(),
           session: rawSessionArg,
         });
         return runCursorOperation(cursor, async (cursorArg) =>
           (await cursorArg.next())?.count ?? 0,
-        opts?.signal);
+        deadlineArg.signal);
       },
     );
   }

package/ts/nosqldb/classes.db.ts

@@ -18,7 +18,7 @@ import {
 } 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 { logger } from './logging.js';
 import { assertDataOptions, SmartdataOperationBudget } from './classes.operationbudget.js';