@lossless.org/client 1.22.2 → 1.23.1

package/ts/nosqldb/classes.session.ts

@@ -21,6 +21,7 @@ import {
   captureSmartdataWrite,
   hasSmartdataWriteObservers,
   type ISmartdataWrite,
+  type ISmartdataWriteReport,
   type TSmartdataWriteKind,
 } from './classes.writeobserver.js';
 import {
@@ -36,13 +37,22 @@ import {
   type ISmartdataReadSpec,
 } from './classes.readtracker.js';
 import {
-  beginSmartdataWriteRevisionCommit,
+  beginSmartdataWriteRevisionAttempt,
   flushSmartdataWriteRevisions,
   isSmartdataWriteRevisionsActive,
+  type ISmartdataWriteRevisionAttempt,
   readPreviousRevisionIds,
   sharedRevisionId,
   writeRevisionsPartitionField,
 } from './classes.writerevisions.js';
+import {
+  deliverSmartdataWriteLogCommit,
+  flushSmartdataWriteLog,
+  isSmartdataWriteLogActive,
+  requiresSmartdataWriteTransactions,
+  writeLogReportOf,
+  type ISmartdataWriteLogCommit,
+} from './classes.writelog.js';
 
 interface ISmartdataSessionBinding {
   session: SmartdataSession;
@@ -72,6 +82,12 @@ 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. */
+  logUnplaced: Set<string>;
   operationSettled?: Promise<void>;
   resolveOperationSettled?: () => void;
   invalidated: boolean;
@@ -363,10 +379,17 @@ 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;
       const attempt = Symbol('smartdataTransactionAttempt');
       binding.transactionAttempt = attempt;
       binding.transactionCallbackOpen = true;
@@ -375,6 +398,9 @@ export class SmartdataSession {
       binding.transactionCommitReached = false;
       binding.transactionWrites = [];
       binding.revisionBumps = new Set();
+      binding.revisionAttempt = revisionAttempt;
+      binding.logReports = [];
+      binding.logUnplaced = new Set();
       callbackError = undefined;
       attemptInterruption = undefined;
       try {
@@ -426,17 +452,22 @@ export class SmartdataSession {
         }
         // An abort that arrived while the callback ran rolls the attempt back.
         signal?.throwIfAborted();
-        // The writes' revisions commit with them. A failure fails the attempt
-        // before its commit, and a transient one is retried with it.
+        // The writes' revisions and write-log entry commit with them. A
+        // failure fails the attempt before its commit, and a transient one is
+        // 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(
-            binding.client.db(binding.owner.smartdataOptions.mongoDbName),
-            binding.rawSession,
-            binding.revisionBumps,
-            signal,
-          );
+          revisionAttempt.commit();
+          await flushSmartdataWriteRevisions(mongoDb, binding.rawSession, revisionAttempt.slots, signal);
         }
+        logCommit = await flushSmartdataWriteLog(
+          binding.owner,
+          mongoDb,
+          binding.rawSession,
+          binding.logReports,
+          binding.logUnplaced,
+          signal,
+        );
         // The driver commits next; a deadline that expires or a session that
         // ends from here on leaves the commit outcome unknown.
         binding.transactionCommitReached = true;
@@ -530,7 +561,10 @@ export class SmartdataSession {
       if (outcome === 'unknown') changeReadsOfTransaction(binding.transactionWrites);
       throw rejectTransaction(error, outcome);
     } finally {
-      if (!returnedFromCommit) finishRevisionCommit?.();
+      if (!returnedFromCommit) {
+        revisionAttempt?.finish(false);
+        logCommit?.settle();
+      }
       binding.transactionActive = false;
       binding.transactionTimeoutMS = undefined;
       binding.transactionSignal = undefined;
@@ -540,24 +574,33 @@ export class SmartdataSession {
       binding.transactionEnded = undefined;
       binding.transactionWrites = [];
       binding.revisionBumps = new Set();
+      binding.revisionAttempt = undefined;
+      binding.logReports = [];
+      binding.logUnplaced = new Set();
     }
-    if (transactionEnded) {
-      const outcome = commitOutcomeOfTransactionEnd(transactionEnded);
+    try {
+      if (transactionEnded) {
+        const outcome = commitOutcomeOfTransactionEnd(transactionEnded);
+        try {
+          if (outcome === 'unknown') changeReadsOfTransaction(committedWrites);
+        } finally {
+          revisionAttempt?.finish(false);
+        }
+        throw rejectTransaction(createTransactionSessionEndedError(transactionEnded), outcome);
+      }
       try {
-        if (outcome === 'unknown') changeReadsOfTransaction(committedWrites);
+        changeReadsOfTransaction(committedWrites);
+        accountSmartdataOwnWriteRevisions(binding.owner, committedRevisionBumps);
       } finally {
-        finishRevisionCommit?.();
+        revisionAttempt?.finish(true);
       }
-      throw rejectTransaction(createTransactionSessionEndedError(transactionEnded), outcome);
-    }
-    try {
-      changeReadsOfTransaction(committedWrites);
-      accountSmartdataOwnWriteRevisions(binding.owner, committedRevisionBumps);
+      for (const write of committedWrites) {
+        write.deliver?.();
+      }
+      // Followers hear of the commit before they may read it from the journal.
+      if (logCommit) deliverSmartdataWriteLogCommit(binding.owner, logCommit);
     } finally {
-      finishRevisionCommit?.();
-    }
-    for (const write of committedWrites) {
-      write.deliver?.();
+      logCommit?.settle();
     }
     return result;
   }
@@ -598,6 +641,8 @@ export const createSmartdataSession = (ownerArg: SmartdataDb): SmartdataSession
     transactionCommitReached: false,
     transactionWrites: [],
     revisionBumps: new Set(),
+    logReports: [],
+    logUnplaced: new Set(),
     invalidated: false,
   };
   bindings.set(session, binding);
@@ -854,18 +899,19 @@ const revisionTransactionSessionOf = (ownerArg: SmartdataDb): SmartdataSession |
 
 /**
  * Whether a write must start a transaction of its own to carry its write
- * revisions: the database keeps them and the write runs outside an owned
- * transaction. A raw driver session cannot carry them and is refused.
+ * revisions and write-log entry: the database keeps either and the write runs
+ * outside an owned transaction. A raw driver session cannot carry them and is
+ * refused.
  */
-export const needsSmartdataRevisionTransaction = (
+export const needsSmartdataWriteTransaction = (
   sessionArg: TSmartdataOrdinarySession | undefined,
   ownerArg: SmartdataDb,
 ): boolean => {
-  if (!isSmartdataWriteRevisionsActive(ownerArg)) return false;
+  if (!requiresSmartdataWriteTransactions(ownerArg)) return false;
   if (sessionArg !== undefined && !isSmartdataSession(sessionArg)) {
     throw new SmartdataPersistenceError(
       'unsupported_operation',
-      'Writes of a database with write revisions run on sessions of db.createSession(), not raw driver sessions.',
+      'Writes of a database with write revisions or a write log run on sessions of db.createSession(), not raw driver sessions.',
     );
   }
   return sessionArg === undefined || !resolveBinding(sessionArg, ownerArg).transactionActive;
@@ -880,13 +926,13 @@ const transactionOptionsOf = (
 });
 
 /**
- * Runs one write of a database with write revisions in a transaction, so its
- * revisions commit with it: on the caller's owned session, or on a session of
+ * Runs one write of a database with write revisions or a write log in a
+ * transaction, so its revisions and entry commit with it: on the caller's owned session, or on a session of
  * its own that ends with the call. The call's deadline and signal bound the
  * whole transaction; the collection is prepared before it starts, since its
  * DDL cannot run inside.
  */
-export const runSmartdataRevisionTransaction = async <TResult>(
+export const runSmartdataWriteTransaction = async <TResult>(
   sessionArg: SmartdataSession | undefined,
   ownerArg: SmartdataDb,
   optionsArg: Pick<
@@ -936,8 +982,8 @@ export const runWithOrdinarySmartdataSession = async <TResult>(
   ) => Promise<TResult>,
 ): Promise<TResult> => {
   optionsArg.signal?.throwIfAborted();
-  if (optionsArg.ordinaryWrite && needsSmartdataRevisionTransaction(sessionArg, ownerArg)) {
-    return runSmartdataRevisionTransaction(
+  if (optionsArg.ordinaryWrite && needsSmartdataWriteTransaction(sessionArg, ownerArg)) {
+    return runSmartdataWriteTransaction(
       sessionArg as SmartdataSession | undefined,
       ownerArg,
       optionsArg,
@@ -985,6 +1031,21 @@ const bufferTransactionWrite = (
   }
 };
 
+/**
+ * Adds a write's report, or a collection no report describes, to the
+ * write-log entry of an owned transaction's current attempt. A write that
+ * settles after its attempt ended rolls back with that attempt.
+ */
+const logTransactionWrite = (
+  bindingArg: ISmartdataSessionBinding,
+  writeArg: { report: ISmartdataWriteReport } | { unplaced: string },
+): void => {
+  const attempt = transactionContext.getStore()?.attempt;
+  if (attempt === undefined || attempt !== bindingArg.transactionAttempt) return;
+  if ('report' in writeArg) bindingArg.logReports.push(writeArg.report);
+  else bindingArg.logUnplaced.add(writeArg.unplaced);
+};
+
 /**
  * Adds write-revision counters to the current attempt of an owned transaction.
  * A write that settles after its attempt ended rolls back with that attempt.
@@ -995,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);
+  }
 };
 
 /**
@@ -1046,6 +1110,8 @@ export const reportSmartdataWrite = (
     if (field !== undefined && isSmartdataWriteRevisionsActive(ownerArg)) {
       bumpTransactionRevisions(binding, writeRevisionIdsOfWrite(writeArg, field));
     }
+    const report = writeLogReportOf(ownerArg, writeArg);
+    if (report) logTransactionWrite(binding, { report });
   }
   const changeReads = captureSmartdataReadChange(ownerArg, writeArg, buffered);
   const deliver = captureSmartdataWrite(ownerArg, writeArg);
@@ -1074,6 +1140,9 @@ export const reportSmartdataWriteFailure = (
   if (binding && buffered && isSmartdataWriteRevisionsActive(ownerArg)) {
     bumpTransactionRevisions(binding, [sharedRevisionId(collectionNameArg)]);
   }
+  if (binding && buffered && isSmartdataWriteLogActive(ownerArg)) {
+    logTransactionWrite(binding, { unplaced: collectionNameArg });
+  }
   const changeReads = captureSmartdataCollectionChange(ownerArg, collectionNameArg, buffered);
   if (!changeReads) return;
   if (binding && buffered) {