@lossless.org/client 0.1.0

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

@@ -0,0 +1,30 @@
+import { SmartdataCollection, type INormalizedCollectionModelSchema } from './classes.collection.js';
+import { SmartdataDb } from './classes.db.js';
+/**
+ * Per-SmartdataDb collection cache.
+ *
+ * Historically this class keyed its cache by class name alone, which meant
+ * the first SmartdataDb to request a collection of a given class name
+ * "won" — every subsequent call from a different SmartdataDb instance
+ * received the cached collection bound to the first db. That silently
+ * broke multi-tenant SaaS apps (one db per tenant), tests instantiating
+ * multiple SmartdataDbs in sequence, and any in-process db cluster switch.
+ *
+ * The cache is now keyed by `(SmartdataDb instance, className)` using a
+ * WeakMap of db → Map<className, SmartdataCollection>. Entries are GC'd
+ * with their parent db automatically.
+ */
+export declare class CollectionFactory {
+    private perDbCollections;
+    getCollection: (nameArg: string, dbArg: SmartdataDb, schemaArg?: INormalizedCollectionModelSchema) => SmartdataCollection<any>;
+    /**
+     * @deprecated Internal back-compat shim. The previous field was a public
+     * Record<className, SmartdataCollection> but was not part of the
+     * documented public API. WeakMap is not iterable, so this getter returns
+     * an empty object — anyone actually relying on the old shape would get
+     * clean nothing rather than wrong-db data. Will be removed in 8.0.
+     */
+    get collections(): {
+        [key: string]: SmartdataCollection<any>;
+    };
+}

package/dist_ts/nosqldb/classes.collectionfactory.js

