@lossless.org/client 1.22.2 → 1.23.1

package/dist_ts/nosqldb/classes.writelog.js

@@ -0,0 +1,497 @@
+import * as plugins from './plugins.js';
+import { assertDataOptions } from './classes.operationbudget.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import { narrowSmartdataWriteReport, normalizeObservedFields, reportOfSmartdataWrite, } from './classes.writeobserver.js';
+import { isSmartdataWriteRevisionsActive, writeRevisionsCollectionName } from './classes.writerevisions.js';
+import { smartdataCommitJournal } from './engineidentity.js';
+import { logger } from './logging.js';
+/** The collection that holds the entries. */
+export const writeLogCollectionName = '__smartdata_write_log';
+/** How long an entry is kept. The engine keeps a commit in its journal at most as long. */
+export const writeLogRetentionSeconds = 15 * 60;
+const expiryIndexName = 'smartdata_write_log_expiry';
+const activePollMs = 250;
+const idlePollMs = 1_000;
+/** A follower that saw a commit this recently polls at the active pace. */
+const activeWindowMs = 60_000;
+const pageLimit = 128;
+/** The engine's largest page; a single commit record larger than a page is refused. */
+const pageBytes = 4 * 1024 * 1024;
+const readTimeoutMs = 5_000;
+/** Beyond these bounds, an entry states its largest collections as unplaced instead. */
+const maximumEntryDocuments = 4_096;
+const maximumEntryBytes = 1024 * 1024;
+/** How long a follower remembers a local delivery whose commit the journal has not listed yet. */
+const localDeliveryMemoryMs = 2 * writeLogRetentionSeconds * 1_000;
+/**
+ * Namespaces whose changes only carry the bookkeeping of model writes, and the
+ * database's own namespace, which a catalog change publishes beside the
+ * collection it changed.
+ */
+const bookkeepingCollections = new Set([
+    '',
+    writeLogCollectionName,
+    writeRevisionsCollectionName,
+]);
+const writeKinds = new Set(['insert', 'update', 'replace', 'delete']);
+const logFields = new WeakMap();
+const logStates = new WeakMap();
+const stateOf = (dbArg) => {
+    let state = logStates.get(dbArg);
+    if (!state) {
+        state = { followers: new Set(), pending: new Map() };
+        logStates.set(dbArg, state);
+    }
+    return state;
+};
+/** @internal Validates and records the option; called once by the database's constructor. */
+export const configureSmartdataWriteLog = (dbArg, optionsArg) => {
+    if (optionsArg === undefined)
+        return;
+    const { fields } = assertDataOptions(optionsArg, ['fields']);
+    logFields.set(dbArg, normalizeObservedFields(fields, 'A SmartData write log'));
+};
+/**
+ * @internal The write log is configured and the engine journals its commits
+ * in commit order; elsewhere the option is inert.
+ */
+export const isSmartdataWriteLogActive = (dbArg) => logFields.has(dbArg)
+    && dbArg.capabilities?.transactions === 'available'
+    && smartdataCommitJournal(dbArg.engineIdentity);
+/**
+ * @internal Every model write runs in an owned transaction, which carries its
+ * write revisions and its write-log entry.
+ */
+export const requiresSmartdataWriteTransactions = (dbArg) => isSmartdataWriteRevisionsActive(dbArg) || isSmartdataWriteLogActive(dbArg);
+/** @internal The report a write adds to its transaction's entry, or `undefined` without an active log. */
+export const writeLogReportOf = (dbArg, writeArg) => {
+    const fields = logFields.get(dbArg);
+    return fields !== undefined && isSmartdataWriteLogActive(dbArg)
+        ? reportOfSmartdataWrite(writeArg, fields)
+        : undefined;
+};
+const logCollection = (mongoDbArg) => mongoDbArg.collection(writeLogCollectionName);
+/**
+ * @internal Creates the index that expires entries, before `init()` publishes
+ * the connection. Another process creating it at the same time is fine.
+ */
+export const ensureSmartdataWriteLog = async (mongoDbArg, optionsArg = {}) => {
+    await logCollection(mongoDbArg).createIndex({ at: 1 }, {
+        name: expiryIndexName,
+        expireAfterSeconds: writeLogRetentionSeconds,
+        ...optionsArg,
+    });
+};
+/**
+ * The receipt the engine journals a transaction's commit with. The driver
+ * numbers a transaction when it sends the transaction's first command.
+ */
+const receiptOfSession = (rawSessionArg) => {
+    const id = rawSessionArg.id;
+    if (id === undefined) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'A SmartData transaction has no server session to key its write-log entry by.');
+    }
+    return `${id.id.toUUID().toHexString()}:${rawSessionArg.serverSession.txnNumber}`;
+};
+const receiptOfJournal = (sessionArg, transactionArg) => `${sessionArg}:${transactionArg}`;
+/**
+ * The entry as written: a collection whose writes cannot be placed changed as
+ * a whole, so its reports add nothing, and the largest collections become
+ * unplaced until the entry fits its bounds.
+ */
+const boundWriteLogEntry = (reportsArg, unplacedArg) => {
+    const unplaced = new Set(unplacedArg);
+    const sizes = new Map();
+    let documents = 0;
+    let bytes = plugins.mongodb.BSON.calculateObjectSize({ unplaced: [...unplaced] });
+    for (const report of reportsArg) {
+        if (unplaced.has(report.collection))
+            continue;
+        const size = sizes.get(report.collection) ?? { documents: 0, bytes: 0 };
+        const reportDocuments = report.documents?.length ?? 0;
+        const reportBytes = plugins.mongodb.BSON.calculateObjectSize(report);
+        size.documents += reportDocuments;
+        size.bytes += reportBytes;
+        documents += reportDocuments;
+        bytes += reportBytes;
+        sizes.set(report.collection, size);
+    }
+    const bySize = [...sizes].sort(([, aArg], [, bArg]) => bArg.bytes - aArg.bytes);
+    for (const [collection, size] of bySize) {
+        if (documents <= maximumEntryDocuments && bytes <= maximumEntryBytes)
+            break;
+        unplaced.add(collection);
+        documents -= size.documents;
+        bytes -= size.bytes;
+    }
+    return Object.freeze({
+        reports: Object.freeze(reportsArg.filter((reportArg) => !unplaced.has(reportArg.collection))),
+        unplaced: Object.freeze([...unplaced].sort()),
+    });
+};
+/**
+ * @internal Writes a transaction's entry inside that transaction, right
+ * before its commit, and registers it until its outcome settled. `undefined`
+ * when the transaction wrote nothing through the models.
+ */
+export const flushSmartdataWriteLog = async (dbArg, mongoDbArg, rawSessionArg, reportsArg, unplacedArg, signalArg) => {
+    const fields = logFields.get(dbArg);
+    if (fields === undefined || (reportsArg.length === 0 && unplacedArg.size === 0))
+        return undefined;
+    const collection = logCollection(mongoDbArg);
+    const signalOptions = signalArg === undefined ? {} : { signal: signalArg };
+    if (reportsArg.length === 0) {
+        // No write of the attempt was acknowledged, so none may have numbered the transaction yet.
+        await collection.findOne({ _id: '' }, { projection: { _id: 1 }, session: rawSessionArg, ...signalOptions });
+    }
+    const receipt = receiptOfSession(rawSessionArg);
+    const entry = boundWriteLogEntry(reportsArg, unplacedArg);
+    await collection.insertOne({
+        _id: receipt,
+        at: new Date(),
+        fields: [...fields],
+        reports: [...entry.reports],
+        unplaced: [...entry.unplaced],
+    }, { session: rawSessionArg, ...signalOptions });
+    const { pending } = stateOf(dbArg);
+    const settled = Promise.withResolvers();
+    pending.set(receipt, settled.promise);
+    let open = true;
+    return {
+        receipt,
+        entry,
+        settle: () => {
+            if (!open)
+                return;
+            open = false;
+            if (pending.get(receipt) === settled.promise)
+                pending.delete(receipt);
+            settled.resolve();
+        },
+    };
+};
+/**
+ * @internal Delivers a confirmed commit of this database instance to its
+ * followers at once; each then skips the commit when the journal lists it.
+ */
+export const deliverSmartdataWriteLogCommit = (dbArg, commitArg) => {
+    const followers = logStates.get(dbArg)?.followers;
+    if (!followers)
+        return;
+    for (const follower of [...followers]) {
+        follower.deliverLocal(commitArg);
+    }
+};
+const isPlainRecord = (valueArg) => {
+    if (typeof valueArg !== 'object' || valueArg === null || Array.isArray(valueArg))
+        return false;
+    const prototype = Object.getPrototypeOf(valueArg);
+    return prototype === Object.prototype || prototype === null;
+};
+const unexpectedPage = () => new SmartdataPersistenceError('unsupported_operation', 'The engine answered getCommittedWrites with an unexpected page.');
+const unsignedDecimal = /^(?:0|[1-9][0-9]*)$/;
+const stampOf = (valueArg) => {
+    if (!isPlainRecord(valueArg)
+        || typeof valueArg.timeline !== 'string'
+        || typeof valueArg.sequence !== 'string'
+        || !unsignedDecimal.test(valueArg.sequence)) {
+        throw unexpectedPage();
+    }
+    return Object.freeze({ timeline: valueArg.timeline, sequence: valueArg.sequence });
+};
+const committedWriteOf = (valueArg, databaseArg) => {
+    if (!isPlainRecord(valueArg) || !Array.isArray(valueArg.namespaces) || typeof valueArg.committedAtMs !== 'number') {
+        throw unexpectedPage();
+    }
+    const collections = new Set();
+    let logged = false;
+    for (const namespace of valueArg.namespaces) {
+        if (!isPlainRecord(namespace) || typeof namespace.database !== 'string' || typeof namespace.collection !== 'string') {
+            throw unexpectedPage();
+        }
+        if (namespace.database !== databaseArg)
+            continue;
+        if (namespace.collection === writeLogCollectionName)
+            logged = true;
+        if (!bookkeepingCollections.has(namespace.collection))
+            collections.add(namespace.collection);
+    }
+    const receipt = valueArg.receipt;
+    if (receipt !== null && receipt !== undefined && (!isPlainRecord(receipt) || typeof receipt.session !== 'string' || typeof receipt.transaction !== 'string')) {
+        throw unexpectedPage();
+    }
+    return {
+        stamp: stampOf(valueArg.stamp),
+        committedAtMs: valueArg.committedAtMs,
+        collections: [...collections].sort(),
+        // A retryable statement outside a transaction carries its number; only a
+        // transaction can have written an entry.
+        receipt: isPlainRecord(receipt) && (receipt.statement === null || receipt.statement === undefined)
+            ? receiptOfJournal(receipt.session, receipt.transaction)
+            : undefined,
+        logged,
+    };
+};
+/** One page of the database's commit journal after `afterArg`, or its head without `afterArg`. */
+const readCommittedWrites = async (mongoDbArg, afterArg, signalArg) => {
+    const page = await mongoDbArg.command({
+        getCommittedWrites: 1,
+        ...(afterArg === undefined ? {} : { after: { timeline: afterArg.timeline, sequence: afterArg.sequence } }),
+        limit: pageLimit,
+        maximumBytes: pageBytes,
+    }, { timeoutMS: readTimeoutMs, ...(signalArg === undefined ? {} : { signal: signalArg }) });
+    if (!Array.isArray(page.writes) || typeof page.gap !== 'boolean' || typeof page.hasMore !== 'boolean') {
+        throw unexpectedPage();
+    }
+    return {
+        writes: page.writes.map((writeArg) => committedWriteOf(writeArg, mongoDbArg.databaseName)),
+        cursor: stampOf(page.cursor),
+        head: stampOf(page.head),
+        gap: page.gap,
+        hasMore: page.hasMore,
+    };
+};
+/**
+ * The entry a stored document states for a follower of `fieldsArg`, or
+ * `undefined` when it states none: a document another version wrote or one
+ * that does not record every field followed.
+ */
+const entryOfDocument = (documentArg, fieldsArg) => {
+    if (!isPlainRecord(documentArg))
+        return undefined;
+    const { fields, reports, unplaced } = documentArg;
+    if (!Array.isArray(fields)
+        || !fieldsArg.every((fieldArg) => fields.includes(fieldArg))
+        || !Array.isArray(unplaced)
+        || !unplaced.every((collectionArg) => typeof collectionArg === 'string')
+        || !Array.isArray(reports)
+        || !reports.every((reportArg) => isPlainRecord(reportArg)
+            && typeof reportArg.collection === 'string'
+            && writeKinds.has(reportArg.kind)
+            && isPlainRecord(reportArg.anchors)
+            && (reportArg.documents === null
+                || (Array.isArray(reportArg.documents) && reportArg.documents.every(isPlainRecord))))) {
+        return undefined;
+    }
+    return { reports: reports, unplaced: unplaced };
+};
+const describeError = (errorArg) => errorArg instanceof Error ? errorArg.message : String(errorArg);
+/** Resolves after `millisecondsArg`, or at once when `signalArg` aborts. */
+const pause = (millisecondsArg, signalArg) => new Promise((resolveArg) => {
+    if (signalArg.aborted)
+        return resolveArg();
+    const done = () => {
+        clearTimeout(timer);
+        signalArg.removeEventListener('abort', done);
+        resolveArg();
+    };
+    const timer = setTimeout(done, millisecondsArg);
+    signalArg.addEventListener('abort', done, { once: true });
+});
+/** Resolves when `promiseArg` settles, or at once when `signalArg` aborts. */
+const settledOrAborted = (promiseArg, signalArg) => new Promise((resolveArg) => {
+    if (signalArg.aborted)
+        return resolveArg();
+    const done = () => {
+        signalArg.removeEventListener('abort', done);
+        resolveArg();
+    };
+    signalArg.addEventListener('abort', done, { once: true });
+    void promiseArg.finally(done);
+});
+class SmartdataWriteFollower {
+    state;
+    fields;
+    onWrite;
+    onGap;
+    /** The receipts of local deliveries, by when they were delivered, until the journal lists them. */
+    delivered = new Map();
+    controller = new AbortController();
+    running = Promise.resolve();
+    stopping;
+    constructor(state, fields, onWrite, onGap) {
+        this.state = state;
+        this.fields = fields;
+        this.onWrite = onWrite;
+        this.onGap = onGap;
+    }
+    start(mongoDbArg, cursorArg) {
+        this.state.followers.add(this);
+        this.running = this.follow(mongoDbArg, cursorArg);
+    }
+    stop() {
+        this.stopping ??= (async () => {
+            this.state.followers.delete(this);
+            this.controller.abort();
+            await this.running;
+        })();
+        return this.stopping;
+    }
+    deliverLocal(commitArg) {
+        if (this.controller.signal.aborted)
+            return;
+        this.delivered.set(commitArg.receipt, Date.now());
+        this.deliver('local', null, null, commitArg.entry.reports, commitArg.entry.unplaced);
+    }
+    deliver(originArg, stampArg, committedAtMsArg, reportsArg, unplacedArg) {
+        const write = Object.freeze({
+            origin: originArg,
+            stamp: stampArg,
+            committedAtMs: committedAtMsArg,
+            reports: Object.freeze(reportsArg.map((reportArg) => narrowSmartdataWriteReport(reportArg, this.fields))),
+            unplaced: Object.freeze([...unplacedArg]),
+        });
+        try {
+            this.onWrite(write);
+        }
+        catch (errorArg) {
+            logger.log('error', `A SmartData write follower threw on a commit: ${describeError(errorArg)}`);
+        }
+    }
+    reportGap(reasonArg) {
+        try {
+            this.onGap(Object.freeze({ reason: reasonArg }));
+        }
+        catch (errorArg) {
+            logger.log('error', `A SmartData write follower threw on a gap: ${describeError(errorArg)}`);
+        }
+    }
+    /**
+     * Reads the journal from `cursorArg` on until stopped. A failed read is
+     * retried from the same position; a position the journal lost reports a gap
+     * and continues from its head.
+     */
+    async follow(mongoDbArg, cursorArg) {
+        const signal = this.controller.signal;
+        let cursor = cursorArg;
+        let lastCommitAt = Number.NEGATIVE_INFINITY;
+        let failing = false;
+        while (!signal.aborted) {
+            try {
+                let page;
+                do {
+                    page = await readCommittedWrites(mongoDbArg, cursor, signal);
+                    if (page.gap) {
+                        // A position beyond the head belongs to a history the journal no longer continues.
+                        const reason = page.head.timeline !== cursor.timeline
+                            || BigInt(cursor.sequence) > BigInt(page.head.sequence) ? 'timeline' : 'retention';
+                        cursor = (await readCommittedWrites(mongoDbArg, undefined, signal)).cursor;
+                        this.reportGap(reason);
+                        break;
+                    }
+                    const committed = await this.deliverPage(mongoDbArg, page.writes, signal);
+                    if (signal.aborted)
+                        return;
+                    if (committed)
+                        lastCommitAt = performance.now();
+                    cursor = page.cursor;
+                } while (page.hasMore && !signal.aborted);
+                if (failing) {
+                    failing = false;
+                    logger.log('info', `A SmartData write follower of "${mongoDbArg.databaseName}" reads the commit journal again.`);
+                }
+            }
+            catch (errorArg) {
+                if (signal.aborted)
+                    return;
+                if (!failing) {
+                    failing = true;
+                    logger.log('warn', `A SmartData write follower of "${mongoDbArg.databaseName}" failed to read the commit journal and retries: ${describeError(errorArg)}`);
+                }
+            }
+            this.forgetOldDeliveries();
+            await pause(performance.now() - lastCommitAt < activeWindowMs ? activePollMs : idlePollMs, signal);
+        }
+    }
+    /**
+     * Delivers one page's commits in order and returns whether it held any.
+     * A commit of this database instance still settling is waited for, so the
+     * follower knows whether it was delivered locally. Every read happens before
+     * the first delivery, so a failed read delivers nothing and is retried with
+     * the page.
+     */
+    async deliverPage(mongoDbArg, writesArg, signalArg) {
+        const writes = writesArg.filter((writeArg) => writeArg.collections.length > 0 || (writeArg.logged && writeArg.receipt !== undefined));
+        if (writes.length === 0)
+            return false;
+        const receipts = writes.flatMap((writeArg) => writeArg.receipt === undefined ? [] : [writeArg.receipt]);
+        for (const receipt of receipts) {
+            const pending = this.state.pending.get(receipt);
+            if (pending)
+                await settledOrAborted(pending, signalArg);
+        }
+        if (signalArg.aborted)
+            return true;
+        const lookups = receipts.filter((receiptArg) => !this.delivered.has(receiptArg));
+        const documents = new Map();
+        if (lookups.length > 0) {
+            const found = await logCollection(mongoDbArg).find({ _id: { $in: lookups } }, { projection: { at: 0 }, timeoutMS: readTimeoutMs, signal: signalArg }).toArray();
+            for (const document of found)
+                documents.set(document._id, document);
+        }
+        for (const write of writes) {
+            if (signalArg.aborted)
+                return true;
+            if (write.receipt !== undefined && this.delivered.delete(write.receipt))
+                continue;
+            const entry = write.receipt === undefined
+                ? undefined
+                : entryOfDocument(documents.get(write.receipt), this.fields);
+            const unplaced = new Set(entry?.unplaced);
+            const covered = new Set([...unplaced, ...(entry?.reports ?? []).map((reportArg) => reportArg.collection)]);
+            for (const collection of write.collections) {
+                if (!covered.has(collection))
+                    unplaced.add(collection);
+            }
+            this.deliver('journal', write.stamp, write.committedAtMs, entry?.reports ?? [], [...unplaced].sort());
+        }
+        return true;
+    }
+    forgetOldDeliveries() {
+        const oldest = Date.now() - localDeliveryMemoryMs;
+        for (const [receipt, deliveredAt] of this.delivered) {
+            if (deliveredAt < oldest)
+                this.delivered.delete(receipt);
+        }
+    }
+}
+/**
+ * @internal Starts a follower at the journal's head; `db.followWrites()`
+ * documents it.
+ */
+export const followSmartdataWrites = async (dbArg, optionsArg) => {
+    const { fields, onWrite, onGap } = assertDataOptions(optionsArg, ['fields', 'onWrite', 'onGap']);
+    const followed = normalizeObservedFields(fields, 'A SmartData write follower');
+    if (typeof onWrite !== 'function' || typeof onGap !== 'function') {
+        throw new SmartdataPersistenceError('invalid_argument', 'A SmartData write follower requires onWrite and onGap functions.');
+    }
+    const logged = logFields.get(dbArg);
+    if (logged === undefined) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Following writes requires the writeLog option of the SmartdataDb.');
+    }
+    if (!followed.every((fieldArg) => logged.includes(fieldArg))) {
+        throw new SmartdataPersistenceError('invalid_argument', 'A SmartData write follower follows fields of the write log only.');
+    }
+    const mongoDb = dbArg.mongoDb;
+    if (dbArg.status !== 'connected' || !mongoDb) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Following writes requires a connected SmartdataDb.');
+    }
+    if (!isSmartdataWriteLogActive(dbArg)) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Following writes requires NoSQLDB 10.9.0 or newer, whose commit journal orders the commits.');
+    }
+    const tail = await readCommittedWrites(mongoDb, undefined);
+    if (dbArg.status !== 'connected' || dbArg.mongoDb !== mongoDb) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'The SmartdataDb closed while the write follower started.');
+    }
+    const follower = new SmartdataWriteFollower(stateOf(dbArg), followed, onWrite, onGap);
+    follower.start(mongoDb, tail.cursor);
+    return Object.freeze({ stop: () => follower.stop() });
+};
+/** @internal Stops every follower of the database; `close()` calls it. */
+export const stopSmartdataWriteFollowers = async (dbArg) => {
+    const followers = logStates.get(dbArg)?.followers;
+    if (!followers)
+        return;
+    await Promise.all([...followers].map((followerArg) => followerArg.stop()));
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.writelog.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.writelog.ts"],"names":[],"mappings":"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"}

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

@@ -59,10 +59,23 @@ export interface ISmartdataWrite {
      */
     previousPartitionsRead?: true;
 }
+/**
+ * @internal Validates the top-level field names a report carries: 1 to 64
+ * distinct names, no `.` and no leading `$`. `subjectArg` names what requires
+ * them in the refusal.
+ */
+export declare const normalizeObservedFields: (fieldsArg: unknown, subjectArg: string) => readonly string[];
 /** @internal Registers a write observer; the returned function removes it. */
 export declare const addSmartdataWriteObserver: (dbArg: SmartdataDb, optionsArg: ISmartdataWriteObserverOptions) => (() => void);
 /** @internal */
 export declare const hasSmartdataWriteObservers: (dbArg: SmartdataDb) => boolean;
+/**
+ * @internal The report of one acknowledged write with the values of `fieldsArg`,
+ * copied now and frozen.
+ */
+export declare const reportOfSmartdataWrite: (writeArg: ISmartdataWrite, fieldsArg: readonly string[]) => ISmartdataWriteReport;
+/** @internal The same report with only the values of `fieldsArg`, which the report's fields include. */
+export declare const narrowSmartdataWriteReport: (reportArg: ISmartdataWriteReport, fieldsArg: readonly string[]) => ISmartdataWriteReport;
 /**
  * @internal Captures one acknowledged write for the observers registered now,
  * and returns the delivery, or `undefined` when nobody observes the database.