@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.session.js

@@ -0,0 +1,246 @@
+import * as plugins from './plugins.js';
+import { SmartdataPersistenceError, normalizeOrdinaryPersistenceError, } from './classes.persistence.js';
+const bindings = new WeakMap();
+const bindingsByOwner = new WeakMap();
+const smartdataSessionInvalidationAggregateBrand = Symbol('smartdataSessionInvalidationAggregate');
+class SmartdataSessionInvalidationAggregateError extends AggregateError {
+    [smartdataSessionInvalidationAggregateBrand] = true;
+}
+const transactionContext = new plugins.nodeAsyncHooks.AsyncLocalStorage();
+const resolveBinding = (sessionArg, ownerArg) => {
+    const binding = bindings.get(sessionArg);
+    if (!binding || binding.invalidated || binding.rawSession.hasEnded) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'The SmartData session has ended or is no longer valid.');
+    }
+    if (ownerArg && binding.owner !== ownerArg) {
+        throw new SmartdataPersistenceError('invalid_argument', 'The SmartData session belongs to another database.');
+    }
+    if (binding.owner.status !== 'connected'
+        || binding.owner.mongoDbClient !== binding.client) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'The SmartData session belongs to a stale database lifecycle.');
+    }
+    return binding;
+};
+const assertTransactionSucceeded = (bindingArg) => {
+    if (bindingArg.transactionFailure) {
+        throw bindingArg.transactionFailure.error;
+    }
+};
+export class SmartdataSession {
+    async withTransaction(callbackArg) {
+        if (typeof callbackArg !== 'function') {
+            throw new SmartdataPersistenceError('invalid_argument', 'SmartData transaction callback must be a function.');
+        }
+        const binding = resolveBinding(this);
+        if (binding.operationActive || binding.transactionActive) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Parallel or nested SmartData session operations are not supported.');
+        }
+        binding.transactionActive = true;
+        let callbackError;
+        try {
+            return await binding.rawSession.withTransaction(async () => {
+                const attempt = Symbol('smartdataTransactionAttempt');
+                binding.transactionAttempt = attempt;
+                binding.transactionCallbackOpen = true;
+                binding.transactionUsesOrdinaryWrite = false;
+                binding.transactionFailure = undefined;
+                callbackError = undefined;
+                try {
+                    let callbackReturned = false;
+                    try {
+                        const result = await transactionContext.run({ contextToken: binding.contextToken, attempt }, async () => callbackArg(this));
+                        callbackReturned = true;
+                        return result;
+                    }
+                    finally {
+                        const activeOperation = binding.operationActive
+                            ? binding.operationSettled
+                            : undefined;
+                        binding.transactionCallbackOpen = false;
+                        if (binding.transactionAttempt === attempt) {
+                            binding.transactionAttempt = undefined;
+                        }
+                        if (activeOperation) {
+                            await activeOperation;
+                        }
+                        assertTransactionSucceeded(binding);
+                        if (callbackReturned && activeOperation) {
+                            throw new SmartdataPersistenceError('unsupported_operation', 'A SmartData transaction callback returned with an operation still active.');
+                        }
+                    }
+                }
+                catch (errorArg) {
+                    callbackError = errorArg;
+                    throw errorArg;
+                }
+            });
+        }
+        catch (errorArg) {
+            if (errorArg === callbackError) {
+                throw errorArg;
+            }
+            if (binding.transactionUsesOrdinaryWrite) {
+                return normalizeOrdinaryPersistenceError(errorArg, 'SmartData transaction conflicts with a unique index.');
+            }
+            throw errorArg;
+        }
+        finally {
+            binding.transactionActive = false;
+            binding.transactionUsesOrdinaryWrite = false;
+            binding.transactionFailure = undefined;
+        }
+    }
+    async close() {
+        const binding = bindings.get(this);
+        if (!binding) {
+            return;
+        }
+        if (binding.operationActive || binding.transactionActive) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Cannot close a SmartData session while an operation is active.');
+        }
+        await closeSessionBinding(binding);
+    }
+}
+export const createSmartdataSession = (ownerArg) => {
+    if (ownerArg.status !== 'connected' || !ownerArg.mongoDbClient) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Cannot create a SmartData session before the database is connected.');
+    }
+    const session = new SmartdataSession();
+    const binding = {
+        session,
+        contextToken: Symbol('smartdataSessionContext'),
+        owner: ownerArg,
+        client: ownerArg.mongoDbClient,
+        rawSession: ownerArg.mongoDbClient.startSession(),
+        operationActive: false,
+        transactionActive: false,
+        transactionCallbackOpen: false,
+        transactionUsesOrdinaryWrite: false,
+        invalidated: false,
+    };
+    bindings.set(session, binding);
+    let ownerBindings = bindingsByOwner.get(ownerArg);
+    if (!ownerBindings) {
+        ownerBindings = new Set();
+        bindingsByOwner.set(ownerArg, ownerBindings);
+    }
+    ownerBindings.add(binding);
+    return session;
+};
+export const acquireSmartdataSession = (sessionArg, ownerArg, optionsArg = {}) => {
+    const binding = resolveBinding(sessionArg, ownerArg);
+    if (binding.transactionFailure) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'The SmartData transaction attempt has aborted and cannot accept further operations.');
+    }
+    const currentContext = transactionContext.getStore();
+    const isOwnedTransactionContext = currentContext?.contextToken === binding.contextToken;
+    if (binding.operationActive
+        || (binding.transactionActive
+            && (!binding.transactionCallbackOpen
+                || !isOwnedTransactionContext
+                || currentContext.attempt !== binding.transactionAttempt))
+        || (!binding.transactionActive && isOwnedTransactionContext)) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Parallel SmartData session operations are not supported.');
+    }
+    if (optionsArg.ordinaryWrite && binding.transactionActive) {
+        binding.transactionUsesOrdinaryWrite = true;
+    }
+    binding.operationActive = true;
+    binding.operationSettled = new Promise((resolveArg) => {
+        binding.resolveOperationSettled = resolveArg;
+    });
+    let released = false;
+    return {
+        rawSession: binding.rawSession,
+        release: () => {
+            if (!released) {
+                released = true;
+                binding.operationActive = false;
+                binding.resolveOperationSettled?.();
+                binding.operationSettled = undefined;
+                binding.resolveOperationSettled = undefined;
+            }
+        },
+    };
+};
+/** Marks the current owned attempt for rollback by withTransaction. */
+export const failSmartdataTransaction = (sessionArg, ownerArg, errorArg) => {
+    const binding = resolveBinding(sessionArg, ownerArg);
+    const context = transactionContext.getStore();
+    if (!binding.operationActive
+        || !binding.transactionActive
+        || context?.contextToken !== binding.contextToken
+        || context.attempt !== binding.transactionAttempt) {
+        throw new SmartdataPersistenceError('unsupported_operation', 'Only the active owned operation can abort a SmartData transaction attempt.');
+    }
+    binding.transactionFailure ??= { error: errorArg };
+    throw binding.transactionFailure.error;
+};
+export const isSmartdataSession = (sessionArg) => sessionArg instanceof SmartdataSession;
+export const isOrdinarySessionInTransaction = (sessionArg) => {
+    if (!sessionArg) {
+        return false;
+    }
+    if (isSmartdataSession(sessionArg)) {
+        return resolveBinding(sessionArg).transactionActive;
+    }
+    return sessionArg.inTransaction();
+};
+export const runWithOrdinarySmartdataSession = async (sessionArg, ownerArg, optionsArg, operationArg) => {
+    if (!isSmartdataSession(sessionArg)) {
+        return operationArg(sessionArg);
+    }
+    if (!optionsArg.prepared) {
+        throw new SmartdataPersistenceError('unsupported_operation', optionsArg.preparationMessage ||
+            'Initialize every participating SmartData model before using an owned session.');
+    }
+    const lease = acquireSmartdataSession(sessionArg, ownerArg, {
+        ordinaryWrite: optionsArg.ordinaryWrite,
+    });
+    try {
+        return await operationArg(lease.rawSession);
+    }
+    finally {
+        lease.release();
+    }
+};
+export const invalidateSmartdataSessions = async (ownerArg) => {
+    const ownerBindings = bindingsByOwner.get(ownerArg);
+    if (!ownerBindings) {
+        return;
+    }
+    const sessions = [...ownerBindings];
+    for (const bindingArg of sessions) {
+        bindingArg.invalidated = true;
+    }
+    const results = await Promise.allSettled(sessions.map((bindingArg) => closeSessionBinding(bindingArg)));
+    const errors = results.flatMap((resultArg) => resultArg.status === 'rejected' ? [resultArg.reason] : []);
+    if (errors.length === 1) {
+        throw errors[0];
+    }
+    if (errors.length > 1) {
+        throw new SmartdataSessionInvalidationAggregateError(errors, 'Multiple SmartData sessions failed to close.');
+    }
+};
+/** Failed cleanup remains owned and invalidated until an explicit retry succeeds. */
+const closeSessionBinding = async (bindingArg) => {
+    if (bindingArg.closing)
+        return bindingArg.closing;
+    bindingArg.invalidated = true;
+    const closing = Promise.resolve().then(async () => {
+        await bindingArg.rawSession.endSession();
+        bindingsByOwner.get(bindingArg.owner)?.delete(bindingArg);
+        bindings.delete(bindingArg.session);
+    });
+    bindingArg.closing = closing;
+    try {
+        await closing;
+    }
+    finally {
+        bindingArg.closing = undefined;
+    }
+};
+export const unwrapSmartdataSessionInvalidationErrors = (errorArg) => errorArg instanceof SmartdataSessionInvalidationAggregateError
+    ? errorArg.errors
+    : undefined;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.session.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.session.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,44 @@
+import type { SmartdataDb } from './classes.db.js';
+import { type SmartdataSession } from './classes.session.js';
+export interface ISmartdataStoredInspectionOptions {
+    filter?: Record<string, unknown>;
+    /** Default 100, maximum 10000. Results are ordered by immutable _id. */
+    limit?: number;
+    skip?: number;
+    /** Default 4 MiB, maximum 64 MiB; overflow rejects the entire page. */
+    maxBytes?: number;
+    /** Default 5000ms, maximum 120000ms. */
+    timeoutMS?: number;
+    signal?: AbortSignal;
+    session?: SmartdataSession;
+}
+export interface ISmartdataStoredInspection {
+    readonly documents: readonly Readonly<Record<string, unknown>>[];
+    readonly hasMore: boolean;
+}
+export type TSmartdataOrdinaryDocumentEvidence = {
+    readonly status: 'valid';
+} | {
+    readonly status: 'invalid';
+    readonly code: 'invalid_document';
+} | {
+    readonly status: 'not_configured';
+};
+export interface ISmartdataStoredDocumentEvidence {
+    /** Untouched stored BSON for diagnosis, never an authorized application record. */
+    readonly document: Readonly<Record<string, unknown>>;
+    /** Reports only the model's ordinary persistence assertion, not exact/domain assertions. */
+    readonly ordinaryValidation: TSmartdataOrdinaryDocumentEvidence;
+}
+export interface ISmartdataStoredEvidenceInspection {
+    readonly evidence: readonly ISmartdataStoredDocumentEvidence[];
+    readonly hasMore: boolean;
+}
+/** @internal Strict inspection used by Model.inspectStoredDocuments. */
+export declare const inspectStoredDocuments: (modelArg: any, dbArg: SmartdataDb, opts?: ISmartdataStoredInspectionOptions) => Promise<ISmartdataStoredInspection>;
+/**
+ * @internal Diagnostic inspection preserves malformed evidence from the same
+ * model and bounds as strict inspection. Invalid records must never enter
+ * normal application flows. Exact and domain assertions remain caller-owned.
+ */
+export declare const inspectStoredDocumentEvidence: (modelArg: any, dbArg: SmartdataDb, opts?: ISmartdataStoredInspectionOptions) => Promise<ISmartdataStoredEvidenceInspection>;

