@lossless.org/client 1.23.1 → 1.23.3

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.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

@@ -1067,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;
 };

package/ts/objectstorage/classes.directory.ts

@@ -243,6 +243,14 @@ export class Directory {
 
 
     const getDirectory = async (directoryArg: Directory, dirNameToSearch: string, isFinalDirectory: boolean) => {
+      // A listed directory and a new one of the same name are the same handle. Only whether the
+      // final directory exists decides anything, and only when it is created with an initializer
+      // file; otherwise a caller that accepts an empty directory needs no listing, which walks every
+      // key below the prefix and costs a large bucket seconds per level.
+      const createsInitializer = isFinalDirectory && optionsArg.createWithInitializerFile;
+      if ((optionsArg.getEmptyDirectory || optionsArg.createWithInitializerFile) && !createsInitializer) {
+        return new Directory(this.bucketRef, directoryArg, dirNameToSearch);
+      }
       const directories = await directoryArg.listDirectories();
       let returnDirectory = directories.find((directory) => {
         return directory.name === dirNameToSearch;