@lossless.org/client 1.23.0 → 1.23.2

package/ts/nosqldb/classes.atomicfindoneandupdate.ts

@@ -15,6 +15,8 @@ import {
   type TSmartdataOrdinarySession,
 } from './classes.session.js';
 import { validateOrdinaryStoredDocument } from './classes.ordinarypersistence.js';
+import { updateLeavesField } from './classes.readtracker.js';
+import { writeRevisionsPartitionField } from './classes.writerevisions.js';
 
 type TRawDocument = plugins.mongodb.WithId<plugins.mongodb.Document>;
 
@@ -129,11 +131,14 @@ export const executeAtomicFindOneAndUpdate = async <T>(
       }
       await deadlineArg.join(collectionArg.init());
       try {
-        // A before image states the document's previous partition itself.
-        const previousPartitionsRead = optionsArg.returnDocument === 'after'
-          && await readPreviousWriteRevisions(
-            collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
-          );
+        // A before image states the document's previous partition itself, and
+        // so does an after image of an update that leaves the partition field
+        // alone: the field holds afterwards what it held before.
+        const partitionField = writeRevisionsPartitionField(collectionArg.smartdataDb);
+        const imageStatesPreviousPartition = optionsArg.returnDocument === 'before'
+          || (partitionField !== undefined && updateLeavesField(updateArg, partitionField));
+        const previousPartitionsRead = !imageStatesPreviousPartition
+          && await readPreviousWriteRevisions(collectionArg, rawSessionArg, filterArg, deadlineArg);
         const result = await collectionArg.mongoDbCollection.findOneAndUpdate(
           filterArg,
           updateArg,
@@ -226,7 +231,7 @@ export const executeAtomicFindOneAndReplace = async <T>(
       try {
         const previousPartitionsRead = optionsArg.returnDocument === 'after'
           && await readPreviousWriteRevisions(
-            collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+            collectionArg, rawSessionArg, filterArg, deadlineArg,
           );
         const result = await collectionArg.mongoDbCollection.findOneAndReplace(
           filterArg,

package/ts/nosqldb/classes.atomicupdate.ts

@@ -44,7 +44,7 @@ export const executeAtomicUpdate = async <T>(
       await deadlineArg.join(collectionArg.init());
       try {
         const previousPartitionsRead = await readPreviousWriteRevisions(
-          collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+          collectionArg, rawSessionArg, filterArg, deadlineArg,
         );
         const result = await collectionArg.mongoDbCollection.updateOne(
           filterArg,
@@ -140,8 +140,7 @@ export const executeAtomicUpsertMany = async <T>(
       };
       try {
         previousPartitionsRead = await readPreviousWriteRevisions(
-          collectionArg.smartdataDb,
-          collectionArg.mongoDbCollection,
+          collectionArg,
           rawSessionArg,
           { $or: operationsArg.map((operationArg) => operationArg.filter) },
           deadlineArg,
@@ -219,7 +218,7 @@ export const executeAtomicUpdateMany = async <T>(
       await deadlineArg.join(collectionArg.init());
       try {
         const previousPartitionsRead = await readPreviousWriteRevisions(
-          collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+          collectionArg, rawSessionArg, filterArg, deadlineArg,
         );
         const result = await collectionArg.mongoDbCollection.updateMany(
           filterArg,

package/ts/nosqldb/classes.collection.ts

@@ -2924,7 +2924,7 @@ export class SmartdataCollection<T> {
         };
         try {
           const previousPartitionsRead = await readPreviousWriteRevisions(
-            this.smartdataDb, this.mongoDbCollection, rawSessionArg, identifiableObject, deadlineArg,
+            this, rawSessionArg, identifiableObject, deadlineArg,
           );
           const result = await this.mongoDbCollection.updateOne(
             identifiableObject,
@@ -2969,7 +2969,7 @@ export class SmartdataCollection<T> {
           ? await dbDocArg.createSavableObject() as object
           : undefined;
         const previousPartitionsRead = await readPreviousWriteRevisions(
-          this.smartdataDb, this.mongoDbCollection, rawSessionArg, identifiableObject, deadlineArg,
+          this, rawSessionArg, identifiableObject, deadlineArg,
         );
         const result = await this.mongoDbCollection.deleteOne(identifiableObject, {
           session: rawSessionArg,

package/ts/nosqldb/classes.db.ts

@@ -34,7 +34,6 @@ import {
   configureSmartdataWriteRevisions,
   ensureSmartdataWriteRevisions,
   isSmartdataWriteRevisionsActive,
-  stopSmartdataWriteRevisionCompactions,
   type ISmartdataWriteRevisionsOptions,
 } from './classes.writerevisions.js';
 import {
@@ -432,11 +431,8 @@ export class SmartdataDb {
     try {
       const closeErrors: unknown[] = [];
       try {
-        // Followers and compactions abort at once; their reads end with the client otherwise.
-        const backgroundStop = Promise.all([
-          stopSmartdataWriteFollowers(this),
-          stopSmartdataWriteRevisionCompactions(this),
-        ]);
+        // Followers abort at once; their reads end with the client otherwise.
+        const backgroundStop = stopSmartdataWriteFollowers(this);
         if (budget) await budget.waitFor(backgroundStop);
         await backgroundStop;
       } catch (errorArg) {

package/ts/nosqldb/classes.exactpersistence.ts

@@ -1956,7 +1956,7 @@ export class SmartdataExactCollection<
     // the write-revision partition it held is read first.
     const previousPartitionsRead = current._smartdataRevision === undefined
       && await readPreviousWriteRevisions(
-        this.collection.smartdataDb, this.collection.mongoDbCollection, sessionArg, selector, deadlineArg,
+        this.collection, sessionArg, selector, deadlineArg,
       );
     const reportTransition = (): void => {
       reportSmartdataCollectionWrite(
@@ -2064,7 +2064,7 @@ export class SmartdataExactCollection<
         };
     const previousPartitionsRead = current._smartdataRevision === undefined
       && await readPreviousWriteRevisions(
-        this.collection.smartdataDb, this.collection.mongoDbCollection, sessionArg, selector, deadlineArg,
+        this.collection, sessionArg, selector, deadlineArg,
       );
     let result: plugins.mongodb.DeleteResult;
     const deleteOptions = { session: sessionArg, ...deadlineArg.commandOptions() };

package/ts/nosqldb/classes.readtracker.ts

@@ -1162,6 +1162,16 @@ export const captureSmartdataCollectionChange = (
   return () => applyChanges(dbArg, collectionArg, [{ kind: 'unknown', touched: 'all', startedAt: 0 }]);
 };
 
+/**
+ * @internal Whether an update by operators leaves a field as each document it
+ * updates held it: no operator names the field or a path through it. An update
+ * the tracker cannot follow may change any field.
+ */
+export const updateLeavesField = (updateArg: unknown, fieldArg: string): boolean => {
+  const { touched } = analyzeUpdate(updateArg, false);
+  return touched !== 'all' && ![...touched].some((pathArg) => pathsOverlap(pathArg, fieldArg));
+};
+
 /**
  * @internal The write-revision counters one acknowledged write bumps: the
  * partition of each document state it names before and after, and the shared

package/ts/nosqldb/classes.session.ts

@@ -37,10 +37,10 @@ import {
   type ISmartdataReadSpec,
 } from './classes.readtracker.js';
 import {
-  beginSmartdataWriteRevisionCommit,
+  beginSmartdataWriteRevisionAttempt,
   flushSmartdataWriteRevisions,
   isSmartdataWriteRevisionsActive,
-  noteSmartdataWriteRevisionEntries,
+  type ISmartdataWriteRevisionAttempt,
   readPreviousRevisionIds,
   sharedRevisionId,
   writeRevisionsPartitionField,
@@ -82,6 +82,8 @@ interface ISmartdataSessionBinding {
   transactionWrites: ISmartdataTransactionWrite[];
   /** The write-revision counters the current attempt's writes bump right before its commit. */
   revisionBumps: Set<string>;
+  /** The slots of those counters the current attempt holds. */
+  revisionAttempt?: ISmartdataWriteRevisionAttempt;
   /** The reports of the current attempt's writes, which its write-log entry carries. */
   logReports: ISmartdataWriteReport[];
   /** Collections the current attempt changed in ways no report describes. */
@@ -377,12 +379,14 @@ export class SmartdataSession {
     let attemptInterruption: { error: unknown } | undefined;
     /** The session-ended rejection the last attempt failed with, and how far that transaction had got. */
     let sessionEnded: { error: SmartdataPersistenceError; end: TSmartdataTransactionEnd } | undefined;
-    let finishRevisionCommit: (() => void) | undefined;
+    let revisionAttempt: ISmartdataWriteRevisionAttempt | undefined;
     /** The last attempt's write-log entry until the transaction's outcome is known. */
     let logCommit: ISmartdataWriteLogCommit | undefined;
     const runAttempt = async () => {
-      finishRevisionCommit?.();
-      finishRevisionCommit = undefined;
+      // The last attempt's slots end after this one starts, so it bumps others.
+      const attemptStartedAt = performance.now();
+      revisionAttempt?.finish(false);
+      revisionAttempt = beginSmartdataWriteRevisionAttempt(binding.owner, attemptStartedAt);
       // The driver starts another attempt only once the last one was aborted.
       logCommit?.settle();
       logCommit = undefined;
@@ -394,6 +398,7 @@ export class SmartdataSession {
       binding.transactionCommitReached = false;
       binding.transactionWrites = [];
       binding.revisionBumps = new Set();
+      binding.revisionAttempt = revisionAttempt;
       binding.logReports = [];
       binding.logUnplaced = new Set();
       callbackError = undefined;
@@ -452,8 +457,8 @@ export class SmartdataSession {
         // retried with it.
         const mongoDb = binding.client.db(binding.owner.smartdataOptions.mongoDbName);
         if (binding.revisionBumps.size > 0) {
-          finishRevisionCommit = beginSmartdataWriteRevisionCommit(binding.owner, binding.revisionBumps);
-          await flushSmartdataWriteRevisions(mongoDb, binding.rawSession, binding.revisionBumps, signal);
+          revisionAttempt.commit();
+          await flushSmartdataWriteRevisions(mongoDb, binding.rawSession, revisionAttempt.slots, signal);
         }
         logCommit = await flushSmartdataWriteLog(
           binding.owner,
@@ -557,7 +562,7 @@ export class SmartdataSession {
       throw rejectTransaction(error, outcome);
     } finally {
       if (!returnedFromCommit) {
-        finishRevisionCommit?.();
+        revisionAttempt?.finish(false);
         logCommit?.settle();
       }
       binding.transactionActive = false;
@@ -569,6 +574,7 @@ export class SmartdataSession {
       binding.transactionEnded = undefined;
       binding.transactionWrites = [];
       binding.revisionBumps = new Set();
+      binding.revisionAttempt = undefined;
       binding.logReports = [];
       binding.logUnplaced = new Set();
     }
@@ -578,7 +584,7 @@ export class SmartdataSession {
         try {
           if (outcome === 'unknown') changeReadsOfTransaction(committedWrites);
         } finally {
-          finishRevisionCommit?.();
+          revisionAttempt?.finish(false);
         }
         throw rejectTransaction(createTransactionSessionEndedError(transactionEnded), outcome);
       }
@@ -586,9 +592,8 @@ export class SmartdataSession {
         changeReadsOfTransaction(committedWrites);
         accountSmartdataOwnWriteRevisions(binding.owner, committedRevisionBumps);
       } finally {
-        finishRevisionCommit?.();
+        revisionAttempt?.finish(true);
       }
-      noteSmartdataWriteRevisionEntries(binding.owner, committedRevisionBumps);
       for (const write of committedWrites) {
         write.deliver?.();
       }
@@ -1051,7 +1056,10 @@ const bumpTransactionRevisions = (
 ): void => {
   const attempt = transactionContext.getStore()?.attempt;
   if (attempt === undefined || attempt !== bindingArg.transactionAttempt) return;
-  for (const id of idsArg) bindingArg.revisionBumps.add(id);
+  for (const id of idsArg) {
+    bindingArg.revisionBumps.add(id);
+    bindingArg.revisionAttempt?.bump(id);
+  }
 };
 
 /**
@@ -1059,19 +1067,26 @@ const bumpTransactionRevisions = (
  * documents a write by selector is about to change, and returns whether it
  * did; the write's report then states `previousPartitionsRead`. `false` when
  * the database keeps no revisions or the write runs outside an owned
- * transaction.
+ * transaction. `false` without a read, too, when the collection's model
+ * persists no partition field: its documents count on the shared counter,
+ * which the write's report bumps for each document state it cannot place, and
+ * every read of the collection depends on that counter.
  */
 export const readPreviousWriteRevisions = async (
-  ownerArg: SmartdataDb,
-  collectionArg: plugins.mongodb.Collection<any>,
+  collectionArg: SmartdataCollection<any>,
   rawSessionArg: plugins.mongodb.ClientSession | undefined,
   selectorArg: unknown,
   deadlineArg: SmartdataOperationDeadline,
 ): Promise<boolean> => {
-  if (!rawSessionArg || !isSmartdataWriteRevisionsActive(ownerArg)) return false;
+  const owner = collectionArg.smartdataDb;
+  if (!rawSessionArg || !isSmartdataWriteRevisionsActive(owner)) return false;
   const binding = bindingsByRawSession.get(rawSessionArg);
-  if (!binding?.transactionActive || binding.owner !== ownerArg) return false;
-  const ids = await readPreviousRevisionIds(ownerArg, collectionArg, rawSessionArg, selectorArg, deadlineArg);
+  if (!binding?.transactionActive || binding.owner !== owner) return false;
+  const persistedFields = collectionArg.getBoundModelSchema()?.persistedFields;
+  if (persistedFields && !persistedFields.includes(writeRevisionsPartitionField(owner)!)) return false;
+  const ids = await readPreviousRevisionIds(
+    owner, collectionArg.mongoDbCollection, rawSessionArg, selectorArg, deadlineArg,
+  );
   bumpTransactionRevisions(binding, ids);
   return true;
 };