@lossless.org/client 1.23.0 → 1.23.2

package/dist_ts/nosqldb/classes.writerevisions.d.ts

@@ -7,10 +7,12 @@ import type { SmartdataOperationDeadline } from './classes.operationdeadline.js'
  * partition in the same transaction, and a read set compares the counters it
  * read before its reads with the current ones.
  *
- * A bump inserts an entry of its own instead of incrementing a shared
- * document, so concurrent transactions of one partition never conflict on its
- * counter. A counter's value is its base document plus its entries; a
- * background compaction folds entries into the base, which keeps the sum.
+ * A counter is its base document, which a writer bumps alone, and up to
+ * `counterShards - 1` shard documents that overlapping transactions bump
+ * instead, so they do not conflict on the base. A list document beside the
+ * base holds how many slots are in use, and the transaction that first bumps
+ * a slot raises it, so a snapshot reads the bases and lists in one query and
+ * only the listed shards of the counters that have any.
  */
 export interface ISmartdataWriteRevisionsOptions {
     /**
@@ -35,13 +37,39 @@ export declare const isSmartdataWriteRevisionsActive: (dbArg: SmartdataDb) => bo
 export declare const partitionRevisionId: (collectionArg: string, partitionArg: string) => string;
 /** @internal The counter of a collection's writes that no partition can place. */
 export declare const sharedRevisionId: (collectionArg: string) => string;
+/** @internal The document of a counter's slot: the base for slot 0, a shard otherwise. */
+export declare const revisionSlotId: (idArg: string, slotArg: number) => string;
+/** @internal The document that lists how many slots of a counter are in use; none means only the base. */
+export declare const revisionSlotListId: (idArg: string) => string;
 /**
  * @internal The counter a stored value of the partition field belongs to:
  * its partition's for a string the counters can name, the shared one otherwise.
  */
 export declare const revisionIdOfValue: (collectionArg: string, valueArg: unknown) => string;
 export declare const writeRevisionBumpsOfKey: (keyArg: string, idsArg: ReadonlySet<string>) => number;
-export declare const beginSmartdataWriteRevisionCommit: (dbArg: SmartdataDb, idsArg: ReadonlySet<string>) => (() => void);
+/**
+ * @internal The slots one attempt of a transaction bumps. A counter takes its
+ * slot at its first bump in the attempt and holds it until the attempt ends,
+ * so no other attempt of this instance commits to it in between.
+ */
+export interface ISmartdataWriteRevisionAttempt {
+    /** The slot of each counter the attempt bumps. */
+    readonly slots: ReadonlyMap<string, number>;
+    /** Takes a slot of a counter the attempt has not bumped yet; once the attempt ended, none. */
+    bump(idArg: string): void;
+    /**
+     * Right before the commit: until the attempt ends, a snapshot of this
+     * instance that depends on its counters cannot tell its bumps from those of
+     * other processes.
+     */
+    commit(): void;
+    /**
+     * Ends the attempt: releases its slots and, after a commit, makes them the
+     * counters' preferred ones. Later calls do nothing.
+     */
+    finish(committedArg: boolean): void;
+}
+export declare const beginSmartdataWriteRevisionAttempt: (dbArg: SmartdataDb, attemptStartedAtArg: number) => ISmartdataWriteRevisionAttempt;
 /**
  * @internal The snapshot keys one read depends on. A read the field pins
  * depends on its partitions and the shared counter, which holds every
@@ -70,19 +98,13 @@ export declare const bumpSmartdataWriteRevisionEpoch: (dbArg: SmartdataDb, optio
 }) => Promise<void>;
 /**
  * @internal Bumps the counters a transaction's writes touched, inside that
- * transaction, right before its commit: one new entry per counter, which no
- * concurrent transaction writes.
- */
-export declare const flushSmartdataWriteRevisions: (mongoDbArg: plugins.mongodb.Db, rawSessionArg: plugins.mongodb.ClientSession, idsArg: ReadonlySet<string>, signalArg: AbortSignal | undefined) => Promise<void>;
-/**
- * @internal Counts the entries a committed transaction of this process added,
- * and starts a compaction of each counter that reached `compactionEntries`.
- * Compactions run in the background; `stopSmartdataWriteRevisionCompactions`
- * ends them.
+ * transaction, right before its commit: each in the slot it took. A shard
+ * bump first makes sure the counter's list exists and holds the slot; once it
+ * does, neither update changes it, so later bumps of listed slots write only
+ * their own document. A slot whose value is no number stays as it is, which
+ * keeps its counter unknown, and the write still commits.
  */
-export declare const noteSmartdataWriteRevisionEntries: (dbArg: SmartdataDb, idsArg: ReadonlySet<string>) => void;
-/** @internal Aborts the database's compactions and waits until they settled; `close()` calls it. */
-export declare const stopSmartdataWriteRevisionCompactions: (dbArg: SmartdataDb) => Promise<void>;
+export declare const flushSmartdataWriteRevisions: (mongoDbArg: plugins.mongodb.Db, rawSessionArg: plugins.mongodb.ClientSession, slotsArg: ReadonlyMap<string, number>, signalArg: AbortSignal | undefined) => Promise<void>;
 /**
  * @internal The counters of the documents a write by selector is about to
  * change, read in its transaction before it runs. Snapshot isolation makes

package/dist_ts/nosqldb/classes.writerevisions.js

@@ -1,22 +1,19 @@
 import * as plugins from './plugins.js';
 import { assertDataOptions } from './classes.operationbudget.js';
 import { SmartdataPersistenceError, isMongoDuplicateKeyError } from './classes.persistence.js';
-import { logger } from './logging.js';
 /** The collection that holds the counters. */
 export const writeRevisionsCollectionName = '__smartdata_write_revisions';
 /** The counter every write revision belongs to; a new generation restarts all counters. */
 const epochId = '$epoch';
+/** Joins a counter's id and the slot of one of its shards, or ends the id of its list. No counter id contains it. */
+const shardSeparator = '\u0000';
 /**
- * Joins a counter's id and the suffix of one of its entries. No counter id
- * contains it, so a counter's base and entries are exactly the ids from the
- * counter's own up to, not including, the id followed by `entryRangeEnd`.
+ * Slots per counter, the base included: as many transactions that overlap in
+ * time can bump one counter without conflicting on it.
  */
-const entrySeparator = '\u0000';
-const entryRangeEnd = '\u0001';
-/** Entries one process adds to a counter before it folds the counter's entries into its base. */
-const compactionEntries = 64;
-const maximumCompactedEntries = 1024;
-const compactionTimeoutMs = 5_000;
+const counterShards = 16;
+/** Counters whose slots a database instance remembers, beyond those an open transaction holds. */
+const maximumRememberedCounters = 4096;
 const maximumPartitionLength = 512;
 const maximumPinnedPartitions = 64;
 /** Beyond this many documents, a write by selector bumps the shared counter instead. */
@@ -46,13 +43,17 @@ export const isSmartdataWriteRevisionsActive = (dbArg) => partitionFields.has(db
 const partitionOf = (valueArg) => typeof valueArg === 'string'
     && valueArg.length <= maximumPartitionLength
     && valueArg.isWellFormed()
-    && !valueArg.includes(entrySeparator)
+    && !valueArg.includes(shardSeparator)
     ? valueArg
     : undefined;
 /** @internal The counter of one partition of a collection. */
 export const partitionRevisionId = (collectionArg, partitionArg) => `${collectionArg}$s${partitionArg}`;
 /** @internal The counter of a collection's writes that no partition can place. */
 export const sharedRevisionId = (collectionArg) => `${collectionArg}$*`;
+/** @internal The document of a counter's slot: the base for slot 0, a shard otherwise. */
+export const revisionSlotId = (idArg, slotArg) => slotArg === 0 ? idArg : `${idArg}${shardSeparator}${slotArg}`;
+/** @internal The document that lists how many slots of a counter are in use; none means only the base. */
+export const revisionSlotListId = (idArg) => `${idArg}${shardSeparator}`;
 /**
  * @internal The counter a stored value of the partition field belongs to:
  * its partition's for a string the counters can name, the shared one otherwise.
@@ -139,15 +140,89 @@ export const writeRevisionBumpsOfKey = (keyArg, idsArg) => {
     }
     return bumps;
 };
-export const beginSmartdataWriteRevisionCommit = (dbArg, idsArg) => {
-    const commits = revisionCommitsOfDb(dbArg);
-    const ids = new Set(idsArg);
-    commits.pending.add(ids);
-    for (const snapshot of commits.snapshots) {
-        if (snapshot.keys.some((keyArg) => writeRevisionBumpsOfKey(keyArg, ids) > 0))
-            snapshot.lost = true;
+/** Per database instance, in least recently bumped order. */
+const revisionSlotsOfDbs = new WeakMap();
+/**
+ * The slot of a counter an attempt that started at `attemptStartedAtArg`
+ * bumps: from the preferred one on, the first that no attempt of this instance
+ * holds or ended since then, whose commit the attempt's snapshot might not
+ * see. Without one, the first that none holds, and the preferred one last.
+ * Transactions of other instances may still take the same slot; a conflict
+ * then fails the attempt, and its retry starts after the slot's end, so it
+ * moves on to another.
+ */
+const chooseRevisionSlot = (counterArg, attemptStartedAtArg) => {
+    let unheld;
+    for (let offset = 0; offset < counterShards; offset++) {
+        const slot = (counterArg.preferred + offset) % counterShards;
+        const state = counterArg.slots[slot];
+        if (state.holders > 0)
+            continue;
+        if (state.endedAt < attemptStartedAtArg)
+            return slot;
+        unheld ??= slot;
     }
-    return () => { commits.pending.delete(ids); };
+    return unheld ?? counterArg.preferred;
+};
+export const beginSmartdataWriteRevisionAttempt = (dbArg, attemptStartedAtArg) => {
+    const taken = [];
+    const slots = new Map();
+    let pending;
+    let finished = false;
+    return {
+        slots,
+        bump: (idArg) => {
+            if (finished || slots.has(idArg))
+                return;
+            let counters = revisionSlotsOfDbs.get(dbArg);
+            if (!counters) {
+                counters = new Map();
+                revisionSlotsOfDbs.set(dbArg, counters);
+            }
+            const counter = counters.get(idArg) ?? {
+                preferred: 0,
+                slots: Array.from({ length: counterShards }, () => ({ holders: 0, endedAt: -Infinity })),
+            };
+            counters.delete(idArg);
+            counters.set(idArg, counter);
+            const slot = chooseRevisionSlot(counter, attemptStartedAtArg);
+            counter.slots[slot].holders++;
+            taken.push([counter, slot]);
+            slots.set(idArg, slot);
+            for (const [id, remembered] of counters) {
+                if (counters.size <= maximumRememberedCounters)
+                    break;
+                if (remembered.slots.every((slotArg) => slotArg.holders === 0))
+                    counters.delete(id);
+            }
+        },
+        commit: () => {
+            if (finished || pending)
+                return;
+            const commits = revisionCommitsOfDb(dbArg);
+            const ids = new Set(slots.keys());
+            pending = ids;
+            commits.pending.add(ids);
+            for (const snapshot of commits.snapshots) {
+                if (snapshot.keys.some((keyArg) => writeRevisionBumpsOfKey(keyArg, ids) > 0))
+                    snapshot.lost = true;
+            }
+        },
+        finish: (committedArg) => {
+            if (finished)
+                return;
+            finished = true;
+            if (pending)
+                revisionCommitsOfDb(dbArg).pending.delete(pending);
+            const endedAt = performance.now();
+            for (const [counter, slot] of taken) {
+                counter.slots[slot].holders--;
+                counter.slots[slot].endedAt = endedAt;
+                if (committedArg)
+                    counter.preferred = slot;
+            }
+        },
+    };
 };
 /**
  * @internal The snapshot keys one read depends on. A read the field pins
@@ -177,9 +252,12 @@ const connectedDb = (dbArg) => {
 };
 /**
  * @internal The current value of each snapshot key, or `undefined` for a key
- * whose value cannot be known: a missing epoch means the counters restarted.
- * Every counter and collection sum is one read, so a compaction that moves
- * entries into a base never shows half done. Bounded by its own deadline.
+ * whose value cannot be known: a missing epoch means the counters restarted,
+ * and a counter with a value or slot count no writer stores stays unknown. One
+ * query reads the epoch, the bases and their lists, a second the listed
+ * shards. Every part only grows, and a slot is listed by the transaction that
+ * first bumps it, so a write that commits between the two queries shows in
+ * this snapshot or in the next, never in neither. Bounded by its own deadline.
  */
 const readStoredWriteRevisionSnapshot = async (dbArg, keysArg) => {
     const collection = revisionsCollection(connectedDb(dbArg));
@@ -190,10 +268,11 @@ const readStoredWriteRevisionSnapshot = async (dbArg, keysArg) => {
         timeoutMode: 'cursorLifetime',
         signal,
     });
+    const readDocuments = async (idsArg) => new Map((await collection.find({ _id: { $in: idsArg } }, { projection: { n: 1, generation: 1, slots: 1 }, ...options() }).toArray()).map((documentArg) => [documentArg._id, documentArg]));
     // `$sum` skips a value that is not a number, so such values are counted apart.
-    const sumOf = async (fromArg, toArg) => {
+    const sumOf = async (collectionArg) => {
         const [sum] = await collection.aggregate([
-            { $match: { _id: { $gte: fromArg, $lt: toArg } } },
+            { $match: { _id: { $gte: `${collectionArg}$`, $lt: `${collectionArg}%` } } },
             { $group: { _id: null, n: { $sum: '$n' }, invalid: { $sum: { $cond: [{ $isNumber: '$n' }, 0, 1] } } } },
         ], options()).toArray();
         if (sum === undefined)
@@ -202,27 +281,43 @@ const readStoredWriteRevisionSnapshot = async (dbArg, keysArg) => {
             ? String(sum.n)
             : undefined;
     };
-    const sums = keysArg.flatMap((keyArg) => {
-        if (keyArg.startsWith('c')) {
-            const id = keyArg.slice(1);
-            return [[keyArg, sumOf(id, `${id}${entryRangeEnd}`)]];
-        }
-        if (keyArg.startsWith('r')) {
-            const collectionName = keyArg.slice(1);
-            return [[keyArg, sumOf(`${collectionName}$`, `${collectionName}%`)]];
-        }
-        return [];
-    });
-    const [epoch, ...values] = await Promise.all([
-        collection.findOne({ _id: epochId }, { projection: { n: 1, generation: 1 }, ...options() }),
-        ...sums.map(([, sumArg]) => sumArg),
+    const counterIds = keysArg.flatMap((keyArg) => keyArg.startsWith('c') ? [keyArg.slice(1)] : []);
+    const ranges = keysArg.flatMap((keyArg) => keyArg.startsWith('r') ? [keyArg.slice(1)] : []);
+    const [bases, ...sums] = await Promise.all([
+        readDocuments([epochId, ...counterIds.flatMap((idArg) => [idArg, revisionSlotListId(idArg)])]),
+        ...ranges.map(sumOf),
     ]);
+    /** The slots each counter's list holds, or `undefined` for a count no writer stores. */
+    const slotCounts = new Map(counterIds.map((idArg) => {
+        const list = bases.get(revisionSlotListId(idArg));
+        const count = list === undefined ? 1 : list.slots;
+        return [idArg, Number.isSafeInteger(count) && count >= 1 && count <= counterShards
+                ? count
+                : undefined];
+    }));
+    const shardIds = counterIds.flatMap((idArg) => Array.from({ length: (slotCounts.get(idArg) ?? 1) - 1 }, (_unusedArg, indexArg) => revisionSlotId(idArg, indexArg + 1)));
+    const shards = shardIds.length === 0 ? new Map() : await readDocuments(shardIds);
     const snapshot = new Map();
+    const epoch = bases.get(epochId);
     snapshot.set(epochKey, typeof epoch?.generation === 'string' && Number.isSafeInteger(epoch.n)
         ? `${epoch.generation}:${epoch.n}`
         : undefined);
-    for (const [index, [key]] of sums.entries())
-        snapshot.set(key, values[index]);
+    for (const id of counterIds) {
+        const count = slotCounts.get(id);
+        let sum = count === undefined ? undefined : 0;
+        for (let slot = 0; sum !== undefined && slot < count; slot++) {
+            // A slot is missing until its first bump commits; a later one may commit first.
+            const document = slot === 0 ? bases.get(id) : shards.get(revisionSlotId(id, slot));
+            if (document === undefined)
+                continue;
+            sum = Number.isSafeInteger(document.n) && Number.isSafeInteger(sum + document.n)
+                ? sum + document.n
+                : undefined;
+        }
+        snapshot.set(counterKey(id), sum === undefined ? undefined : String(sum));
+    }
+    for (const [index, collectionName] of ranges.entries())
+        snapshot.set(rangeKey(collectionName), sums[index]);
     return snapshot;
 };
 export const readWriteRevisionSnapshot = async (dbArg, keysArg) => {
@@ -276,98 +371,40 @@ export const bumpSmartdataWriteRevisionEpoch = async (dbArg, optionsArg) => {
 };
 /**
  * @internal Bumps the counters a transaction's writes touched, inside that
- * transaction, right before its commit: one new entry per counter, which no
- * concurrent transaction writes.
+ * transaction, right before its commit: each in the slot it took. A shard
+ * bump first makes sure the counter's list exists and holds the slot; once it
+ * does, neither update changes it, so later bumps of listed slots write only
+ * their own document. A slot whose value is no number stays as it is, which
+ * keeps its counter unknown, and the write still commits.
  */
-export const flushSmartdataWriteRevisions = async (mongoDbArg, rawSessionArg, idsArg, signalArg) => {
-    if (idsArg.size === 0)
+export const flushSmartdataWriteRevisions = async (mongoDbArg, rawSessionArg, slotsArg, signalArg) => {
+    if (slotsArg.size === 0)
         return;
-    await revisionsCollection(mongoDbArg).insertMany([...idsArg].map((idArg) => ({
-        _id: `${idArg}${entrySeparator}${plugins.nodeCrypto.randomUUID()}`,
-        n: 1,
-    })), {
+    const operations = [];
+    for (const [id, slot] of [...slotsArg].sort(([aArg], [bArg]) => aArg < bArg ? -1 : aArg > bArg ? 1 : 0)) {
+        if (slot > 0) {
+            const listId = revisionSlotListId(id);
+            operations.push({ updateOne: { filter: { _id: listId }, update: { $setOnInsert: { n: 0 } }, upsert: true } }, {
+                updateOne: {
+                    filter: { _id: listId, $or: [{ slots: { $exists: false } }, { slots: { $lt: slot + 1 } }] },
+                    update: { $set: { slots: slot + 1 } },
+                },
+            });
+        }
+        const slotId = revisionSlotId(id, slot);
+        operations.push({
+            updateOne: {
+                filter: { _id: slotId, $or: [{ n: { $type: 'int' } }, { n: { $type: 'long' } }, { n: { $type: 'double' } }] },
+                update: { $inc: { n: 1 } },
+            },
+        }, { updateOne: { filter: { _id: slotId }, update: { $setOnInsert: { n: 1 } }, upsert: true } });
+    }
+    await revisionsCollection(mongoDbArg).bulkWrite(operations, {
         ordered: true,
         session: rawSessionArg,
         ...(signalArg === undefined ? {} : { signal: signalArg }),
     });
 };
-const revisionCompactions = new WeakMap();
-/**
- * Folds up to `maximumCompactedEntries` entries of one counter into its base
- * in one transaction, which keeps the counter's value. A concurrent compaction
- * of the same counter conflicts on the base and on the entries, and the driver
- * retries it within the deadline; one that still fails leaves the entries for
- * the next.
- */
-const compactWriteRevisionEntries = async (dbArg, idArg, signalArg) => {
-    const collection = revisionsCollection(connectedDb(dbArg));
-    const abortable = { signal: signalArg };
-    const session = dbArg.mongoDbClient.startSession();
-    try {
-        await session.withTransaction(async () => {
-            const entries = await collection.find({ _id: { $gt: `${idArg}${entrySeparator}`, $lt: `${idArg}${entryRangeEnd}` } }, { projection: { n: 1 }, limit: maximumCompactedEntries, session, ...abortable }).toArray();
-            if (entries.length === 0)
-                return;
-            let sum = 0;
-            for (const entry of entries) {
-                if (!Number.isSafeInteger(entry.n)) {
-                    throw new SmartdataPersistenceError('invalid_document', `Write-revision entry "${entry._id}" holds no safe integer.`);
-                }
-                sum += entry.n;
-                if (!Number.isSafeInteger(sum)) {
-                    throw new SmartdataPersistenceError('invalid_document', `Write-revision entries of "${idArg}" do not sum to a safe integer.`);
-                }
-            }
-            await collection.deleteMany({ _id: { $in: entries.map((entryArg) => entryArg._id) } }, { session, ...abortable });
-            await collection.updateOne({ _id: idArg }, { $inc: { n: sum } }, { upsert: true, session, ...abortable });
-        }, { timeoutMS: compactionTimeoutMs });
-    }
-    finally {
-        await session.endSession();
-    }
-};
-/**
- * @internal Counts the entries a committed transaction of this process added,
- * and starts a compaction of each counter that reached `compactionEntries`.
- * Compactions run in the background; `stopSmartdataWriteRevisionCompactions`
- * ends them.
- */
-export const noteSmartdataWriteRevisionEntries = (dbArg, idsArg) => {
-    if (idsArg.size === 0 || dbArg.status !== 'connected' || !isSmartdataWriteRevisionsActive(dbArg))
-        return;
-    let state = revisionCompactions.get(dbArg);
-    if (!state) {
-        state = { entries: new Map(), running: new Map(), controller: new AbortController() };
-        revisionCompactions.set(dbArg, state);
-    }
-    const compactions = state;
-    for (const id of idsArg) {
-        const entries = (compactions.entries.get(id) ?? 0) + 1;
-        if (entries < compactionEntries || compactions.running.has(id)) {
-            compactions.entries.set(id, entries);
-            continue;
-        }
-        compactions.entries.delete(id);
-        const signal = compactions.controller.signal;
-        const compaction = compactWriteRevisionEntries(dbArg, id, signal)
-            .catch((errorArg) => {
-            if (signal.aborted)
-                return;
-            logger.log('warn', `Compacting the write revisions of "${id}" failed; a later compaction retries: ${errorArg instanceof Error ? errorArg.message : String(errorArg)}`);
-        })
-            .finally(() => { compactions.running.delete(id); });
-        compactions.running.set(id, compaction);
-    }
-};
-/** @internal Aborts the database's compactions and waits until they settled; `close()` calls it. */
-export const stopSmartdataWriteRevisionCompactions = async (dbArg) => {
-    const state = revisionCompactions.get(dbArg);
-    if (!state)
-        return;
-    revisionCompactions.delete(dbArg);
-    state.controller.abort();
-    await Promise.allSettled(state.running.values());
-};
 /**
  * @internal The counters of the documents a write by selector is about to
  * change, read in its transaction before it runs. Snapshot isolation makes
@@ -392,4 +429,4 @@ export const readPreviousRevisionIds = async (dbArg, collectionArg, rawSessionAr
     }
     return ids;
 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.writerevisions.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.writerevisions.ts"],"names":[],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.writerevisions.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.writerevisions.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lossless.org/client",
-  "version": "1.23.0",
+  "version": "1.23.2",
   "private": false,
   "publishConfig": {
     "registry": "https://verdaccio.lossless.digital"

package/readme.md

@@ -125,7 +125,7 @@ Family imports preserve the established SmartData and SmartBucket names and cons
 | Subclasses need their own binding | a subclass of a bound model that declares decorators or a persistence policy of its own and no `@Collection()`, `@managed()` or `defineCollectionModel()` binding is refused with `invalid_configuration` on every read and write, so it never writes through the parent's schema; an undecorated subclass keeps the inherited binding |
 | Observing this process's writes | `db.observeWrites({ fields, listener })` — one frozen report per acknowledged model write, `{ collection, kind, documents, anchors }` with the requested top-level fields of the written documents and of the selector's equality anchors; writes inside a `db.createSession()` transaction are reported after the commit, never after a rollback; works on NoSQLDB, where `watch()` is unsupported |
 | Following this process's reads | `db.trackReads(fn)` resolves `{ result, reads }`; `reads.changed` turns true once a write this process makes through the database's models could have changed what a model read of `fn` returned, judged by the read's query and the ids it returned, and a write it cannot place counts as one that did, so a cache keyed by `reads` rebuilds only what a write touched; works on NoSQLDB |
-| Following every process's writes | with `new SmartdataDb({ ..., writeRevisions: { partitionField: 'organizationId' } })` in every writer, the awaited `reads.isCurrent()` counts changes per collection and partition in the write's transaction; confirmed writes of this database that leave `reads.changed` false receive exact revision allowances, while other writers and unknown outcomes stay conservative; a revision snapshot overlapping a local commit that touches its keys is unknowable; `db.invalidateTrackedReads()` states raw writes and migrations; each write inserts its own counter entry, so concurrent writers of one partition do not conflict on it, and every process of a database upgrades together; needs an engine identified as NoSQLDB, elsewhere `isCurrent()` is always false |
+| Following every process's writes | with `new SmartdataDb({ ..., writeRevisions: { partitionField: 'organizationId' } })` in every writer, the awaited `reads.isCurrent()` counts changes per collection and partition in the write's transaction; confirmed writes of this database that leave `reads.changed` false receive exact revision allowances, while other writers and unknown outcomes stay conservative; a revision snapshot overlapping a local commit that touches its keys is unknowable; `db.invalidateTrackedReads()` states raw writes and migrations; overlapping transactions of one process bump separate documents of a partition's counter, so they rarely conflict on it, a check reads the counters in one query plus one for those with shards in use, and every process of a database upgrades together; needs an engine identified as NoSQLDB, elsewhere `isCurrent()` is always false |
 | Following committed writes in commit order | with `new SmartdataDb({ ..., writeLog: { fields: ['id', 'organizationId'] } })` in every writer, `db.followWrites({ fields, onWrite, onGap })` delivers each committed transaction once with its write reports: this instance's own commits at once (`origin: 'local'`), every other commit from the engine's commit journal in commit order (`origin: 'journal'`, with its `stamp`), within 250 ms while active and a second when idle; rollbacks and aborted retry attempts deliver nothing, raw writes name their collections in `unplaced`, and a follower that falls out of the journal's 15-minute retention or meets a restarted memory engine calls `onGap` and continues from the head; needs NoSQLDB 10.9.0, elsewhere the option is inert and following is refused with `unsupported_operation` |
 | Disposable test databases on a unix socket | `SmartdataTestDatabase.create({ connection: { socketPath } })` from `@lossless.org/client/testsupport` reaches an engine that listens only on a unix-domain socket, fault helpers included; the loopback `host`/`port` form is unchanged |
 

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@lossless.org/client',
-  version: '1.23.0',
+  version: '1.23.2',
   description: 'One typed client for NoSQLDB, MongoDB, SQLDB, MariaDB, ClickHouse and S3 object storage.'
 }

package/ts/nosqldb/classes.atomicdelete.ts

@@ -35,7 +35,7 @@ export const executeAtomicDelete = async <T>(
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
       const previousPartitionsRead = await readPreviousWriteRevisions(
-        collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+        collectionArg, rawSessionArg, filterArg, deadlineArg,
       );
       const result = await collectionArg.mongoDbCollection.deleteOne(
         filterArg,
@@ -90,7 +90,7 @@ export const executeAtomicDeleteMany = async <T>(
     async (rawSessionArg, deadlineArg) => {
       await deadlineArg.join(collectionArg.init());
       const previousPartitionsRead = await readPreviousWriteRevisions(
-        collectionArg.smartdataDb, collectionArg.mongoDbCollection, rawSessionArg, filterArg, deadlineArg,
+        collectionArg, rawSessionArg, filterArg, deadlineArg,
       );
       const result = await collectionArg.mongoDbCollection.deleteMany(
         filterArg,