@modelprofile.com/flexharness 9.10.0 → 10.1.0

package/dist_ts_stores_nosqldb/classes.nosqldbstores.js

@@ -0,0 +1,312 @@
+import * as plugins from './plugins.js';
+import { FlexHarnessStoreConflictError, FlexHarnessValidationError } from '../dist_ts/errors.js';
+import { assertFlexPermissionSnapshot, assertFlexProjectionSnapshot, assertFlexScopeSnapshot, } from '../dist_ts/utils.json.js';
+import { assertFlexProjectManagementRecord, assertFlexProjectManagementSnapshot, assertFlexProjectManagementTombstone, } from '../dist_ts/utils.projectmanagement.js';
+import { createAgentEventSnapshot, createToolJobSnapshot, normalizeJsonObjectUndefined, validateAgentEventArchive, validateAgentEventSnapshot, validateToolJobSnapshot, } from '../dist_ts/utils.storecodecs.js';
+import { assertProjectionSession, assertProjectManagementSaveAdmitted, assertSameArchiveEvents, isProjectManagementTombstoneAdmitted, providerKey, validateExpectedRevision, validateIdentifier, validateProjectManagementWriteContext, validateSnapshotSave, } from '../dist_ts/utils.storerules.js';
+import { FlexRecordStore } from './classes.recordstore.js';
+function revisionWrite(current, snapshot, expectedRevision, conflict) {
+    const actualRevision = current?.revision ?? 0;
+    if (actualRevision !== expectedRevision)
+        throw conflict(actualRevision);
+    return { revision: snapshot.revision, value: snapshot };
+}
+function validateScope(value) {
+    assertFlexScopeSnapshot(value);
+    return value;
+}
+function validatePermission(value) {
+    assertFlexPermissionSnapshot(value);
+    return value;
+}
+function validateProjectManagement(value) {
+    assertFlexProjectManagementRecord(value);
+    return value;
+}
+class NoSqlScopeStore {
+    records;
+    constructor(records) {
+        this.records = records;
+    }
+    load(storageKey) {
+        validateIdentifier(storageKey, 'storageKey');
+        return this.records.read({ domain: 'scope', storageKey }, validateScope);
+    }
+    async save(storageKey, snapshot, expectedRevision) {
+        validateIdentifier(storageKey, 'storageKey');
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexScopeSnapshot);
+        const conflict = (actualRevision) => new FlexHarnessStoreConflictError(storageKey, expectedRevision, actualRevision);
+        await this.records.mutate({ domain: 'scope', storageKey }, {
+            validate: validateScope,
+            decide: (current) => revisionWrite(current, validated, expectedRevision, conflict),
+            contention: conflict,
+        });
+    }
+}
+class NoSqlProjectionStore {
+    records;
+    constructor(records) {
+        this.records = records;
+    }
+    validator(sessionId) {
+        return (value) => {
+            assertFlexProjectionSnapshot(value);
+            assertProjectionSession(value, sessionId);
+            return value;
+        };
+    }
+    load(storageKey, sessionId) {
+        providerKey(storageKey, sessionId);
+        return this.records.read({ domain: 'projection', storageKey, sessionId }, this.validator(sessionId));
+    }
+    async save(storageKey, sessionId, snapshot, expectedRevision) {
+        const key = providerKey(storageKey, sessionId);
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexProjectionSnapshot);
+        assertProjectionSession(validated, sessionId);
+        const conflict = (actualRevision) => new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+        await this.records.mutate({ domain: 'projection', storageKey, sessionId }, {
+            validate: this.validator(sessionId),
+            decide: (current) => revisionWrite(current, validated, expectedRevision, conflict),
+            contention: conflict,
+        });
+    }
+    deleteSession(storageKey, sessionId) {
+        providerKey(storageKey, sessionId);
+        return this.records.deleteOwner(storageKey, sessionId, ['projection']);
+    }
+}
+class NoSqlPermissionStore {
+    records;
+    constructor(records) {
+        this.records = records;
+    }
+    load(storageKey, sessionId) {
+        providerKey(storageKey, sessionId);
+        return this.records.read({ domain: 'permission', storageKey, sessionId }, validatePermission);
+    }
+    async save(storageKey, sessionId, snapshot, expectedRevision) {
+        const key = providerKey(storageKey, sessionId);
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexPermissionSnapshot);
+        const conflict = (actualRevision) => new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+        await this.records.mutate({ domain: 'permission', storageKey, sessionId }, {
+            validate: validatePermission,
+            decide: (current) => revisionWrite(current, validated, expectedRevision, conflict),
+            contention: conflict,
+        });
+    }
+    deleteSession(storageKey, sessionId) {
+        providerKey(storageKey, sessionId);
+        return this.records.deleteOwner(storageKey, sessionId, ['permission']);
+    }
+}
+class NoSqlProjectManagementStore {
+    records;
+    constructor(records) {
+        this.records = records;
+    }
+    load(storageKey, sessionId) {
+        providerKey(storageKey, sessionId);
+        return this.records.read({ domain: 'projectManagement', storageKey, sessionId }, validateProjectManagement);
+    }
+    async save(storageKey, sessionId, snapshot, expectedRevision, writeContext) {
+        const key = providerKey(storageKey, sessionId);
+        validateProjectManagementWriteContext(writeContext);
+        const validated = validateSnapshotSave(snapshot, expectedRevision, assertFlexProjectManagementSnapshot);
+        await this.records.mutate({ domain: 'projectManagement', storageKey, sessionId }, {
+            validate: validateProjectManagement,
+            decide: (current) => {
+                assertProjectManagementSaveAdmitted(key, current, validated, expectedRevision);
+                return { revision: validated.revision, value: validated };
+            },
+            contention: (actualRevision) => new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision),
+        });
+    }
+    async tombstoneSession(storageKey, sessionId, tombstone, expectedRevision) {
+        const key = providerKey(storageKey, sessionId);
+        const validated = validateSnapshotSave(tombstone, expectedRevision, assertFlexProjectManagementTombstone);
+        await this.records.mutate({ domain: 'projectManagement', storageKey, sessionId }, {
+            validate: validateProjectManagement,
+            decide: (current) => (isProjectManagementTombstoneAdmitted(key, current, validated, expectedRevision)
+                ? { revision: validated.revision, value: validated }
+                : undefined),
+            contention: (actualRevision) => new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision),
+        });
+    }
+    purgeNamespace(storageKey) {
+        validateIdentifier(storageKey, 'storageKey');
+        return this.records.purgeNamespace(storageKey, 'projectManagement');
+    }
+}
+class NoSqlAgentEventStore {
+    records;
+    storageKey;
+    sessionId;
+    eventSchemaVersion = 2;
+    constructor(records, storageKey, sessionId) {
+        this.records = records;
+        this.storageKey = storageKey;
+        this.sessionId = sessionId;
+    }
+    assertSession(sessionId) {
+        if (sessionId !== this.sessionId) {
+            throw new FlexHarnessValidationError(`Agent event store is bound to session "${this.sessionId}", not "${sessionId}".`);
+        }
+    }
+    validateSnapshot = (value) => validateAgentEventSnapshot(value, this.sessionId);
+    load(sessionId) {
+        this.assertSession(sessionId);
+        return this.records.read({ domain: 'agentEvents', storageKey: this.storageKey, sessionId }, this.validateSnapshot);
+    }
+    async save(sessionId, events, expectedRevision) {
+        this.assertSession(sessionId);
+        validateExpectedRevision(expectedRevision);
+        const snapshot = createAgentEventSnapshot(sessionId, events, expectedRevision + 1);
+        validateAgentEventSnapshot(snapshot, sessionId);
+        const conflict = (actualRevision) => new plugins.AgentEventStoreConflictError(sessionId, expectedRevision, actualRevision);
+        await this.records.mutate({ domain: 'agentEvents', storageKey: this.storageKey, sessionId }, {
+            validate: this.validateSnapshot,
+            decide: (current) => revisionWrite(current, snapshot, expectedRevision, conflict),
+            contention: conflict,
+        });
+        return snapshot.revision;
+    }
+    async archive(archive) {
+        this.assertSession(archive.sessionId);
+        const normalized = normalizeJsonObjectUndefined(archive, '$archive');
+        const validated = validateAgentEventArchive(normalized, this.sessionId, archive.archiveId);
+        const address = {
+            domain: 'agentEventArchive',
+            storageKey: this.storageKey,
+            sessionId: this.sessionId,
+            archiveId: archive.archiveId,
+        };
+        await this.records.mutate(address, {
+            validate: (value) => validateAgentEventArchive(value, this.sessionId, archive.archiveId),
+            decide: (current) => {
+                if (!current)
+                    return { revision: 0, value: validated };
+                assertSameArchiveEvents(current, validated);
+                return undefined;
+            },
+            contention: () => new Error(`Archive "${archive.archiveId}" is contended by concurrent writers.`),
+        });
+    }
+    loadArchive(sessionId, archiveId) {
+        this.assertSession(sessionId);
+        validateIdentifier(archiveId, 'archiveId');
+        return this.records.read({ domain: 'agentEventArchive', storageKey: this.storageKey, sessionId, archiveId }, (value) => validateAgentEventArchive(value, this.sessionId, archiveId));
+    }
+}
+class NoSqlAgentEventStoreProvider {
+    records;
+    stores = new Map();
+    constructor(records) {
+        this.records = records;
+    }
+    getStore(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        let store = this.stores.get(key);
+        if (!store) {
+            store = new NoSqlAgentEventStore(this.records, storageKey, sessionId);
+            this.stores.set(key, store);
+        }
+        return store;
+    }
+    releaseSession(storageKey, sessionId) {
+        this.stores.delete(providerKey(storageKey, sessionId));
+    }
+    async deleteSession(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        await this.records.deleteOwner(storageKey, sessionId, ['agentEvents', 'agentEventArchive']);
+        this.stores.delete(key);
+    }
+}
+class NoSqlToolJobStore {
+    records;
+    storageKey;
+    sessionId;
+    constructor(records, storageKey, sessionId) {
+        this.records = records;
+        this.storageKey = storageKey;
+        this.sessionId = sessionId;
+    }
+    async load(abortSignal) {
+        abortSignal?.throwIfAborted();
+        const snapshot = await this.records.read({ domain: 'jobs', storageKey: this.storageKey, sessionId: this.sessionId }, validateToolJobSnapshot);
+        abortSignal?.throwIfAborted();
+        return snapshot;
+    }
+    async save(jobs, expectedRevision, abortSignal) {
+        abortSignal?.throwIfAborted();
+        validateExpectedRevision(expectedRevision);
+        const snapshot = createToolJobSnapshot(jobs, expectedRevision + 1);
+        const conflict = (actualRevision) => new plugins.ToolJobStoreConflictError(expectedRevision, actualRevision);
+        await this.records.mutate({ domain: 'jobs', storageKey: this.storageKey, sessionId: this.sessionId }, {
+            validate: validateToolJobSnapshot,
+            decide: (current) => {
+                abortSignal?.throwIfAborted();
+                return revisionWrite(current, snapshot, expectedRevision, conflict);
+            },
+            contention: conflict,
+        });
+        return snapshot.revision;
+    }
+}
+class NoSqlToolJobStoreProvider {
+    records;
+    stores = new Map();
+    constructor(records) {
+        this.records = records;
+    }
+    getStore(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        let store = this.stores.get(key);
+        if (!store) {
+            store = new NoSqlToolJobStore(this.records, storageKey, sessionId);
+            this.stores.set(key, store);
+        }
+        return store;
+    }
+    releaseSession(storageKey, sessionId) {
+        this.stores.delete(providerKey(storageKey, sessionId));
+    }
+    async deleteSession(storageKey, sessionId) {
+        const key = providerKey(storageKey, sessionId);
+        await this.records.deleteOwner(storageKey, sessionId, ['jobs']);
+        this.stores.delete(key);
+    }
+}
+/**
+ * Every FlexHarness persistence domain on `@lossless.org/client/nosqldb`, with compare-and-swap
+ * that holds across processes. Records live in `flexharness_records`; payloads longer than one
+ * chunk live in `flexharness_chunks`.
+ */
+export class NoSqlFlexHarnessStores {
+    scopes;
+    projections;
+    permissions;
+    projectManagement;
+    agentEvents;
+    jobs;
+    records;
+    constructor(options) {
+        if (!(options?.db instanceof plugins.SmartdataDb)) {
+            throw new FlexHarnessValidationError('NoSqlFlexHarnessStores requires a SmartdataDb.');
+        }
+        this.records = new FlexRecordStore(options);
+        this.scopes = new NoSqlScopeStore(this.records);
+        this.projections = new NoSqlProjectionStore(this.records);
+        this.permissions = new NoSqlPermissionStore(this.records);
+        this.projectManagement = new NoSqlProjectManagementStore(this.records);
+        this.agentEvents = new NoSqlAgentEventStoreProvider(this.records);
+        this.jobs = new NoSqlToolJobStoreProvider(this.records);
+    }
+    /**
+     * Creates or verifies the two collections and their indexes. Every store operation awaits the
+     * same preparation, so calling it at startup only moves that work, and its failure, forward.
+     */
+    prepare() {
+        return this.records.prepare();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.nosqldbstores.js","sourceRoot":"","sources":["../../ts_stores_nosqldb/classes.nosqldbstores.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,6BAA6B,EAAE,0BAA0B,EAAE,MAAM,iBAAiB,CAAC;AAkB5F,OAAO,EACL,4BAA4B,EAC5B,4BAA4B,EAC5B,uBAAuB,GACxB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACL,iCAAiC,EACjC,mCAAmC,EACnC,oCAAoC,GACrC,MAAM,kCAAkC,CAAC;AAC1C,OAAO,EACL,wBAAwB,EACxB,qBAAqB,EACrB,4BAA4B,EAC5B,yBAAyB,EACzB,0BAA0B,EAC1B,uBAAuB,GACxB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,uBAAuB,EACvB,mCAAmC,EACnC,uBAAuB,EACvB,oCAAoC,EACpC,WAAW,EACX,wBAAwB,EACxB,kBAAkB,EAClB,qCAAqC,EACrC,oBAAoB,GACrB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAE,eAAe,EAAyB,MAAM,0BAA0B,CAAC;AAElF,SAAS,aAAa,CACpB,OAAyC,EACzC,QAAmB,EACnB,gBAAwB,EACxB,QAA2C;IAE3C,MAAM,cAAc,GAAG,OAAO,EAAE,QAAQ,IAAI,CAAC,CAAC;IAC9C,IAAI,cAAc,KAAK,gBAAgB;QAAE,MAAM,QAAQ,CAAC,cAAc,CAAC,CAAC;IACxE,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,QAAQ,EAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;AAC1D,CAAC;AAED,SAAS,aAAa,CAAC,KAAc;IACnC,uBAAuB,CAAC,KAAK,CAAC,CAAC;IAC/B,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,kBAAkB,CAAC,KAAc;IACxC,4BAA4B,CAAC,KAAK,CAAC,CAAC;IACpC,OAAO,KAAK,CAAC;AACf,CAAC;AAED,SAAS,yBAAyB,CAAC,KAAc;IAC/C,iCAAiC,CAAC,KAAK,CAAC,CAAC;IACzC,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAM,eAAe;IACU;IAA7B,YAA6B,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAElD,IAAI,CAAC,UAAkB;QAC5B,kBAAkB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAC7C,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE,aAAa,CAAC,CAAC;IAC3E,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,UAAkB,EAClB,QAA4B,EAC5B,gBAAwB;QAExB,kBAAkB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAC7C,MAAM,SAAS,GAAG,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,uBAAuB,CAAC,CAAC;QAC5F,MAAM,QAAQ,GAAG,CAAC,cAAsB,EAAE,EAAE,CAC1C,IAAI,6BAA6B,CAAC,UAAU,EAAE,gBAAgB,EAAE,cAAc,CAAC,CAAC;QAClF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,UAAU,EAAE,EAAE;YACzD,QAAQ,EAAE,aAAa;YACvB,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,QAAQ,CAAC;YAClF,UAAU,EAAE,QAAQ;SACrB,CAAC,CAAC;IACL,CAAC;CACF;AAED,MAAM,oBAAoB;IACK;IAA7B,YAA6B,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAEjD,SAAS,CAAC,SAAiB;QACjC,OAAO,CAAC,KAAK,EAAE,EAAE;YACf,4BAA4B,CAAC,KAAK,CAAC,CAAC;YACpC,uBAAuB,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;YAC1C,OAAO,KAAK,CAAC;QACf,CAAC,CAAC;IACJ,CAAC;IAEM,IAAI,CAAC,UAAkB,EAAE,SAAiB;QAC/C,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CACtB,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,EAC/C,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC,CAC1B,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,UAAkB,EAClB,SAAiB,EACjB,QAAmC,EACnC,gBAAwB;QAExB,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,MAAM,SAAS,GAAG,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,4BAA4B,CAAC,CAAC;QACjG,uBAAuB,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;QAC9C,MAAM,QAAQ,GAAG,CAAC,cAAsB,EAAE,EAAE,CAC1C,IAAI,6BAA6B,CAAC,GAAG,EAAE,gBAAgB,EAAE,cAAc,CAAC,CAAC;QAC3E,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE;YACzE,QAAQ,EAAE,IAAI,CAAC,SAAS,CAAC,SAAS,CAAC;YACnC,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,QAAQ,CAAC;YAClF,UAAU,EAAE,QAAQ;SACrB,CAAC,CAAC;IACL,CAAC;IAEM,aAAa,CAAC,UAAkB,EAAE,SAAiB;QACxD,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;IACzE,CAAC;CACF;AAED,MAAM,oBAAoB;IACK;IAA7B,YAA6B,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAElD,IAAI,CAAC,UAAkB,EAAE,SAAiB;QAC/C,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE,kBAAkB,CAAC,CAAC;IAChG,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,UAAkB,EAClB,SAAiB,EACjB,QAAiC,EACjC,gBAAwB;QAExB,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,MAAM,SAAS,GAAG,oBAAoB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,4BAA4B,CAAC,CAAC;QACjG,MAAM,QAAQ,GAAG,CAAC,cAAsB,EAAE,EAAE,CAC1C,IAAI,6BAA6B,CAAC,GAAG,EAAE,gBAAgB,EAAE,cAAc,CAAC,CAAC;QAC3E,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE;YACzE,QAAQ,EAAE,kBAAkB;YAC5B,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,QAAQ,CAAC;YAClF,UAAU,EAAE,QAAQ;SACrB,CAAC,CAAC;IACL,CAAC;IAEM,aAAa,CAAC,UAAkB,EAAE,SAAiB;QACxD,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC;IACzE,CAAC;CACF;AAED,MAAM,2BAA2B;IACF;IAA7B,YAA6B,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAElD,IAAI,CACT,UAAkB,EAClB,SAAiB;QAEjB,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QACnC,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CACtB,EAAE,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,SAAS,EAAE,EACtD,yBAAyB,CAC1B,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,UAAkB,EAClB,SAAiB,EACjB,QAAwC,EACxC,gBAAwB,EACxB,YAAgD;QAEhD,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,qCAAqC,CAAC,YAAY,CAAC,CAAC;QACpD,MAAM,SAAS,GAAG,oBAAoB,CACpC,QAAQ,EACR,gBAAgB,EAChB,mCAAmC,CACpC,CAAC;QACF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE;YAChF,QAAQ,EAAE,yBAAyB;YACnC,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;gBAClB,mCAAmC,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,CAAC,CAAC;gBAC/E,OAAO,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;YAC5D,CAAC;YACD,UAAU,EAAE,CAAC,cAAc,EAAE,EAAE,CAC7B,IAAI,6BAA6B,CAAC,GAAG,EAAE,gBAAgB,EAAE,cAAc,CAAC;SAC3E,CAAC,CAAC;IACL,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAC3B,UAAkB,EAClB,SAAiB,EACjB,SAA0C,EAC1C,gBAAwB;QAExB,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,MAAM,SAAS,GAAG,oBAAoB,CACpC,SAAS,EACT,gBAAgB,EAChB,oCAAoC,CACrC,CAAC;QACF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE;YAChF,QAAQ,EAAE,yBAAyB;YACnC,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,CACnB,oCAAoC,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,CAAC;gBAC7E,CAAC,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE;gBACpD,CAAC,CAAC,SAAS,CACd;YACD,UAAU,EAAE,CAAC,cAAc,EAAE,EAAE,CAC7B,IAAI,6BAA6B,CAAC,GAAG,EAAE,gBAAgB,EAAE,cAAc,CAAC;SAC3E,CAAC,CAAC;IACL,CAAC;IAEM,cAAc,CAAC,UAAkB;QACtC,kBAAkB,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAC7C,OAAO,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,UAAU,EAAE,mBAAmB,CAAC,CAAC;IACtE,CAAC;CACF;AAED,MAAM,oBAAoB;IAIL;IACA;IACA;IALH,kBAAkB,GAAG,CAAU,CAAC;IAEhD,YACmB,OAAwB,EACxB,UAAkB,EAClB,SAAiB;QAFjB,YAAO,GAAP,OAAO,CAAiB;QACxB,eAAU,GAAV,UAAU,CAAQ;QAClB,cAAS,GAAT,SAAS,CAAQ;IACjC,CAAC;IAEI,aAAa,CAAC,SAAiB;QACrC,IAAI,SAAS,KAAK,IAAI,CAAC,SAAS,EAAE,CAAC;YACjC,MAAM,IAAI,0BAA0B,CAClC,0CAA0C,IAAI,CAAC,SAAS,WAAW,SAAS,IAAI,CACjF,CAAC;QACJ,CAAC;IACH,CAAC;IAEgB,gBAAgB,GAAG,CAAC,KAAc,EAAiC,EAAE,CACpF,0BAA0B,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;IAE7C,IAAI,CAAC,SAAiB;QAC3B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CACtB,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,EACjE,IAAI,CAAC,gBAAgB,CACtB,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,SAAiB,EACjB,MAAsC,EACtC,gBAAwB;QAExB,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAC9B,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;QAC3C,MAAM,QAAQ,GAAG,wBAAwB,CAAC,SAAS,EAAE,MAAM,EAAE,gBAAgB,GAAG,CAAC,CAAC,CAAC;QACnF,0BAA0B,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;QAChD,MAAM,QAAQ,GAAG,CAAC,cAAsB,EAAE,EAAE,CAC1C,IAAI,OAAO,CAAC,4BAA4B,CAAC,SAAS,EAAE,gBAAgB,EAAE,cAAc,CAAC,CAAC;QACxF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,EAAE;YAC3F,QAAQ,EAAE,IAAI,CAAC,gBAAgB;YAC/B,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,CAAC;YACjF,UAAU,EAAE,QAAQ;SACrB,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC,QAAQ,CAAC;IAC3B,CAAC;IAEM,KAAK,CAAC,OAAO,CAAC,OAAqC;QACxD,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;QACtC,MAAM,UAAU,GAAG,4BAA4B,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;QACrE,MAAM,SAAS,GAAG,yBAAyB,CAAC,UAAU,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;QAC3F,MAAM,OAAO,GAAG;YACd,MAAM,EAAE,mBAA4B;YACpC,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,IAAI,CAAC,SAAS;YACzB,SAAS,EAAE,OAAO,CAAC,SAAS;SAC7B,CAAC;QACF,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE;YACjC,QAAQ,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,yBAAyB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC;YACxF,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;gBAClB,IAAI,CAAC,OAAO;oBAAE,OAAO,EAAE,QAAQ,EAAE,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC;gBACvD,uBAAuB,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;gBAC5C,OAAO,SAAS,CAAC;YACnB,CAAC;YACD,UAAU,EAAE,GAAG,EAAE,CACf,IAAI,KAAK,CAAC,YAAY,OAAO,CAAC,SAAS,uCAAuC,CAAC;SAClF,CAAC,CAAC;IACL,CAAC;IAEM,WAAW,CAChB,SAAiB,EACjB,SAAiB;QAEjB,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;QAC9B,kBAAkB,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC3C,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,CACtB,EAAE,MAAM,EAAE,mBAAmB,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,EAClF,CAAC,KAAK,EAAE,EAAE,CAAC,yBAAyB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,SAAS,CAAC,CACvE,CAAC;IACJ,CAAC;CACF;AAED,MAAM,4BAA4B;IAGH;IAFZ,MAAM,GAAG,IAAI,GAAG,EAAgC,CAAC;IAElE,YAA6B,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAElD,QAAQ,CAAC,UAAkB,EAAE,SAAiB;QACnD,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;YACtE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,cAAc,CAAC,UAAkB,EAAE,SAAiB;QACzD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,UAAkB,EAAE,SAAiB;QAC9D,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC,aAAa,EAAE,mBAAmB,CAAC,CAAC,CAAC;QAC5F,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;CACF;AAED,MAAM,iBAAiB;IAEF;IACA;IACA;IAHnB,YACmB,OAAwB,EACxB,UAAkB,EAClB,SAAiB;QAFjB,YAAO,GAAP,OAAO,CAAiB;QACxB,eAAU,GAAV,UAAU,CAAQ;QAClB,cAAS,GAAT,SAAS,CAAQ;IACjC,CAAC;IAEG,KAAK,CAAC,IAAI,CAAC,WAAyB;QACzC,WAAW,EAAE,cAAc,EAAE,CAAC;QAC9B,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,IAAI,CACtC,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,EAC1E,uBAAuB,CACxB,CAAC;QACF,WAAW,EAAE,cAAc,EAAE,CAAC;QAC9B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,KAAK,CAAC,IAAI,CACf,IAAsC,EACtC,gBAAwB,EACxB,WAAyB;QAEzB,WAAW,EAAE,cAAc,EAAE,CAAC;QAC9B,wBAAwB,CAAC,gBAAgB,CAAC,CAAC;QAC3C,MAAM,QAAQ,GAAG,qBAAqB,CAAC,IAAI,EAAE,gBAAgB,GAAG,CAAC,CAAC,CAAC;QACnE,MAAM,QAAQ,GAAG,CAAC,cAAsB,EAAE,EAAE,CAC1C,IAAI,OAAO,CAAC,yBAAyB,CAAC,gBAAgB,EAAE,cAAc,CAAC,CAAC;QAC1E,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CACvB,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,EAC1E;YACE,QAAQ,EAAE,uBAAuB;YACjC,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE;gBAClB,WAAW,EAAE,cAAc,EAAE,CAAC;gBAC9B,OAAO,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,QAAQ,CAAC,CAAC;YACtE,CAAC;YACD,UAAU,EAAE,QAAQ;SACrB,CACF,CAAC;QACF,OAAO,QAAQ,CAAC,QAAQ,CAAC;IAC3B,CAAC;CACF;AAED,MAAM,yBAAyB;IAGA;IAFZ,MAAM,GAAG,IAAI,GAAG,EAA6B,CAAC;IAE/D,YAA6B,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAG,CAAC;IAElD,QAAQ,CAAC,UAAkB,EAAE,SAAiB;QACnD,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,IAAI,KAAK,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,KAAK,GAAG,IAAI,iBAAiB,CAAC,IAAI,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,CAAC,CAAC;YACnE,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;QAC9B,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,cAAc,CAAC,UAAkB,EAAE,SAAiB;QACzD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC,CAAC;IACzD,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,UAAkB,EAAE,SAAiB;QAC9D,MAAM,GAAG,GAAG,WAAW,CAAC,UAAU,EAAE,SAAS,CAAC,CAAC;QAC/C,MAAM,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,UAAU,EAAE,SAAS,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;CACF;AAYD;;;;GAIG;AACH,MAAM,OAAO,sBAAsB;IACjB,MAAM,CAAkB;IACxB,WAAW,CAAuB;IAClC,WAAW,CAAuB;IAClC,iBAAiB,CAA8B;IAC/C,WAAW,CAA+B;IAC1C,IAAI,CAA4B;IAC/B,OAAO,CAAkB;IAE1C,YAAY,OAAuC;QACjD,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,YAAY,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,0BAA0B,CAAC,gDAAgD,CAAC,CAAC;QACzF,CAAC;QACD,IAAI,CAAC,OAAO,GAAG,IAAI,eAAe,CAAC,OAAO,CAAC,CAAC;QAC5C,IAAI,CAAC,MAAM,GAAG,IAAI,eAAe,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAChD,IAAI,CAAC,WAAW,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1D,IAAI,CAAC,WAAW,GAAG,IAAI,oBAAoB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAC1D,IAAI,CAAC,iBAAiB,GAAG,IAAI,2BAA2B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACvE,IAAI,CAAC,WAAW,GAAG,IAAI,4BAA4B,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QAClE,IAAI,CAAC,IAAI,GAAG,IAAI,yBAAyB,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IAC1D,CAAC;IAED;;;OAGG;IACI,OAAO;QACZ,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;IAChC,CAAC;CACF"}

package/dist_ts_stores_nosqldb/classes.recordstore.d.ts

@@ -0,0 +1,110 @@
+import * as plugins from './plugins.js';
+export type TFlexRecordDomain = 'scope' | 'projection' | 'permission' | 'projectManagement' | 'agentEvents' | 'agentEventArchive' | 'jobs';
+/** Names one record: a domain snapshot of a storage key, a session or an archive. */
+export interface IFlexRecordAddress {
+    domain: TFlexRecordDomain;
+    storageKey: string;
+    sessionId?: string;
+    archiveId?: string;
+}
+/** The next stored value a mutation decided on. */
+export interface IFlexRecordWrite {
+    revision: number;
+    value: unknown;
+}
+export interface IFlexRecordMutation<TValue> {
+    validate: (value: unknown) => TValue;
+    /** Decides on the stored value: the next value, nothing to write, or a thrown rejection. */
+    decide: (current: TValue | undefined) => IFlexRecordWrite | undefined;
+    /** The conflict to report when concurrent writers keep winning the compare-and-swap. */
+    contention: (actualRevision: number) => Error;
+}
+export declare const FLEX_RECORD_COLLECTION = "flexharness_records";
+export declare const FLEX_CHUNK_COLLECTION = "flexharness_chunks";
+/**
+ * UTF-16 code units a record holds inline, and the size of each chunk of a longer payload. A
+ * chunk stays below 3 MiB of UTF-8, far under the 16 MiB document limit NoSQLDB and MongoDB
+ * enforce, so a record and each of its chunks always fit one document.
+ */
+export declare const FLEX_RECORD_CHUNK_CODE_UNITS: number;
+/**
+ * The head of one record. A payload up to one chunk is stored inline; a longer one lives in
+ * immutable chunks named by `blobId`. `writeToken` changes on every committed write and is the
+ * compare-and-swap fence. A head without payload or blob is a placeholder that reserves the
+ * record for a chunked first write; it reads as absent.
+ */
+export declare class FlexRecordDocument extends plugins.SmartDataDbDoc<FlexRecordDocument, FlexRecordDocument> {
+    recordId: string;
+    domain: TFlexRecordDomain;
+    ownerKey: string;
+    namespaceKey: string;
+    revision: number;
+    writeToken: string;
+    payload: string | null;
+    blobId: string | null;
+    chunkCount: number;
+    payloadSha256: string | null;
+    /** Set before the first chunk of this record is written; the record's writes then sweep. */
+    chunked: boolean;
+    sweepCount: number;
+}
+/** One immutable piece of a chunked payload, written against the head token it will replace. */
+export declare class FlexChunkDocument extends plugins.SmartDataDbDoc<FlexChunkDocument, FlexChunkDocument> {
+    chunkId: string;
+    recordId: string;
+    domain: TFlexRecordDomain;
+    ownerKey: string;
+    namespaceKey: string;
+    blobId: string;
+    baseToken: string;
+    index: number;
+    data: string;
+}
+export interface IFlexRecordStoreOptions {
+    db: plugins.SmartdataDb;
+    operationTimeoutMs?: number;
+}
+/**
+ * Compare-and-swap records on `@lossless.org/client/nosqldb`. A write reads the head, decides,
+ * writes any chunks, and swaps the head only while its `writeToken` is unchanged. Chunks of a
+ * replaced or abandoned payload are swept in a transaction that also touches the head, so a
+ * concurrent deletion or writer can never lose chunks its head references.
+ */
+export declare class FlexRecordStore {
+    private readonly db;
+    private readonly timeoutMs;
+    private readonly records;
+    private readonly chunks;
+    private preparation?;
+    constructor(options: IFlexRecordStoreOptions);
+    /** Creates or verifies both collections and their indexes once; a failed attempt is retried. */
+    prepare(): Promise<void>;
+    private prepareCollections;
+    private resolve;
+    read<TValue>(address: IFlexRecordAddress, validate: (value: unknown) => TValue): Promise<TValue | undefined>;
+    mutate<TValue>(address: IFlexRecordAddress, mutation: IFlexRecordMutation<TValue>): Promise<void>;
+    /** Deletes every record and chunk one session owns in the given domains. */
+    deleteOwner(storageKey: string, sessionId: string, domains: readonly TFlexRecordDomain[]): Promise<void>;
+    /** Deletes every record and chunk of one domain in a storage namespace. */
+    purgeNamespace(storageKey: string, domain: TFlexRecordDomain): Promise<void>;
+    private deleteInTransaction;
+    private parse;
+    private findHead;
+    private readHead;
+    private readBlob;
+    /** Returns false when another writer swapped the head first; nothing of this write remains. */
+    private commit;
+    private newHead;
+    private insertHead;
+    /** Reserves the record for a chunked first write, so its chunks have a head token to replace. */
+    private insertPlaceholder;
+    private markChunked;
+    private writeBlob;
+    /**
+     * Deletes the record's chunks that no head can reference any more: every blob but the current
+     * one that was written against another head token. A writer that read the current token keeps
+     * its chunks. Touching the head in the same transaction makes a concurrent deletion conflict,
+     * so chunks written after a deletion are never swept by a transaction that predates it.
+     */
+    private sweep;
+}