@@ -0,0 +1,65 @@
+import * as plugins from './plugins.js';
+import { SmartdataCollection, } from './classes.collection.js';
+import { SmartdataDb } from './classes.db.js';
+import { SmartdataPersistenceError } from './classes.persistence.js';
+/**
+ * Per-SmartdataDb collection cache.
+ *
+ * Historically this class keyed its cache by class name alone, which meant
+ * the first SmartdataDb to request a collection of a given class name
+ * "won" — every subsequent call from a different SmartdataDb instance
+ * received the cached collection bound to the first db. That silently
+ * broke multi-tenant SaaS apps (one db per tenant), tests instantiating
+ * multiple SmartdataDbs in sequence, and any in-process db cluster switch.
+ *
+ * The cache is now keyed by `(SmartdataDb instance, className)` using a
+ * WeakMap of db → Map<className, SmartdataCollection>. Entries are GC'd
+ * with their parent db automatically.
+ */
+export class CollectionFactory {
+    perDbCollections = new WeakMap();
+    getCollection = (nameArg, dbArg, schemaArg) => {
+        if (!(dbArg instanceof SmartdataDb)) {
+            // Preserve the historical behavior of returning undefined-ish for
+            // non-db args. All in-repo callers already guard on instanceof
+            // before using the result (see classes.collection.ts).
+            return undefined;
+        }
+        let dbMap = this.perDbCollections.get(dbArg);
+        if (!dbMap) {
+            dbMap = new Map();
+            this.perDbCollections.set(dbArg, dbMap);
+        }
+        let entry = dbMap.get(nameArg);
+        if (!entry) {
+            const collection = new SmartdataCollection(nameArg, dbArg);
+            entry = { collection, schema: schemaArg };
+            if (schemaArg) {
+                collection.bindModelSchema(schemaArg);
+            }
+            dbMap.set(nameArg, entry);
+        }
+        else if (schemaArg) {
+            if (entry.schema &&
+                entry.schema.fingerprint !== schemaArg.fingerprint) {
+                throw new SmartdataPersistenceError('invalid_configuration', `Collection "${nameArg}" already has a divergent model schema in this SmartdataDb.`);
+            }
+            if (!entry.schema) {
+                entry.schema = schemaArg;
+            }
+            entry.collection.bindModelSchema(schemaArg);
+        }
+        return entry.collection;
+    };
+    /**
+     * @deprecated Internal back-compat shim. The previous field was a public
+     * Record<className, SmartdataCollection> but was not part of the
+     * documented public API. WeakMap is not iterable, so this getter returns
+     * an empty object — anyone actually relying on the old shape would get
+     * clean nothing rather than wrong-db data. Will be removed in 8.0.
+     */
+    get collections() {
+        return {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+type TCollectionReconnectHandler = () => void;
+export declare const registerCollectionReconnectHandler: (collectionArg: object, handlerArg: TCollectionReconnectHandler) => void;
+export declare const notifyCollectionReconnect: (collectionArg: object) => void;
+export {};

package/dist_ts/nosqldb/classes.collectionlifecycle.js

@@ -0,0 +1,15 @@
+const reconnectHandlersByCollection = new WeakMap();
+export const registerCollectionReconnectHandler = (collectionArg, handlerArg) => {
+    let handlers = reconnectHandlersByCollection.get(collectionArg);
+    if (!handlers) {
+        handlers = new Set();
+        reconnectHandlersByCollection.set(collectionArg, handlers);
+    }
+    handlers.add(handlerArg);
+};
+export const notifyCollectionReconnect = (collectionArg) => {
+    for (const handler of reconnectHandlersByCollection.get(collectionArg) || []) {
+        handler();
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2xhc3Nlcy5jb2xsZWN0aW9ubGlmZWN5Y2xlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvbm9zcWxkYi9jbGFzc2VzLmNvbGxlY3Rpb25saWZlY3ljbGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSw2QkFBNkIsR0FBRyxJQUFJLE9BQU8sRUFHOUMsQ0FBQztBQUVKLE1BQU0sQ0FBQyxNQUFNLGtDQUFrQyxHQUFHLENBQ2hELGFBQXFCLEVBQ3JCLFVBQXVDLEVBQ2pDLEVBQUU7SUFDUixJQUFJLFFBQVEsR0FBRyw2QkFBNkIsQ0FBQyxHQUFHLENBQUMsYUFBYSxDQUFDLENBQUM7SUFDaEUsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO1FBQ2QsUUFBUSxHQUFHLElBQUksR0FBRyxFQUFFLENBQUM7UUFDckIsNkJBQTZCLENBQUMsR0FBRyxDQUFDLGFBQWEsRUFBRSxRQUFRLENBQUMsQ0FBQztJQUM3RCxDQUFDO0lBQ0QsUUFBUSxDQUFDLEdBQUcsQ0FBQyxVQUFVLENBQUMsQ0FBQztBQUMzQixDQUFDLENBQUM7QUFFRixNQUFNLENBQUMsTUFBTSx5QkFBeUIsR0FBRyxDQUFDLGFBQXFCLEVBQVEsRUFBRTtJQUN2RSxLQUFLLE1BQU0sT0FBTyxJQUFJLDZCQUE2QixDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLEVBQUUsQ0FBQztRQUM3RSxPQUFPLEVBQUUsQ0FBQztJQUNaLENBQUM7QUFDSCxDQUFDLENBQUMifQ==

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

@@ -0,0 +1,34 @@
+import type * as plugins from './plugins.js';
+import type { INormalizedCollectionModelSchema } from './classes.collection.js';
+export interface ISmartdataCollectionPreparationOptions {
+    /** Observe an exact topology, or install only missing declarations. */
+    mode: 'requireExact' | 'ensureCompatible';
+    /** Total budget including queueing and cursor cleanup: 1 through 120000 ms. */
+    timeoutMs: number;
+    signal?: AbortSignal;
+}
+/** @internal Validate before resolving a model manager or starting a deadline. */
+export declare const validateCollectionPreparationOptions: (opts: ISmartdataCollectionPreparationOptions) => void;
+/** @internal Owns the explicit preparation caller's deadline and queue wait. */
+export declare class CollectionPreparationBudget {
+    readonly signal: AbortSignal;
+    readonly mode: ISmartdataCollectionPreparationOptions['mode'];
+    private readonly deadline;
+    private readonly expiresAt;
+    private readonly timer;
+    constructor(opts: ISmartdataCollectionPreparationOptions);
+    private expire;
+    check(): void;
+    operationOptions(): {
+        timeoutMS: number;
+    };
+    /** Cleanup still runs after expiration; zero would disable the driver's timeout. */
+    cleanupOptions(): {
+        timeoutMS: number;
+    };
+    /** Cancellation detaches only this waiter, never the operation it is waiting for. */
+    waitFor(operationArg: Promise<void>): Promise<void>;
+    close(): void;
+}
+/** @internal No state is published until all commands and cleanup have settled. */
+export declare const prepareBoundCollection: (dbArg: plugins.mongodb.Db, schemaArg: INormalizedCollectionModelSchema, budgetArg: CollectionPreparationBudget, assertCurrentArg: () => void) => Promise<plugins.mongodb.Collection>;

package/dist_ts/nosqldb/classes.collectionpreparation.js

@@ -0,0 +1,134 @@
+import { SmartdataPersistenceError } from './classes.persistence.js';
+import { readBoundedInspectionCursor } from './classes.namespaceinspection.js';
+import { getExpectedCollectionTopologyForSchema, inspectCollectionTopologySnapshot, } from './classes.collectiontopology.js';
+/** @internal Validate before resolving a model manager or starting a deadline. */
+export const validateCollectionPreparationOptions = (opts) => {
+    if (!opts || Object.getPrototypeOf(opts) !== Object.prototype ||
+        Reflect.ownKeys(opts).some((keyArg) => typeof keyArg !== 'string' ||
+            !['mode', 'timeoutMs', 'signal'].includes(keyArg) ||
+            !('value' in Object.getOwnPropertyDescriptor(opts, keyArg))) ||
+        !['requireExact', 'ensureCompatible'].includes(opts.mode) ||
+        !Number.isSafeInteger(opts.timeoutMs) || opts.timeoutMs < 1 || opts.timeoutMs > 120_000 ||
+        (opts.signal !== undefined && !(opts.signal instanceof AbortSignal))) {
+        throw new SmartdataPersistenceError('invalid_argument', 'Invalid collection preparation options.');
+    }
+    opts.signal?.throwIfAborted();
+};
+/** @internal Owns the explicit preparation caller's deadline and queue wait. */
+export class CollectionPreparationBudget {
+    signal;
+    mode;
+    deadline = new AbortController();
+    expiresAt;
+    timer;
+    constructor(opts) {
+        validateCollectionPreparationOptions(opts);
+        this.mode = opts.mode;
+        this.expiresAt = performance.now() + opts.timeoutMs;
+        this.timer = setTimeout(() => this.expire(), opts.timeoutMs);
+        this.signal = opts.signal ? AbortSignal.any([opts.signal, this.deadline.signal]) : this.deadline.signal;
+    }
+    expire() {
+        this.deadline.abort(new SmartdataPersistenceError('unsupported_operation', 'Collection preparation deadline exceeded.'));
+    }
+    check() {
+        if (performance.now() >= this.expiresAt)
+            this.expire();
+        this.signal.throwIfAborted();
+    }
+    operationOptions() {
+        this.check();
+        return this.cleanupOptions();
+    }
+    /** Cleanup still runs after expiration; zero would disable the driver's timeout. */
+    cleanupOptions() {
+        return { timeoutMS: Math.max(1, Math.ceil(this.expiresAt - performance.now())) };
+    }
+    /** Cancellation detaches only this waiter, never the operation it is waiting for. */
+    async waitFor(operationArg) {
+        this.check();
+        await new Promise((resolveArg, rejectArg) => {
+            const onAbort = () => { cleanup(); rejectArg(this.signal.reason); };
+            const cleanup = () => this.signal.removeEventListener('abort', onAbort);
+            this.signal.addEventListener('abort', onAbort, { once: true });
+            operationArg.then(() => { cleanup(); resolveArg(); }, () => { cleanup(); resolveArg(); });
+            if (this.signal.aborted)
+                onAbort();
+        });
+        this.check();
+    }
+    close() { clearTimeout(this.timer); }
+}
+/** @internal No state is published until all commands and cleanup have settled. */
+export const prepareBoundCollection = async (dbArg, schemaArg, budgetArg, assertCurrentArg) => {
+    const expected = getExpectedCollectionTopologyForSchema(schemaArg);
+    const collection = dbArg.collection(schemaArg.collectionName);
+    const check = () => { budgetArg.check(); assertCurrentArg(); };
+    const inspect = async () => {
+        check();
+        const namespaces = await readBoundedInspectionCursor(dbArg.listCollections({ name: schemaArg.collectionName }, { nameOnly: false, batchSize: 1, ...budgetArg.operationOptions(), signal: budgetArg.signal }), 1, budgetArg.signal, () => budgetArg.cleanupOptions());
+        check();
+        const namespace = namespaces[0];
+        const indexes = namespace?.type === 'collection'
+            ? await readBoundedInspectionCursor(collection.listIndexes({
+                batchSize: 1, ...budgetArg.operationOptions(),
+            }), 64, budgetArg.signal, () => budgetArg.cleanupOptions())
+            : [];
+        check();
+        return inspectCollectionTopologySnapshot(expected, { namespace: namespace ?? null, indexes });
+    };
+    const requireAcceptable = (inspectionArg, exactArg) => {
+        if (inspectionArg.status === 'divergent' || (exactArg && inspectionArg.status !== 'exact')) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Collection "${schemaArg.collectionName}" requires ${exactArg ? 'exact' : 'compatible'} topology: ` +
+                `${inspectionArg.status}${inspectionArg.reasonCodes.length ? ` (${inspectionArg.reasonCodes.join(', ')})` : ''}.`);
+        }
+    };
+    let inspection = await inspect();
+    requireAcceptable(inspection, budgetArg.mode === 'requireExact');
+    if (budgetArg.mode === 'ensureCompatible' && inspection.status !== 'exact') {
+        if (inspection.status === 'absent') {
+            check();
+            try {
+                await dbArg.createCollection(schemaArg.collectionName, budgetArg.operationOptions());
+            }
+            catch (errorArg) {
+                if (errorArg?.code !== 48)
+                    throw errorArg;
+            }
+            // A competing creator may have installed divergent options or indexes.
+            inspection = await inspect();
+            requireAcceptable(inspection, false);
+            if (inspection.status === 'absent') {
+                throw new SmartdataPersistenceError('unsupported_operation', 'Created collection is not observable.');
+            }
+        }
+        const existing = new Set(inspection.actualIndexes.map((indexArg) => indexArg.name));
+        for (const index of schemaArg.indexes) {
+            if (existing.has(index.name))
+                continue;
+            check();
+            try {
+                await collection.createIndex(Object.fromEntries(index.key), {
+                    ...index.options, name: index.name, ...budgetArg.operationOptions(),
+                });
+            }
+            catch (errorArg) {
+                // A rejected acknowledgement does not prove the index build failed.
+                // Continue only from compatible observed topology containing this exact
+                // declaration, within the same deadline and connection generation.
+                inspection = await inspect();
+                requireAcceptable(inspection, false);
+                if (!inspection.actualIndexes.some((actualArg) => actualArg.name === index.name)) {
+                    throw errorArg;
+                }
+                for (const actual of inspection.actualIndexes)
+                    existing.add(actual.name);
+            }
+        }
+        inspection = await inspect();
+        requireAcceptable(inspection, true);
+    }
+    check();
+    return collection;
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.collectionpreparation.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.collectionpreparation.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,47 @@
+import type { INormalizedCollectionModelSchema } from './classes.collection.js';
+import type { SmartdataDb } from './classes.db.js';
+export type TSmartdataCollectionTopologyStatus = 'absent' | 'compatible' | 'exact' | 'divergent';
+export type TSmartdataCollectionTopologyReasonCode = 'namespace_not_collection' | 'collection_options_present' | 'id_index_missing' | 'id_index_changed' | 'expected_index_missing' | 'unexpected_index' | 'index_changed' | 'unsupported_actual_index';
+export type TSmartdataCollectionTopologyIndexDirection = 1 | -1 | 'text';
+export interface ISmartdataCollectionTopologyIndexKey {
+    readonly path: string;
+    readonly direction: TSmartdataCollectionTopologyIndexDirection;
+    readonly weight: number | null;
+}
+export interface ISmartdataCollectionTopologyIndex {
+    readonly name: string;
+    readonly keys: readonly ISmartdataCollectionTopologyIndexKey[];
+    readonly unique: boolean;
+    readonly sparse: boolean;
+    readonly expireAfterSeconds: number | null;
+}
+export interface ISmartdataExpectedCollectionTopology {
+    readonly collectionName: string;
+    readonly indexes: readonly ISmartdataCollectionTopologyIndex[];
+}
+export interface ISmartdataCollectionTopologyInspection {
+    readonly collectionName: string;
+    readonly status: TSmartdataCollectionTopologyStatus;
+    readonly reasonCodes: readonly TSmartdataCollectionTopologyReasonCode[];
+    readonly expectedIndexes: readonly ISmartdataCollectionTopologyIndex[];
+    readonly actualIndexes: readonly ISmartdataCollectionTopologyIndex[];
+}
+type TCollectionModelSchemaResolver = () => INormalizedCollectionModelSchema;
+export declare const collectionModelSchemaResolverSymbol: unique symbol;
+export declare const collectionTopologyDbInspectionSymbol: unique symbol;
+interface ICollectionTopologyModelConstructor {
+    readonly name: string;
+    readonly [collectionModelSchemaResolverSymbol]?: TCollectionModelSchemaResolver;
+}
+interface ICollectionTopologyRawSnapshot {
+    namespace: Record<string, unknown> | null;
+    indexes: unknown[];
+}
+export declare const compareSmartdataTopologyStrings: (leftArg: string, rightArg: string) => number;
+export declare const getExpectedCollectionTopologyForModel: (constructorArg: ICollectionTopologyModelConstructor) => ISmartdataExpectedCollectionTopology;
+/** @internal Normalizes the same contract for a bound collection. */
+export declare const getExpectedCollectionTopologyForSchema: (schema: INormalizedCollectionModelSchema) => ISmartdataExpectedCollectionTopology;
+export declare const inspectCollectionTopologyForModel: (constructorArg: ICollectionTopologyModelConstructor, dbArg: SmartdataDb) => Promise<ISmartdataCollectionTopologyInspection>;
+/** @internal Pure normalization shared by model and namespace inspection. */
+export declare const inspectCollectionTopologySnapshot: (expected: ISmartdataExpectedCollectionTopology, rawSnapshot: ICollectionTopologyRawSnapshot) => ISmartdataCollectionTopologyInspection;
+export {};