package/dist_ts/nosqldb/classes.storedinspection.js

@@ -0,0 +1,100 @@
+import * as plugins from './plugins.js';
+import { convertFilterForMongoDb } from './classes.doc.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import { runCursorOperation } from './classes.cursoroperation.js';
+import { acquireSmartdataSession, isSmartdataSession } from './classes.session.js';
+import { collectionTopologyDbInspectionSymbol, collectionModelSchemaResolverSymbol, } from './classes.collectiontopology.js';
+import { validateOrdinaryStoredDocument } from './classes.ordinarypersistence.js';
+/** No model binding, index initialization, hydration, or raw handle escapes. */
+const readStoredDocuments = async (modelArg, dbArg, opts = {}) => {
+    if (!opts || Object.getPrototypeOf(opts) !== Object.prototype ||
+        Reflect.ownKeys(opts).some((keyArg) => typeof keyArg !== 'string' ||
+            !['filter', 'limit', 'skip', 'maxBytes', 'timeoutMS', 'signal', 'session'].includes(keyArg) ||
+            !('value' in Object.getOwnPropertyDescriptor(opts, keyArg)))) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Invalid stored inspection options.');
+    }
+    const limit = opts.limit === undefined ? 100 : opts.limit;
+    const skip = opts.skip === undefined ? 0 : opts.skip;
+    const maxBytes = opts.maxBytes === undefined ? 4 * 1024 * 1024 : opts.maxBytes;
+    const timeoutMS = opts.timeoutMS === undefined ? 5_000 : opts.timeoutMS;
+    if (!Number.isSafeInteger(limit) || limit < 1 || limit > 10_000 ||
+        !Number.isSafeInteger(skip) || skip < 0 || skip > 2_147_483_647 ||
+        !Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > 64 * 1024 * 1024 ||
+        !Number.isSafeInteger(timeoutMS) || timeoutMS < 1 || timeoutMS > 120_000 ||
+        (opts.signal !== undefined && !(opts.signal instanceof AbortSignal)) ||
+        (opts.session !== undefined && !isSmartdataSession(opts.session))) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Invalid stored inspection bounds or context.');
+    }
+    opts.signal?.throwIfAborted();
+    const schema = modelArg[collectionModelSchemaResolverSymbol]();
+    const filter = convertFilterForMongoDb(opts.filter || {});
+    const lease = opts.session ? acquireSmartdataSession(opts.session, dbArg) : undefined;
+    let page;
+    try {
+        page = await dbArg[collectionTopologyDbInspectionSymbol](async (mongoDbArg) => {
+            const cursor = mongoDbArg.collection(schema.collectionName).find(filter, {
+                sort: { _id: 1 }, skip, limit: limit + 1, batchSize: 1,
+                timeoutMS, timeoutMode: 'cursorLifetime', signal: opts.signal, session: lease?.rawSession,
+            });
+            return runCursorOperation(cursor, async (cursorArg) => {
+                const documents = [];
+                let bytes = 0;
+                while (true) {
+                    const next = await cursorArg.next();
+                    if (next === null)
+                        return { documents, hasMore: false };
+                    if (documents.length === limit)
+                        return { documents, hasMore: true };
+                    bytes += plugins.mongodb.BSON.calculateObjectSize(next);
+                    if (bytes > maxBytes)
+                        throw new SmartdataPersistenceError('unsupported_operation', 'Stored inspection exceeds its byte budget.');
+                    documents.push(next);
+                }
+            }, opts.signal);
+        });
+    }
+    catch (errorArg) {
+        opts.signal?.throwIfAborted();
+        throw errorArg;
+    }
+    finally {
+        lease?.release();
+    }
+    return { schema, page };
+};
+/** @internal Strict inspection used by Model.inspectStoredDocuments. */
+export const inspectStoredDocuments = async (modelArg, dbArg, opts = {}) => {
+    const { schema, page } = await readStoredDocuments(modelArg, dbArg, opts);
+    // Full validation occurs on the untouched stored envelope, before any
+    // constructor/default/serializer can hide field-presence evidence.
+    const documents = schema.ordinaryPersistence
+        ? page.documents.map((documentArg) => validateOrdinaryStoredDocument(documentArg, schema.ordinaryPersistence, schema.persistedFields))
+        : page.documents;
+    return Object.freeze({ documents: Object.freeze(documents), hasMore: page.hasMore });
+};
+/**
+ * @internal Diagnostic inspection preserves malformed evidence from the same
+ * model and bounds as strict inspection. Invalid records must never enter
+ * normal application flows. Exact and domain assertions remain caller-owned.
+ */
+export const inspectStoredDocumentEvidence = async (modelArg, dbArg, opts = {}) => {
+    const { schema, page } = await readStoredDocuments(modelArg, dbArg, opts);
+    const evidence = page.documents.map((documentArg) => {
+        let ordinaryValidation = { status: 'not_configured' };
+        if (schema.ordinaryPersistence) {
+            try {
+                validateOrdinaryStoredDocument(documentArg, schema.ordinaryPersistence, schema.persistedFields);
+                ordinaryValidation = { status: 'valid' };
+            }
+            catch (errorArg) {
+                if (!(errorArg instanceof SmartdataPersistenceError) || errorArg.code !== 'invalid_document') {
+                    throw errorArg;
+                }
+                ordinaryValidation = { status: 'invalid', code: 'invalid_document' };
+            }
+        }
+        return Object.freeze({ document: documentArg, ordinaryValidation: Object.freeze(ordinaryValidation) });
+    });
+    return Object.freeze({ evidence: Object.freeze(evidence), hasMore: page.hasMore });
+};
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,56 @@
+import { SmartdataDb } from './classes.db.js';
+import { SmartDataDbDoc } from './classes.doc.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+export interface ISmartdataTestConnection {
+    /** Literal loopback IPv4, ::1, or localhost (normalized to 127.0.0.1). */
+    host: string;
+    port: number;
+    /** Supply both credentials or neither. Authentication uses admin. */
+    username?: string;
+    password?: string;
+}
+export interface ISmartdataTestDatabaseOptions {
+    connection: ISmartdataTestConnection;
+    /** Default 5000; maximum 120000 ms, shared by connection and ownership checks. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ISmartdataStoredDocumentFaultOptions {
+    /** Default 64 KiB, maximum 1 MiB. */
+    maxBytes?: number;
+    /** Default 5000; maximum 120000 ms, including collection preparation. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export interface ISmartdataIndexFaultOptions {
+    /** Default 5000; maximum 120000 ms, shared by topology verification and removal. */
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+export type TSmartdataTestModel = Pick<typeof SmartDataDbDoc, 'prototype' | 'collection' | 'getExpectedCollectionTopology' | 'prepareCollection'> & (abstract new (...args: never[]) => object);
+/** Construction failed and cleanup also failed. Explicit close retries the retained owner. */
+export declare class SmartdataTestDatabaseCreationError extends SmartdataPersistenceError {
+    #private;
+    constructor(cleanupArg: () => Promise<void>);
+    close(): Promise<void>;
+}
+/** Disposable fault injection is available only through the testsupport package subpath. */
+export declare class SmartdataTestDatabase {
+    #private;
+    readonly db: SmartdataDb;
+    private constructor();
+    static create(optionsArg: ISmartdataTestDatabaseOptions): Promise<SmartdataTestDatabase>;
+    insertStoredDocumentFault(modelArg: TSmartdataTestModel, documentArg: unknown, optionsArg?: ISmartdataStoredDocumentFaultOptions): Promise<void>;
+    replaceStoredDocumentFault(modelArg: TSmartdataTestModel, expectedIdArg: unknown, documentArg: unknown, optionsArg?: ISmartdataStoredDocumentFaultOptions): Promise<void>;
+    /** Remove one declared secondary index from an exact, owned test collection. */
+    dropDeclaredIndexFault(modelArg: TSmartdataTestModel, indexNameArg: string, optionsArg?: ISmartdataIndexFaultOptions): Promise<void>;
+    private assertFaultAvailable;
+    private getFaultModelTopology;
+    private assertOwnedBinding;
+    private inject;
+    /** Idempotent after success. A failed close retains ownership for an explicit retry. */
+    close(optionsArg?: {
+        timeoutMs?: number;
+    }): Promise<void>;
+    private dispose;
+}