@lossless.org/client 1.20.1 → 1.21.0

package/ts/nosqldb/classes.exactpersistence.ts

@@ -10,9 +10,12 @@ import type { SmartdataSession } from './classes.session.js';
 import {
   acquireSmartdataSession,
   reportSmartdataCollectionWrite,
+  reportSmartdataWriteFailure,
   settleSmartdataOperationError,
   resolveSmartdataOperationDeadline,
+  trackSmartdataRead,
 } from './classes.session.js';
+import { runSmartdataWrite } from './classes.readtracker.js';
 import {
   type SmartdataOperationDeadline,
   requireOperationSignal,
@@ -1135,6 +1138,35 @@ export class SmartdataExactCollection<
     }
   }
 
+  /**
+   * Runs one exact write through `runOperation`. A write that fails once
+   * started may still have applied, so it changes every open read set that
+   * read the collection.
+   */
+  private async runWriteOperation<TResult>(
+    optionsArg: IExactBoundedOptions,
+    operationArg: (
+      sessionArg: plugins.mongodb.ClientSession | undefined,
+      deadlineArg: SmartdataOperationDeadline,
+    ) => Promise<TResult>,
+  ): Promise<TResult> {
+    let started = false;
+    try {
+      return await runSmartdataWrite(this.collection.smartdataDb, () =>
+        this.runOperation(optionsArg, (sessionArg, deadlineArg) => {
+          started = true;
+          return operationArg(sessionArg, deadlineArg);
+        }));
+    } catch (errorArg) {
+      if (started) {
+        reportSmartdataWriteFailure(
+          this.collection.smartdataDb, optionsArg.session, this.collection.collectionName,
+        );
+      }
+      throw errorArg;
+    }
+  }
+
   /**
    * The error of a non-transactional write that its client deadline or
    * signal interrupted after the write was handed to the driver: the command
@@ -1531,7 +1563,7 @@ export class SmartdataExactCollection<
     documentArg: TModel | TExactPersistedDocument<TPersisted>,
     optionsArg: IExactBoundedOptions = {},
   ): Promise<TExactInsertResult<TPersisted>> {
-    return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
+    return this.runWriteOperation(optionsArg, async (sessionArg, deadlineArg) => {
     const persistedBytes = await this.createPersistedDocument(documentArg);
     const persistedDocument = this.decodeCanonical<
       TExactPersistedDocument<TPersisted>
@@ -1554,7 +1586,8 @@ export class SmartdataExactCollection<
     const reportReconciledInsert = (storedArg: TStoredDocument<TPersisted>): void => {
       if (storedArg._id.equals(expectedStoredDocument._id)) {
         reportSmartdataCollectionWrite(
-          this.collection, optionsArg.session, 'insert', [expectedStoredDocument],
+          this.collection, optionsArg.session, 'insert', [expectedStoredDocument], undefined,
+          { images: 'after' },
         );
       }
     };
@@ -1652,7 +1685,8 @@ export class SmartdataExactCollection<
       );
     }
     reportSmartdataCollectionWrite(
-      this.collection, optionsArg.session, 'insert', [expectedStoredDocument],
+      this.collection, optionsArg.session, 'insert', [expectedStoredDocument], undefined,
+      { images: 'after' },
     );
     return { status: 'inserted', document: expectedStoredDocument };
     });
@@ -1677,8 +1711,14 @@ export class SmartdataExactCollection<
     optionsArg: IExactBoundedOptions = {},
   ): Promise<TStoredDocument<TPersisted> | null> {
     return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
+    const filter = convertFilterForMongoDb(filterArg);
+    const tracked = trackSmartdataRead(this.collection, optionsArg.session, {
+      kind: 'documents',
+      filter,
+      limited: true,
+    });
     const cursor = this.collection.mongoDbCollection.find(
-      convertFilterForMongoDb(filterArg),
+      filter,
       {
         session: sessionArg,
         singleBatch: true,
@@ -1694,6 +1734,8 @@ export class SmartdataExactCollection<
     let storedDocument: TStoredDocument<TPersisted> | null;
     try {
       const rawDocument = await cursor.next();
+      if (rawDocument) tracked?.record(rawDocument);
+      tracked?.settle();
       storedDocument = rawDocument
         ? this.readStoredDocument(rawDocument).document
         : null;
@@ -1714,8 +1756,17 @@ export class SmartdataExactCollection<
     optionsArg: IFindStoredOptions<TPersisted> = {},
   ): Promise<Array<TStoredDocument<TPersisted>>> {
     return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
+    const filter = convertFilterForMongoDb(optionsArg.filter || {});
+    // A skipped page depends on the documents before it, which it never returns.
+    const tracked = trackSmartdataRead(this.collection, optionsArg.session, {
+      kind: 'documents',
+      filter,
+      sort: optionsArg.sort,
+      matches: optionsArg.skip !== undefined && optionsArg.skip > 0,
+      limited: optionsArg.limit !== undefined,
+    });
     let cursor = this.collection.mongoDbCollection.find(
-      convertFilterForMongoDb(optionsArg.filter || {}),
+      filter,
       { session: sessionArg, ...deadlineArg.cursorOptions() },
     );
     // The driver abort listener does not await close, so every close must join
@@ -1738,6 +1789,8 @@ export class SmartdataExactCollection<
         cursor = cursor.limit(optionsArg.limit);
       }
       const rawDocuments = await cursor.toArray();
+      for (const rawDocument of rawDocuments) tracked?.record(rawDocument);
+      tracked?.settle();
       storedDocuments = rawDocuments.map((documentArg) =>
         this.readStoredDocument(documentArg).document,
       );
@@ -1758,12 +1811,16 @@ export class SmartdataExactCollection<
     filterArg: MongoFilter<TStoredDocument<TPersisted>> = {},
     optionsArg: IExactBoundedOptions = {},
   ): Promise<number> {
-    return this.runOperation(optionsArg, async (sessionArg, deadlineArg) =>
-      this.collection.mongoDbCollection.countDocuments(
-        convertFilterForMongoDb(filterArg),
+    return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
+      const filter = convertFilterForMongoDb(filterArg);
+      const tracked = trackSmartdataRead(this.collection, optionsArg.session, { kind: 'count', filter });
+      const count = await this.collection.mongoDbCollection.countDocuments(
+        filter,
         { session: sessionArg, ...deadlineArg.commandOptions() },
-      )
-    );
+      );
+      tracked?.settle();
+      return count;
+    });
   }
 
   public async distinct<
@@ -1775,15 +1832,21 @@ export class SmartdataExactCollection<
   ): Promise<Array<TExactDistinctValue<
     TExactDocumentPathValue<TStoredDocument<TPersisted>, TField>
   >>> {
-    return this.runOperation(optionsArg, async (sessionArg, deadlineArg) =>
-      (await this.collection.mongoDbCollection.distinct(
+    return this.runOperation(optionsArg, async (sessionArg, deadlineArg) => {
+      const filter = convertFilterForMongoDb(filterArg);
+      trackSmartdataRead(this.collection, optionsArg.session, {
+        kind: 'documents',
+        filter,
+        matches: true,
+      });
+      return (await this.collection.mongoDbCollection.distinct(
         fieldArg as string,
-        convertFilterForMongoDb(filterArg),
+        filter,
         { session: sessionArg, ...deadlineArg.commandOptions() },
       )) as Array<TExactDistinctValue<
         TExactDocumentPathValue<TStoredDocument<TPersisted>, TField>
-      >>
-    );
+      >>;
+    });
   }
 
   public async transition(
@@ -1793,7 +1856,7 @@ export class SmartdataExactCollection<
     },
     sessionOptionsArg: IExactBoundedOptions = {},
   ): Promise<TExactTransitionResult<TPersisted>> {
-    return this.runOperation(sessionOptionsArg, async (sessionArg, deadlineArg) => {
+    return this.runWriteOperation(sessionOptionsArg, async (sessionArg, deadlineArg) => {
     const { document: current, bodyBytes: currentBodyBytes } =
       this.readStoredDocument(optionsArg.current);
     const currentIdentity = this.validateReconcileIdentity(current);
@@ -1841,9 +1904,15 @@ export class SmartdataExactCollection<
       ? { _id: current._id, _smartdataRevision: current._smartdataRevision }
       : { _id: current._id, _smartdataRevision: { $exists: false } };
 
+    // Only a revision pins the stored body the selector matched.
     const reportTransition = (): void => {
       reportSmartdataCollectionWrite(
-        this.collection, sessionOptionsArg.session, 'replace', [current, expectedStoredDocument], selector,
+        this.collection,
+        sessionOptionsArg.session,
+        'replace',
+        [current, expectedStoredDocument],
+        selector,
+        { images: current._smartdataRevision !== undefined ? 'beforeAndAfter' : 'after' },
       );
     };
     const replaceOptions = {
@@ -1925,7 +1994,7 @@ export class SmartdataExactCollection<
     sessionOptionsArg: IExactBoundedOptions = {},
   ): Promise<TExactDeleteResult> {
     const { current, identity } = this.canonicalizeDeleteCurrent(optionsArg);
-    return this.runOperation(sessionOptionsArg, async (sessionArg, deadlineArg) => {
+    return this.runWriteOperation(sessionOptionsArg, async (sessionArg, deadlineArg) => {
     const selector = current._smartdataRevision !== undefined
       ? {
           _id: current._id,
@@ -1958,7 +2027,12 @@ export class SmartdataExactCollection<
       result.deletedCount === 1
     ) {
       reportSmartdataCollectionWrite(
-        this.collection, sessionOptionsArg.session, 'delete', [current], selector,
+        this.collection,
+        sessionOptionsArg.session,
+        'delete',
+        [current],
+        selector,
+        { images: current._smartdataRevision !== undefined ? 'before' : 'none' },
       );
       return { status: 'deleted', deletedCount: 1 };
     }