@lossless.org/client 0.1.0

package/dist_ts/nosqldb/classes.collection.js

@@ -0,0 +1,1568 @@
+import * as plugins from './plugins.js';
+import { LosslessClientError } from '../core/classes.error.js';
+import { runCursorOperation } from './classes.cursoroperation.js';
+import { CollectionPreparationBudget, prepareBoundCollection, } from './classes.collectionpreparation.js';
+import { getOrdinaryPersistencePolicy, validateOrdinaryStoredDocument, } from './classes.ordinarypersistence.js';
+import { SmartdataDb } from './classes.db.js';
+import { SmartdataDbCursor } from './classes.cursor.js';
+import { SmartDataDbDoc, } from './classes.doc.js';
+import { SmartdataDbWatcher } from './classes.watcher.js';
+import { CollectionFactory } from './classes.collectionfactory.js';
+import { logger } from './logging.js';
+import { SmartdataPersistenceError, normalizeOrdinaryPersistenceError, } from './classes.persistence.js';
+import { notifyCollectionReconnect } from './classes.collectionlifecycle.js';
+import { runWithOrdinarySmartdataSession, } from './classes.session.js';
+import { collectionModelSchemaResolverSymbol, collectionTopologyDbInspectionSymbol, getExpectedCollectionTopologyForSchema, compareSmartdataTopologyStrings, } from './classes.collectiontopology.js';
+const collectionFactory = new CollectionFactory();
+const unsafeFieldNames = new Set(['__proto__', 'prototype', 'constructor']);
+const automaticTextIndexName = 'smartdata_text_index';
+const requireSafeFieldName = (fieldArg, labelArg, allowPathArg = false) => {
+    if (typeof fieldArg !== 'string' ||
+        fieldArg.length === 0 ||
+        fieldArg.includes('\0') ||
+        fieldArg.startsWith('$')) {
+        throw new SmartdataPersistenceError('invalid_configuration', `${labelArg} must be a non-empty safe field name.`);
+    }
+    const segments = fieldArg.split('.');
+    if ((!allowPathArg && segments.length !== 1) ||
+        segments.some((segmentArg) => segmentArg.length === 0 ||
+            segmentArg.startsWith('$') ||
+            unsafeFieldNames.has(segmentArg))) {
+        throw new SmartdataPersistenceError('invalid_configuration', `${labelArg} contains an unsafe field name.`);
+    }
+    return fieldArg;
+};
+const normalizeCollectionName = (collectionNameArg, labelArg = 'SmartData collectionName') => {
+    if (typeof collectionNameArg !== 'string' ||
+        collectionNameArg.trim().length === 0 ||
+        collectionNameArg.includes('\0') ||
+        collectionNameArg.startsWith('system.')) {
+        throw new SmartdataPersistenceError('invalid_configuration', `${labelArg} must be a non-empty non-system name without null bytes.`);
+    }
+    return collectionNameArg;
+};
+const normalizeIndexOptions = (optionsArg, indexNameArg, allowExtendedOptionsArg = false) => {
+    const options = optionsArg || {};
+    const allowedKeys = new Set([
+        'background',
+        'unique',
+        'sparse',
+        'expireAfterSeconds',
+    ]);
+    if (!allowExtendedOptionsArg) {
+        for (const optionName of Object.keys(options)) {
+            if (allowedKeys.has(optionName)) {
+                continue;
+            }
+            throw new SmartdataPersistenceError('invalid_configuration', `Index "${indexNameArg}" defines unsupported option "${optionName}".`);
+        }
+    }
+    for (const booleanOption of ['background', 'unique', 'sparse']) {
+        if (options[booleanOption] !== undefined &&
+            typeof options[booleanOption] !== 'boolean') {
+            throw new SmartdataPersistenceError('invalid_configuration', `Index "${indexNameArg}" option "${booleanOption}" must be boolean.`);
+        }
+    }
+    if (options.expireAfterSeconds !== undefined &&
+        (!Number.isFinite(options.expireAfterSeconds) ||
+            options.expireAfterSeconds < 0)) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Index "${indexNameArg}" expireAfterSeconds must be a finite non-negative number.`);
+    }
+    return Object.freeze(allowExtendedOptionsArg
+        ? { ...options }
+        : {
+            ...(options.background === true ? { background: true } : {}),
+            ...(options.unique === true ? { unique: true } : {}),
+            ...(options.sparse === true ? { sparse: true } : {}),
+            ...(options.expireAfterSeconds !== undefined
+                ? { expireAfterSeconds: options.expireAfterSeconds }
+                : {}),
+        });
+};
+const stableValue = (valueArg) => {
+    if (Array.isArray(valueArg)) {
+        return `[${valueArg.map((entryArg) => stableValue(entryArg)).join(',')}]`;
+    }
+    if (typeof valueArg === 'object' && valueArg !== null) {
+        return `{${Object.keys(valueArg)
+            .sort(compareSmartdataTopologyStrings)
+            .map((keyArg) => `${JSON.stringify(keyArg)}:${stableValue(valueArg[keyArg])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(valueArg);
+};
+const normalizeCollectionModelSchema = (configArg, allowExtendedIndexOptionsArg = false, identityValueTypesArg, ordinaryPolicyArg) => {
+    if (typeof configArg !== 'object' ||
+        configArg === null ||
+        Array.isArray(configArg)) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Collection model config must be an object.');
+    }
+    const allowedConfigKeys = new Set([
+        'collectionName',
+        'persistedFields',
+        'numericFields',
+        'identityFields',
+        'searchableFields',
+        'indexes',
+    ]);
+    for (const key of Object.keys(configArg)) {
+        if (!allowedConfigKeys.has(key)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Collection model config defines unsupported key "${key}".`);
+        }
+    }
+    const collectionName = normalizeCollectionName(configArg.collectionName);
+    if (!Array.isArray(configArg.persistedFields)) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Collection model persistedFields must be an array.');
+    }
+    const persistedFields = [];
+    for (const field of configArg.persistedFields) {
+        requireSafeFieldName(field, 'A persisted field');
+        if (!persistedFields.includes(field)) {
+            persistedFields.push(field);
+        }
+    }
+    if (ordinaryPolicyArg?.idType === 'string' && !persistedFields.includes('_id')) {
+        persistedFields.push('_id');
+    }
+    if (configArg.numericFields !== undefined &&
+        !Array.isArray(configArg.numericFields)) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Collection model numericFields must be an array.');
+    }
+    const numericFields = [];
+    for (const field of configArg.numericFields || []) {
+        requireSafeFieldName(field, 'A numeric field');
+        if (!persistedFields.includes(field)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Numeric field "${field}" is not a declared persisted field.`);
+        }
+        if (!numericFields.includes(field)) {
+            numericFields.push(field);
+        }
+    }
+    if (configArg.identityFields !== undefined &&
+        !Array.isArray(configArg.identityFields)) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Collection model identityFields must be an array.');
+    }
+    const identityFields = [];
+    for (const field of configArg.identityFields || []) {
+        requireSafeFieldName(field, 'An identity field');
+        if (!persistedFields.includes(field)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Identity field "${field}" is not a declared persisted field.`);
+        }
+        if (!identityFields.includes(field)) {
+            identityFields.push(field);
+        }
+    }
+    const identityValueTypes = {};
+    for (const field of Object.keys(identityValueTypesArg || {})) {
+        if (!identityFields.includes(field)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Identity valueType field "${field}" is not a declared identity field.`);
+        }
+    }
+    for (const field of identityFields) {
+        const valueType = identityValueTypesArg?.[field] ?? 'string';
+        if (valueType !== 'string' && valueType !== 'positiveSafeInteger') {
+            throw new SmartdataPersistenceError('invalid_configuration', `Identity field "${field}" has an unsupported valueType.`);
+        }
+        identityValueTypes[field] = valueType;
+        if (valueType === 'positiveSafeInteger' && !numericFields.includes(field)) {
+            numericFields.push(field);
+        }
+    }
+    const searchableFields = [];
+    if (configArg.searchableFields !== undefined &&
+        !Array.isArray(configArg.searchableFields)) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Collection model searchableFields must be an array.');
+    }
+    for (const field of configArg.searchableFields || []) {
+        requireSafeFieldName(field, 'A searchable field');
+        if (!persistedFields.includes(field)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Searchable field "${field}" is not a declared persisted field.`);
+        }
+        if (!searchableFields.includes(field)) {
+            searchableFields.push(field);
+        }
+    }
+    if (configArg.indexes !== undefined && !Array.isArray(configArg.indexes)) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'Collection model indexes must be an array.');
+    }
+    const indexesByName = new Map();
+    for (const index of configArg.indexes || []) {
+        if (typeof index !== 'object' ||
+            index === null ||
+            Array.isArray(index) ||
+            typeof index.name !== 'string' ||
+            index.name.trim().length === 0 ||
+            index.name.includes('\0')) {
+            throw new SmartdataPersistenceError('invalid_configuration', 'Every collection model index requires a non-empty safe name.');
+        }
+        if (index.name === automaticTextIndexName) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Index name "${automaticTextIndexName}" is reserved for SmartData's automatic text index.`);
+        }
+        const indexKeys = Object.entries(index.key || {});
+        if (indexKeys.length === 0) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Index "${index.name}" requires at least one key.`);
+        }
+        const normalizedKeys = indexKeys.map(([field, direction]) => {
+            requireSafeFieldName(field, `Index "${index.name}" field`, true);
+            const root = field.split('.')[0];
+            if (!persistedFields.includes(root) &&
+                root !== '_createdAt' &&
+                root !== '_updatedAt') {
+                throw new SmartdataPersistenceError('invalid_configuration', `Index "${index.name}" references undeclared field "${field}".`);
+            }
+            if (direction !== 1 && direction !== -1 && direction !== 'text') {
+                throw new SmartdataPersistenceError('invalid_configuration', `Index "${index.name}" has an invalid direction for "${field}".`);
+            }
+            return Object.freeze([field, direction]);
+        });
+        const normalizedIndex = Object.freeze({
+            name: index.name,
+            key: Object.freeze(normalizedKeys),
+            options: normalizeIndexOptions(index.options, index.name, allowExtendedIndexOptionsArg),
+        });
+        const existing = indexesByName.get(index.name);
+        if (existing && stableValue(existing) !== stableValue(normalizedIndex)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Index "${index.name}" has divergent declarations.`);
+        }
+        indexesByName.set(index.name, existing || normalizedIndex);
+    }
+    const textIndexes = [...indexesByName.values()].filter((indexArg) => indexArg.key.some(([, directionArg]) => directionArg === 'text'));
+    if (textIndexes.length > 1) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'A collection model may declare at most one text index.');
+    }
+    if (textIndexes.length === 1) {
+        const indexedTextFields = textIndexes[0].key
+            .filter(([, directionArg]) => directionArg === 'text')
+            .map(([fieldArg]) => fieldArg)
+            .sort(compareSmartdataTopologyStrings);
+        const normalizedSearchableFields = [...searchableFields].sort(compareSmartdataTopologyStrings);
+        if (stableValue(indexedTextFields) !==
+            stableValue(normalizedSearchableFields)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Text index "${textIndexes[0].name}" must cover exactly the declared searchable fields.`);
+        }
+    }
+    if (searchableFields.length > 0 && textIndexes.length === 0) {
+        indexesByName.set(automaticTextIndexName, Object.freeze({
+            name: automaticTextIndexName,
+            key: Object.freeze(searchableFields.map((fieldArg) => Object.freeze([fieldArg, 'text']))),
+            options: Object.freeze({}),
+        }));
+    }
+    for (const identityField of identityFields) {
+        const hasIdentityIndex = [...indexesByName.values()].some((indexArg) => indexArg.options.unique === true &&
+            indexArg.key.length === 1 &&
+            indexArg.key[0][0] === identityField &&
+            indexArg.key[0][1] === 1);
+        if (!hasIdentityIndex) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Identity field "${identityField}" requires an explicit single-field ascending unique index.`);
+        }
+    }
+    const normalizedCore = {
+        ordinaryPersistence: ordinaryPolicyArg,
+        collectionName,
+        persistedFields: Object.freeze([...persistedFields]),
+        numericFields: Object.freeze([...numericFields]),
+        identityFields: Object.freeze([...identityFields]),
+        identityValueTypes: Object.freeze({ ...identityValueTypes }),
+        searchableFields: Object.freeze([...searchableFields]),
+        indexes: Object.freeze([...indexesByName.values()]),
+    };
+    return Object.freeze({
+        ...normalizedCore,
+        fingerprint: stableValue({
+            ordinaryPersistence: ordinaryPolicyArg ? {
+                idType: ordinaryPolicyArg.idType, timestamps: ordinaryPolicyArg.timestamps,
+            } : undefined,
+            collectionName,
+            persistedFields: [...persistedFields].sort(compareSmartdataTopologyStrings),
+            numericFields: [...numericFields].sort(compareSmartdataTopologyStrings),
+            identityFields: [...identityFields].sort(compareSmartdataTopologyStrings),
+            identityValueTypes,
+            searchableFields: [...searchableFields].sort(compareSmartdataTopologyStrings),
+            indexes: [...indexesByName.values()].sort((leftArg, rightArg) => compareSmartdataTopologyStrings(leftArg.name, rightArg.name)),
+        }),
+    });
+};
+const getOwnMetadataValue = (metadata, key) => {
+    if (!metadata || !Object.prototype.hasOwnProperty.call(metadata, key)) {
+        return undefined;
+    }
+    return metadata[key];
+};
+const mergeStringArrays = (...arrays) => {
+    const merged = [];
+    for (const array of arrays) {
+        if (!array) {
+            continue;
+        }
+        for (const item of array) {
+            if (!merged.includes(item)) {
+                merged.push(item);
+            }
+        }
+    }
+    return merged;
+};
+const mergeIdentityValueTypes = (...typeMapsArg) => {
+    const merged = {};
+    for (const typeMap of typeMapsArg) {
+        for (const [field, valueType] of Object.entries(typeMap || {})) {
+            const existing = merged[field];
+            if (existing && existing !== valueType) {
+                throw new SmartdataPersistenceError('invalid_configuration', `Identity field "${field}" has divergent inherited valueType declarations.`);
+            }
+            merged[field] = valueType;
+        }
+    }
+    return merged;
+};
+const mergeRegularIndexes = (...indexArrays) => {
+    const mergedMap = new Map();
+    for (const indexArray of indexArrays) {
+        if (!indexArray) {
+            continue;
+        }
+        for (const indexDef of indexArray) {
+            mergedMap.set(indexDef.field, {
+                field: indexDef.field,
+                options: { ...indexDef.options },
+            });
+        }
+    }
+    return [...mergedMap.values()];
+};
+const stableIndexValue = (valueArg) => {
+    if (Array.isArray(valueArg)) {
+        return `[${valueArg.map((entryArg) => stableIndexValue(entryArg)).join(',')}]`;
+    }
+    if (typeof valueArg === 'object' && valueArg !== null) {
+        return `{${Object.keys(valueArg)
+            .sort(compareSmartdataTopologyStrings)
+            .map((keyArg) => `${JSON.stringify(keyArg)}:${stableIndexValue(valueArg[keyArg])}`)
+            .join(',')}}`;
+    }
+    return JSON.stringify(valueArg);
+};
+const compoundIndexesEqual = (leftArg, rightArg) => {
+    const leftKeyEntries = Object.entries(leftArg.key);
+    const rightKeyEntries = Object.entries(rightArg.key);
+    return (stableIndexValue(leftKeyEntries) === stableIndexValue(rightKeyEntries) &&
+        stableIndexValue(leftArg.options || {}) ===
+            stableIndexValue(rightArg.options || {}));
+};
+const mergeCompoundIndexes = (...indexArrays) => {
+    const mergedMap = new Map();
+    for (const indexArray of indexArrays) {
+        if (!indexArray) {
+            continue;
+        }
+        for (const indexDefinition of indexArray) {
+            const existing = mergedMap.get(indexDefinition.name);
+            if (existing && !compoundIndexesEqual(existing, indexDefinition)) {
+                throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${indexDefinition.name}" has divergent inherited declarations.`);
+            }
+            if (!existing) {
+                mergedMap.set(indexDefinition.name, {
+                    ...indexDefinition,
+                    name: indexDefinition.name,
+                    key: { ...indexDefinition.key },
+                    options: { ...(indexDefinition.options || {}) },
+                });
+            }
+        }
+    }
+    return [...mergedMap.values()];
+};
+const mergeDecoratorMetadata = (...metadataArgs) => {
+    const merged = {};
+    merged.globalSaveableProperties = mergeStringArrays(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'globalSaveableProperties')));
+    merged.saveableProperties = mergeStringArrays(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'saveableProperties')));
+    merged.uniqueIndexes = mergeStringArrays(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'uniqueIndexes')));
+    merged.identityValueTypes = mergeIdentityValueTypes(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'identityValueTypes')));
+    merged.searchableFields = mergeStringArrays(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'searchableFields')));
+    merged.regularIndexes = mergeRegularIndexes(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'regularIndexes')));
+    merged.compoundIndexes = mergeCompoundIndexes(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'compoundIndexes')));
+    merged.namedIndexes = mergeCompoundIndexes(...metadataArgs.map((metadataArg) => getOwnMetadataValue(metadataArg, 'namedIndexes')));
+    const svDbOptions = {};
+    for (const metadataArg of metadataArgs) {
+        const options = getOwnMetadataValue(metadataArg, '_svDbOptions');
+        if (options) {
+            Object.assign(svDbOptions, options);
+        }
+    }
+    if (Object.keys(svDbOptions).length > 0) {
+        merged._svDbOptions = svDbOptions;
+    }
+    return merged;
+};
+const collectInheritedDecoratorMetadata = (constructor) => {
+    const metadataChain = [];
+    let proto = Object.getPrototypeOf(constructor.prototype);
+    while (proto && proto !== Object.prototype) {
+        const metadata = proto.constructor?.[Symbol.metadata];
+        if (metadata) {
+            metadataChain.unshift(metadata);
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return mergeDecoratorMetadata(...metadataChain);
+};
+/**
+ * Initialize prototype and constructor properties from TC39 decorator metadata.
+ * Shared by both Collection and managed decorators.
+ */
+function initializeDecoratorMetadata(constructor, metadata) {
+    const mergedMetadata = mergeDecoratorMetadata(collectInheritedDecoratorMetadata(constructor), metadata);
+    const proto = constructor.prototype;
+    const ctor = constructor;
+    // Prototype properties (instance-level)
+    if (mergedMetadata.globalSaveableProperties?.length) {
+        proto.globalSaveableProperties = [...mergedMetadata.globalSaveableProperties];
+    }
+    if (mergedMetadata.saveableProperties?.length) {
+        proto.saveableProperties = [...mergedMetadata.saveableProperties];
+    }
+    if (mergedMetadata.uniqueIndexes?.length) {
+        proto.uniqueIndexes = [...mergedMetadata.uniqueIndexes];
+    }
+    if (mergedMetadata.identityValueTypes) {
+        proto.identityValueTypes = { ...mergedMetadata.identityValueTypes };
+    }
+    if (mergedMetadata.regularIndexes?.length) {
+        proto.regularIndexes = [...mergedMetadata.regularIndexes];
+    }
+    if (mergedMetadata.compoundIndexes?.length) {
+        proto.compoundIndexes = [...mergedMetadata.compoundIndexes];
+        ctor.compoundIndexes = [...mergedMetadata.compoundIndexes];
+    }
+    // Constructor properties (static-level)
+    if (mergedMetadata.searchableFields?.length) {
+        ctor.searchableFields = [...mergedMetadata.searchableFields];
+    }
+    if (mergedMetadata._svDbOptions) {
+        ctor._svDbOptions = { ...mergedMetadata._svDbOptions };
+    }
+}
+const definedModelSchemaSymbol = Symbol.for('@push.rocks/smartdata.definedCollectionModelSchema');
+const schemaFromDecoratorMetadata = (constructorArg, collectionNameArg) => {
+    const ownMetadata = Object.prototype.hasOwnProperty.call(constructorArg, Symbol.metadata)
+        ? constructorArg[Symbol.metadata]
+        : undefined;
+    const metadata = mergeDecoratorMetadata(collectInheritedDecoratorMetadata(constructorArg), ownMetadata);
+    const persistedFields = [
+        ...new Set([
+            ...(metadata.saveableProperties || []),
+            ...(metadata.uniqueIndexes || []),
+            ...(metadata.regularIndexes || []).map((indexArg) => indexArg.field.split('.')[0]),
+            ...(metadata.compoundIndexes || []).flatMap((indexArg) => Object.keys(indexArg.key).map((fieldArg) => fieldArg.split('.')[0])),
+        ]),
+    ];
+    const numericFields = Object.entries(metadata._svDbOptions || {})
+        .filter(([, optionsArg]) => optionsArg?.numeric === true)
+        .map(([fieldArg]) => fieldArg);
+    const indexes = [];
+    for (const uniqueField of metadata.uniqueIndexes || []) {
+        indexes.push({
+            name: `${uniqueField}_1`,
+            key: { [uniqueField]: 1 },
+            options: { unique: true },
+        });
+    }
+    for (const regularIndex of metadata.regularIndexes || []) {
+        const rawOptions = { ...(regularIndex.options || {}) };
+        const explicitName = typeof rawOptions.name === 'string'
+            ? rawOptions.name
+            : `${regularIndex.field}_1`;
+        delete rawOptions.name;
+        indexes.push({
+            name: explicitName,
+            key: { [regularIndex.field]: 1 },
+            options: rawOptions,
+        });
+    }
+    for (const compoundIndexDefinition of metadata.compoundIndexes || []) {
+        const validatedDefinition = validateCompoundIndexDefinition(compoundIndexDefinition);
+        indexes.push({
+            name: validatedDefinition.name,
+            key: { ...validatedDefinition.key },
+            options: { ...(validatedDefinition.options || {}) },
+        });
+    }
+    indexes.push(...(metadata.namedIndexes || []));
+    return normalizeCollectionModelSchema({
+        collectionName: collectionNameArg,
+        persistedFields,
+        numericFields,
+        identityFields: metadata.uniqueIndexes || [],
+        searchableFields: metadata.searchableFields || [],
+        indexes,
+    }, true, metadata.identityValueTypes, getOrdinaryPersistencePolicy(constructorArg));
+};
+const installCollectionBinding = (constructorArg, dbResolverArg, schemaResolverArg) => {
+    const getCollection = (receiverArg) => {
+        const db = dbResolverArg(receiverArg);
+        if (!(db instanceof SmartdataDb)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Model "${constructorArg.name}" did not resolve a SmartdataDb.`);
+        }
+        const schema = schemaResolverArg();
+        if (schema.ordinaryPersistence !== getOrdinaryPersistencePolicy(constructorArg)) {
+            throw new SmartdataPersistenceError('invalid_configuration', 'Persistence policy must be installed before binding a programmatic model.');
+        }
+        return collectionFactory.getCollection(schema.collectionName, db, schema);
+    };
+    Object.defineProperty(constructorArg, collectionModelSchemaResolverSymbol, {
+        value: schemaResolverArg,
+        enumerable: false,
+        configurable: true,
+        writable: false,
+    });
+    constructorArg.className = constructorArg.name;
+    Object.defineProperty(constructorArg, 'collection', {
+        get() {
+            return getCollection(this);
+        },
+        enumerable: false,
+        configurable: true,
+    });
+    Object.defineProperty(constructorArg.prototype, 'collection', {
+        get() {
+            return getCollection(this);
+        },
+        enumerable: false,
+        configurable: true,
+    });
+    return constructorArg;
+};
+/**
+ * Programmatically declares and binds an ordinary SmartData model.
+ *
+ * Repeating an equivalent declaration is safe. Divergent declarations for
+ * the same constructor, database and collection fail before database work.
+ */
+export function defineCollectionModel(modelArg, dbArg, configArg) {
+    if (typeof modelArg !== 'function' ||
+        !(modelArg.prototype instanceof SmartDataDbDoc)) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'defineCollectionModel requires a SmartDataDbDoc constructor.');
+    }
+    const inheritedPrototype = Object.getPrototypeOf(modelArg.prototype);
+    const inheritedConstructor = Object.getPrototypeOf(modelArg);
+    const inheritedSchema = inheritedConstructor?.[definedModelSchemaSymbol];
+    const normalizedSchema = normalizeCollectionModelSchema({
+        ...configArg,
+        persistedFields: [
+            ...(inheritedPrototype?.saveableProperties || []),
+            ...(configArg.persistedFields || []),
+        ],
+        numericFields: [
+            ...(inheritedSchema?.numericFields || []),
+            ...(configArg.numericFields || []),
+        ],
+        identityFields: [
+            ...(inheritedSchema?.identityFields || []),
+            ...(configArg.identityFields || []),
+        ],
+        searchableFields: [
+            ...(inheritedSchema?.searchableFields || []),
+            ...(configArg.searchableFields || []),
+        ],
+        indexes: [
+            ...(inheritedSchema?.indexes || [])
+                .filter((indexArg) => indexArg.name !== automaticTextIndexName)
+                .map((indexArg) => ({
+                name: indexArg.name,
+                key: Object.fromEntries(indexArg.key),
+                options: { ...indexArg.options },
+            })),
+            ...(configArg.indexes || []),
+        ],
+    }, false, undefined, getOrdinaryPersistencePolicy(modelArg));
+    const existingOwnSchema = Object.prototype.hasOwnProperty.call(modelArg, definedModelSchemaSymbol)
+        ? modelArg[definedModelSchemaSymbol]
+        : undefined;
+    if (existingOwnSchema &&
+        (existingOwnSchema.fingerprint !== normalizedSchema.fingerprint ||
+            existingOwnSchema.ordinaryPersistence?.assertStoredDocument !==
+                normalizedSchema.ordinaryPersistence?.assertStoredDocument)) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Model "${modelArg.name}" already has a divergent collection schema.`);
+    }
+    const effectiveSchema = existingOwnSchema || normalizedSchema;
+    if (!existingOwnSchema) {
+        Object.defineProperty(modelArg, definedModelSchemaSymbol, {
+            value: effectiveSchema,
+            enumerable: false,
+            configurable: false,
+            writable: false,
+        });
+    }
+    modelArg.prototype.saveableProperties = [
+        ...effectiveSchema.persistedFields,
+    ];
+    modelArg.prototype.uniqueIndexes = [...effectiveSchema.identityFields];
+    modelArg.prototype.identityValueTypes = {
+        ...effectiveSchema.identityValueTypes,
+    };
+    modelArg.searchableFields = [
+        ...effectiveSchema.searchableFields,
+    ];
+    return installCollectionBinding(modelArg, () => (dbArg instanceof SmartdataDb ? dbArg : dbArg()), () => effectiveSchema);
+}
+const validateCompoundIndexDefinition = (definitionArg) => {
+    if (typeof definitionArg?.name !== 'string' ||
+        definitionArg.name.trim().length === 0) {
+        throw new SmartdataPersistenceError('invalid_configuration', 'A compound index requires a non-empty name.');
+    }
+    if (typeof definitionArg.key !== 'object' ||
+        definitionArg.key === null ||
+        Array.isArray(definitionArg.key) ||
+        Object.keys(definitionArg.key).length < 2) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${definitionArg.name}" requires at least two ordered fields.`);
+    }
+    for (const [field, direction] of Object.entries(definitionArg.key)) {
+        if (field.trim().length === 0 ||
+            field.startsWith('$') ||
+            field.includes('\0') ||
+            (direction !== 1 && direction !== -1)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${definitionArg.name}" has an invalid field or direction.`);
+        }
+    }
+    const options = { ...(definitionArg.options || {}) };
+    if ('name' in options) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${definitionArg.name}" must define its name outside options.`);
+    }
+    if ('unique' in options && typeof options.unique !== 'boolean') {
+        throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${definitionArg.name}" has a non-boolean unique option.`);
+    }
+    if ('sparse' in options && typeof options.sparse !== 'boolean') {
+        throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${definitionArg.name}" has a non-boolean sparse option.`);
+    }
+    if ('expireAfterSeconds' in options &&
+        (!Number.isFinite(options.expireAfterSeconds) ||
+            options.expireAfterSeconds < 0)) {
+        throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${definitionArg.name}" has an invalid expireAfterSeconds option.`);
+    }
+    return {
+        name: definitionArg.name,
+        key: { ...definitionArg.key },
+        options: { ...(definitionArg.options || {}) },
+    };
+};
+/**
+ * Declares a stable named compound index owned by a SmartData model.
+ */
+export function compoundIndex(definitionArg) {
+    const definition = validateCompoundIndexDefinition(definitionArg);
+    return function classDecorator(value, context) {
+        if (context.kind !== 'class') {
+            throw new Error('compoundIndex can only decorate classes');
+        }
+        const metadata = context.metadata;
+        if (!Object.prototype.hasOwnProperty.call(metadata, 'compoundIndexes')) {
+            metadata.compoundIndexes = [...(metadata.compoundIndexes || [])];
+        }
+        const ownCompoundIndexes = metadata.compoundIndexes;
+        const existing = ownCompoundIndexes.find((indexDefinition) => indexDefinition.name === definition.name);
+        if (existing && !compoundIndexesEqual(existing, definition)) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Compound index "${definition.name}" has divergent declarations.`);
+        }
+        if (!existing) {
+            ownCompoundIndexes.push(definition);
+        }
+        initializeDecoratorMetadata(value, context.metadata);
+        return value;
+    };
+}
+/** Declares an inherited named index without implicitly declaring persisted fields. */
+export function namedIndex(definitionArg) {
+    const requirePlainDataObject = (valueArg, keysArg) => {
+        if (!valueArg || Object.getPrototypeOf(valueArg) !== Object.prototype ||
+            Reflect.ownKeys(valueArg).some((keyArg) => typeof keyArg !== 'string' ||
+                (keysArg && !keysArg.includes(keyArg)) ||
+                !('value' in Object.getOwnPropertyDescriptor(valueArg, keyArg)))) {
+            throw new SmartdataPersistenceError('invalid_configuration', 'Invalid named index declaration.');
+        }
+    };
+    requirePlainDataObject(definitionArg, ['name', 'key', 'options']);
+    requirePlainDataObject(definitionArg.key);
+    if (definitionArg.options !== undefined)
+        requirePlainDataObject(definitionArg.options);
+    const schema = normalizeCollectionModelSchema({
+        collectionName: 'named_index_declaration',
+        persistedFields: [...new Set(Object.keys(definitionArg.key).map((pathArg) => pathArg.split('.')[0]))],
+        searchableFields: Object.entries(definitionArg.key)
+            .filter(([, directionArg]) => directionArg === 'text').map(([pathArg]) => pathArg),
+        indexes: [definitionArg],
+    });
+    // Share topology constraints too (reserved names, index widths, supported options).
+    getExpectedCollectionTopologyForSchema(schema);
+    const normalized = schema.indexes[0];
+    const definition = Object.freeze({
+        name: normalized.name,
+        key: Object.freeze(Object.fromEntries(normalized.key)),
+        options: normalized.options,
+    });
+    return function classDecorator(value, context) {
+        if (context.kind !== 'class') {
+            throw new SmartdataPersistenceError('invalid_configuration', 'namedIndex can only decorate classes.');
+        }
+        const metadata = context.metadata;
+        metadata.namedIndexes = mergeCompoundIndexes(metadata.namedIndexes, [definition]);
+        return value;
+    };
+}
+/**
+ * This is a decorator that will tell the decorated class what dbTable to use
+ * @param dbArg
+ */
+export function Collection(dbArg, optionsArg) {
+    return function classDecorator(value, context) {
+        if (context.kind !== 'class') {
+            throw new Error('Collection can only decorate classes');
+        }
+        const constructor = value;
+        initializeDecoratorMetadata(constructor, context.metadata);
+        const collectionName = normalizeCollectionName(optionsArg?.collectionName ?? constructor.name);
+        return installCollectionBinding(constructor, () => (dbArg instanceof SmartdataDb ? dbArg : dbArg()), () => {
+            return schemaFromDecoratorMetadata(constructor, collectionName);
+        });
+    };
+}
+export const setDefaultManagerForDoc = (managerArg, dbDocArg) => {
+    dbDocArg.prototype.defaultManager = managerArg;
+    return dbDocArg;
+};
+/**
+ * This is a decorator that will tell the decorated class what dbTable to use
+ * @param dbArg
+ */
+export function managed(managerOrOptionsArg, optionsArg) {
+    const firstArgumentIsOptions = typeof managerOrOptionsArg === 'object' &&
+        managerOrOptionsArg !== null &&
+        !('db' in managerOrOptionsArg) &&
+        'collectionName' in managerOrOptionsArg &&
+        optionsArg === undefined;
+    const managerArg = firstArgumentIsOptions
+        ? undefined
+        : managerOrOptionsArg;
+    const bindingOptions = firstArgumentIsOptions
+        ? managerOrOptionsArg
+        : optionsArg;
+    return function classDecorator(value, context) {
+        if (context.kind !== 'class') {
+            throw new Error('managed can only decorate classes');
+        }
+        const constructor = value;
+        initializeDecoratorMetadata(constructor, context.metadata);
+        // Resolution helpers (capture managerArg via closure)
+        const getManager = (receiverArg) => {
+            if (!managerArg) {
+                if (typeof receiverArg === 'function') {
+                    return receiverArg.prototype.defaultManager;
+                }
+                return (receiverArg
+                    ?.defaultManager ?? constructor.prototype.defaultManager);
+            }
+            if (typeof managerArg !== 'function' && managerArg.db) {
+                return managerArg;
+            }
+            return managerArg();
+        };
+        const collectionName = normalizeCollectionName(bindingOptions?.collectionName ?? constructor.name);
+        installCollectionBinding(constructor, (receiverArg) => getManager(receiverArg).db, () => {
+            return schemaFromDecoratorMetadata(constructor, collectionName);
+        });
+        Object.defineProperty(constructor, 'manager', {
+            get() { return getManager(this); },
+            enumerable: false,
+            configurable: true
+        });
+        Object.defineProperty(constructor.prototype, 'manager', {
+            get() { return getManager(this); },
+            enumerable: false,
+            configurable: true
+        });
+        return constructor;
+    };
+}
+/**
+ * @dpecrecated use @managed instead
+ */
+export const Manager = managed;
+export class SmartdataCollection {
+    /**
+     * the collection that is used
+     */
+    mongoDbCollection;
+    objectValidation = null;
+    collectionName;
+    smartdataDb;
+    uniqueIndexes = [];
+    regularIndexes = [];
+    compoundIndexes = [];
+    modelSchema;
+    initializationPromise;
+    initializationGeneration = 0;
+    initialized = false;
+    constructor(classNameArg, smartDataDbArg) {
+        // tell the collection where it belongs
+        this.collectionName = classNameArg;
+        this.smartdataDb = smartDataDbArg;
+        // tell the db class about it (important since Db uses different systems under the hood)
+        this.smartdataDb.addCollection(this);
+    }
+    runWithOrdinarySession(sessionArg, ordinaryWriteArg, operationArg) {
+        return runWithOrdinarySmartdataSession(sessionArg, this.smartdataDb, {
+            ordinaryWrite: ordinaryWriteArg,
+            prepared: this.isInitializedForCurrentDatabase(),
+            preparationMessage: `Initialize collection "${this.collectionName}" before using an owned SmartData session.`,
+        }, operationArg);
+    }
+    /**
+     * Returns the deep-frozen normalized model schema bound to this collection,
+     * or undefined when no model schema has been bound yet. The schema exposes
+     * declared fields and named index definitions only, never raw driver access.
+     */
+    getBoundModelSchema() {
+        return this.modelSchema;
+    }
+    bindModelSchema(schemaArg) {
+        if (schemaArg.collectionName !== this.collectionName ||
+            (this.modelSchema &&
+                (this.modelSchema.fingerprint !== schemaArg.fingerprint ||
+                    this.modelSchema.ordinaryPersistence?.assertStoredDocument !==
+                        schemaArg.ordinaryPersistence?.assertStoredDocument))) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Collection "${this.collectionName}" cannot bind a divergent model schema.`);
+        }
+        if (!this.modelSchema) {
+            this.modelSchema = schemaArg;
+            this.initializationGeneration++;
+            this.initialized = false;
+            this.initializationPromise = undefined;
+        }
+    }
+    resetForDatabaseReconnect() {
+        this.initializationGeneration++;
+        delete this
+            .mongoDbCollection;
+        this.initialized = false;
+        this.initializationPromise = undefined;
+        this.uniqueIndexes = [];
+        this.regularIndexes = [];
+        this.compoundIndexes = [];
+        notifyCollectionReconnect(this);
+    }
+    /**
+     * makes sure a collection exists within MongoDb that maps to the SmartdataCollection
+     */
+    async init() {
+        if (this.initialized) {
+            return;
+        }
+        if (!this.initializationPromise) {
+            const generation = this.initializationGeneration;
+            const targetDb = this.smartdataDb.mongoDb;
+            let initializationPromise;
+            initializationPromise = this.initializeOnce(targetDb, generation)
+                .then(() => {
+                if (this.initializationGeneration === generation
+                    && this.smartdataDb.mongoDb === targetDb) {
+                    this.initialized = true;
+                }
+            })
+                .catch((errorArg) => {
+                const isCurrentGeneration = this.initializationGeneration === generation
+                    && this.smartdataDb.mongoDb === targetDb;
+                if (this.initializationPromise === initializationPromise) {
+                    this.initializationPromise = undefined;
+                    if (isCurrentGeneration) {
+                        this.initialized = false;
+                    }
+                }
+                if (isCurrentGeneration) {
+                    throw errorArg;
+                }
+            })
+                .finally(() => {
+                if (this.initializationPromise === initializationPromise) {
+                    this.initializationPromise = undefined;
+                }
+            });
+            this.initializationPromise = initializationPromise;
+        }
+        const initializationPromise = this.initializationPromise;
+        await initializationPromise;
+        if (!this.initialized) {
+            await this.init();
+        }
+    }
+    async ensureInitialized() {
+        await this.init();
+    }
+    /** Explicit bounded preparation of the bound model's exact declared topology. */
+    async prepareCollection(opts) {
+        const budget = new CollectionPreparationBudget(opts);
+        const generation = this.initializationGeneration;
+        const targetDb = this.smartdataDb.mongoDb;
+        const assertCurrent = () => {
+            budget.check();
+            if (this.initializationGeneration !== generation || this.smartdataDb.mongoDb !== targetDb ||
+                this.smartdataDb.status !== 'connected') {
+                throw new SmartdataPersistenceError('unsupported_operation', 'SmartData connection changed during collection preparation.');
+            }
+        };
+        try {
+            if (!this.modelSchema) {
+                throw new SmartdataPersistenceError('invalid_configuration', 'Collection preparation requires a bound model schema.');
+            }
+            // The caller owns its waiting deadline, not the preceding operation.
+            while (this.initializationPromise) {
+                await budget.waitFor(this.initializationPromise);
+                assertCurrent();
+            }
+            assertCurrent();
+            this.initialized = false;
+            const schema = this.modelSchema;
+            const preparation = (async () => {
+                const outcome = await this.smartdataDb[collectionTopologyDbInspectionSymbol](async (dbArg) => {
+                    try {
+                        return { collection: await prepareBoundCollection(dbArg, schema, budget, assertCurrent) };
+                    }
+                    catch (errorArg) {
+                        // Let the connection owner check its epoch before publishing either outcome.
+                        return { error: errorArg };
+                    }
+                });
+                assertCurrent();
+                if ('error' in outcome)
+                    throw outcome.error;
+                this.mongoDbCollection = outcome.collection;
+                this.publishModelIndexes(schema);
+                this.initialized = true;
+            })();
+            this.initializationPromise = preparation;
+            try {
+                await preparation;
+            }
+            finally {
+                if (this.initializationPromise === preparation)
+                    this.initializationPromise = undefined;
+            }
+        }
+        catch (errorArg) {
+            budget.check();
+            throw errorArg;
+        }
+        finally {
+            budget.close();
+        }
+    }
+    isInitializedForCurrentDatabase() {
+        return this.initialized && Boolean(this.mongoDbCollection);
+    }
+    async initializeOnce(targetDbArg, generationArg) {
+        let targetCollection = this.mongoDbCollection;
+        if (!targetCollection) {
+            const wantedCollection = await targetDbArg
+                .listCollections({ name: this.collectionName }, { nameOnly: true })
+                .hasNext();
+            if (!wantedCollection) {
+                try {
+                    await targetDbArg.createCollection(this.collectionName);
+                }
+                catch (errorArg) {
+                    const mongoError = errorArg;
+                    if (mongoError.code !== 48) {
+                        throw errorArg;
+                    }
+                }
+                logger.log('info', `Successfully initiated Collection ${this.collectionName}`);
+            }
+            targetCollection = targetDbArg.collection(this.collectionName);
+        }
+        if (this.initializationGeneration !== generationArg
+            || this.smartdataDb.mongoDb !== targetDbArg) {
+            return;
+        }
+        this.mongoDbCollection = targetCollection;
+        const modelSchema = this.modelSchema;
+        if (!modelSchema) {
+            return;
+        }
+        for (const index of modelSchema.indexes) {
+            await targetCollection.createIndex(Object.fromEntries(index.key), {
+                ...index.options,
+                name: index.name,
+            });
+        }
+        const actualIndexes = await targetCollection.listIndexes().toArray();
+        for (const expected of modelSchema.indexes) {
+            const actual = actualIndexes.find((indexArg) => indexArg.name === expected.name);
+            if (!actual) {
+                throw new SmartdataPersistenceError('invalid_configuration', `Index "${expected.name}" was not created on "${this.collectionName}".`);
+            }
+            const actualKeyEntries = Object.entries(actual.key || {});
+            const expectedTextFields = expected.key
+                .filter(([, directionArg]) => directionArg === 'text')
+                .map(([fieldArg]) => fieldArg);
+            const canonicalExpectedKey = [];
+            let textMarkerAdded = false;
+            for (const [field, direction] of expected.key) {
+                if (direction === 'text') {
+                    if (!textMarkerAdded) {
+                        canonicalExpectedKey.push(['_fts', 'text'], ['_ftsx', 1]);
+                        textMarkerAdded = true;
+                    }
+                }
+                else {
+                    canonicalExpectedKey.push([field, direction]);
+                }
+            }
+            const actualTextFields = Object.keys(actual.weights || {}).sort(compareSmartdataTopologyStrings);
+            if (stableValue(actualKeyEntries) !==
+                stableValue(canonicalExpectedKey) ||
+                stableValue(actualTextFields) !==
+                    stableValue([...expectedTextFields].sort(compareSmartdataTopologyStrings))) {
+                throw new SmartdataPersistenceError('invalid_configuration', `Index "${expected.name}" has an unexpected key specification.`);
+            }
+            for (const booleanOption of ['unique', 'sparse']) {
+                if (Boolean(actual[booleanOption]) !==
+                    Boolean(expected.options[booleanOption])) {
+                    throw new SmartdataPersistenceError('invalid_configuration', `Index "${expected.name}" has an unexpected "${booleanOption}" option.`);
+                }
+            }
+            if (expected.options.expireAfterSeconds !== undefined &&
+                actual.expireAfterSeconds !==
+                    expected.options.expireAfterSeconds) {
+                throw new SmartdataPersistenceError('invalid_configuration', `Index "${expected.name}" has an unexpected expireAfterSeconds option.`);
+            }
+        }
+        if (this.initializationGeneration !== generationArg
+            || this.smartdataDb.mongoDb !== targetDbArg
+            || this.mongoDbCollection !== targetCollection) {
+            return;
+        }
+        this.publishModelIndexes(modelSchema);
+    }
+    publishModelIndexes(modelSchema) {
+        this.uniqueIndexes = modelSchema.indexes
+            .filter((indexArg) => indexArg.options.unique)
+            .filter((indexArg) => indexArg.key.length === 1 && indexArg.key[0][1] === 1)
+            .map((indexArg) => indexArg.key[0][0]);
+        this.regularIndexes = modelSchema.indexes
+            .filter((indexArg) => indexArg.key.length === 1 &&
+            indexArg.key[0][1] === 1)
+            .map((indexArg) => ({
+            field: indexArg.key[0][0],
+            options: { ...indexArg.options },
+        }));
+        this.compoundIndexes = modelSchema.indexes
+            .filter((indexArg) => indexArg.key.length >= 2 &&
+            indexArg.key.every(([, directionArg]) => directionArg !== 'text'))
+            .map((indexArg) => ({
+            name: indexArg.name,
+            key: Object.fromEntries(indexArg.key),
+            options: { ...indexArg.options },
+        }));
+    }
+    /**
+     * mark unique index
+     */
+    async markUniqueIndexes(keyArrayArg = []) {
+        for (const key of keyArrayArg) {
+            if (!this.uniqueIndexes.includes(key)) {
+                try {
+                    await this.mongoDbCollection.createIndex({ [key]: 1 }, {
+                        unique: true,
+                        name: `${key}_1`,
+                    });
+                    this.uniqueIndexes.push(key);
+                }
+                catch (err) {
+                    const errorCode = err?.code || err?.codeName || 'unknown';
+                    const errorMessage = err?.message || String(err);
+                    logger.log('error', `Failed to create unique index on field "${key}" in collection "${this.collectionName}". ` +
+                        `MongoDB error [${errorCode}]: ${errorMessage}. ` +
+                        `Uniqueness constraint on "${key}" is NOT enforced.`);
+                    if (errorCode === 11000 || errorCode === 'DuplicateKey' || String(errorMessage).includes('E11000')) {
+                        await this.logDuplicatesForField(key);
+                    }
+                    throw err;
+                }
+            }
+        }
+    }
+    /**
+     * creates regular indexes for the collection
+     */
+    async createRegularIndexes(indexesArg = []) {
+        for (const indexDef of indexesArg) {
+            // Check if we've already created this index
+            const indexKey = indexDef.field;
+            if (!this.regularIndexes.some(i => i.field === indexKey)) {
+                try {
+                    await this.mongoDbCollection.createIndex({ [indexDef.field]: 1 }, // Simple single-field index
+                    indexDef.options);
+                    this.regularIndexes.push(indexDef);
+                }
+                catch (err) {
+                    const errorCode = err?.code || err?.codeName || 'unknown';
+                    const errorMessage = err?.message || String(err);
+                    logger.log('warn', `Failed to create index on field "${indexKey}" in collection "${this.collectionName}". ` +
+                        `MongoDB error [${errorCode}]: ${errorMessage}.`);
+                    if (indexDef.options?.unique &&
+                        (errorCode === 11000 || errorCode === 'DuplicateKey' || String(errorMessage).includes('E11000'))) {
+                        await this.logDuplicatesForField(indexKey);
+                    }
+                    throw err;
+                }
+            }
+        }
+    }
+    /**
+     * Logs duplicate values for a field to help diagnose unique index creation failures.
+     */
+    async logDuplicatesForField(field) {
+        try {
+            const pipeline = [
+                { $group: { _id: `$${field}`, count: { $sum: 1 }, ids: { $push: '$_id' } } },
+                { $match: { count: { $gt: 1 } } },
+                { $limit: 5 },
+            ];
+            const duplicates = await this.mongoDbCollection.aggregate(pipeline).toArray();
+            if (duplicates.length > 0) {
+                for (const dup of duplicates) {
+                    logger.log('warn', `Duplicate values for "${field}" in "${this.collectionName}": ` +
+                        `value=${JSON.stringify(dup._id)} appears ${dup.count} times ` +
+                        `(document _ids: ${JSON.stringify(dup.ids.slice(0, 5))})`);
+                }
+                logger.log('warn', `Unique index on "${field}" in "${this.collectionName}" was NOT created. ` +
+                    `Resolve duplicates and restart to enforce uniqueness.`);
+            }
+        }
+        catch (aggErr) {
+            logger.log('warn', `Could not identify duplicate documents for field "${field}" in "${this.collectionName}": ${aggErr?.message || String(aggErr)}`);
+        }
+    }
+    /**
+     * adds a validation function that all newly inserted and updated objects have to pass
+     */
+    addDocValidation(funcArg) {
+        this.objectValidation = funcArg;
+    }
+    /**
+     * finds an object in the DbCollection
+     */
+    async findOne(filterObject, opts) {
+        return this.runWithOrdinarySession(opts?.session, false, async (rawSessionArg) => {
+            await this.init();
+            return this.mongoDbCollection.findOne(filterObject, {
+                projection: opts?.projection,
+                maxTimeMS: opts?.maxTimeMS,
+                session: rawSessionArg,
+            });
+        });
+    }
+    async getCursor(filterObjectArg, dbDocArg, opts) {
+        await this.init();
+        const cursor = this.mongoDbCollection.find(filterObjectArg, { session: opts?.session });
+        return new SmartdataDbCursor(cursor, dbDocArg);
+    }
+    /**
+     * finds an object in the DbCollection
+     */
+    async findAll(filterObject, opts) {
+        return this.runWithOrdinarySession(opts?.session, false, async (rawSessionArg) => {
+            await this.init();
+            const cursor = this.mongoDbCollection.find(filterObject, {
+                session: rawSessionArg,
+            });
+            let result;
+            let operationFailed = false;
+            try {
+                result = await cursor.toArray();
+            }
+            catch (errorArg) {
+                operationFailed = true;
+                throw errorArg;
+            }
+            finally {
+                try {
+                    await cursor.close();
+                }
+                catch (closeError) {
+                    if (!operationFailed) {
+                        throw closeError;
+                    }
+                }
+            }
+            // In-memory check for duplicate _id values (should never happen)
+            if (result.length > 0) {
+                const idSet = new Set();
+                const duplicateIds = [];
+                for (const doc of result) {
+                    const idStr = String(doc._id);
+                    if (idSet.has(idStr)) {
+                        duplicateIds.push(idStr);
+                    }
+                    else {
+                        idSet.add(idStr);
+                    }
+                }
+                if (duplicateIds.length > 0) {
+                    logger.log('error', `Integrity issue in "${this.collectionName}": found ${duplicateIds.length} duplicate _id values ` +
+                        `in findAll results: [${duplicateIds.slice(0, 5).join(', ')}]. This should never happen.`);
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * Watches the collection, returning a SmartdataDbWatcher with RxJS and EventEmitter support.
+     * @param filterObject match filter for change stream
+     * @param opts optional MongoDB ChangeStreamOptions & { bufferTimeMs } to buffer events
+     * @param smartdataDbDocArg document class for instance creation
+     */
+    async watch(filterObject, opts = {}, smartdataDbDocArg) {
+        if ('capabilities' in this.smartdataDb &&
+            this.smartdataDb.capabilities.changeStreams === 'unsupported') {
+            throw new LosslessClientError('unsupported_capability', 'Change streams are unsupported by this backend.');
+        }
+        await this.init();
+        // Extract bufferTimeMs from options
+        const { bufferTimeMs, fullDocument, ...otherOptions } = opts || {};
+        // Determine fullDocument behavior: default to 'updateLookup'
+        const changeStreamOptions = {
+            ...otherOptions,
+            fullDocument: fullDocument === undefined
+                ? 'updateLookup'
+                : fullDocument === true
+                    ? 'updateLookup'
+                    : fullDocument,
+        };
+        // Build pipeline with match if provided
+        const pipeline = filterObject ? [{ $match: filterObject }] : [];
+        const changeStream = this.mongoDbCollection.watch(pipeline, changeStreamOptions);
+        const smartdataWatcher = new SmartdataDbWatcher(changeStream, smartdataDbDocArg, { bufferTimeMs });
+        await smartdataWatcher.readyDeferred.promise;
+        return smartdataWatcher;
+    }
+    /**
+     * create an object in the database
+     */
+    prepareOrdinaryInsert(documentArg) {
+        const policy = this.modelSchema?.ordinaryPersistence;
+        if (!policy)
+            return documentArg;
+        if (policy.idType === 'objectId' && !Object.prototype.hasOwnProperty.call(documentArg, '_id')) {
+            documentArg = { ...documentArg, _id: new plugins.mongodb.ObjectId() };
+        }
+        return validateOrdinaryStoredDocument(documentArg, policy, this.modelSchema.persistedFields);
+    }
+    async insert(dbDocArg, opts) {
+        const preparedObject = this.modelSchema?.ordinaryPersistence
+            ? this.prepareOrdinaryInsert(await dbDocArg.createSavableObject()) : undefined;
+        return this.runWithOrdinarySession(opts?.session, true, async (rawSessionArg) => {
+            await this.init();
+            await this.checkDoc(dbDocArg);
+            await this.markUniqueIndexes(dbDocArg.uniqueIndexes);
+            // Create regular indexes if available
+            if (dbDocArg.regularIndexes && dbDocArg.regularIndexes.length > 0) {
+                await this.createRegularIndexes(dbDocArg.regularIndexes);
+            }
+            const saveableObject = preparedObject ?? await dbDocArg.createSavableObject();
+            try {
+                return await this.mongoDbCollection.insertOne(saveableObject, {
+                    session: rawSessionArg,
+                });
+            }
+            catch (err) {
+                return normalizeOrdinaryPersistenceError(err, `Insert conflicts with a unique index in collection "${this.collectionName}".`);
+            }
+        });
+    }
+    /**
+     * Executes a bounded grouped-totals aggregation over already-validated
+     * stages and never exposes the aggregation cursor. Prefer the validated
+     * static `SmartDataDbDoc.getGroupedTotals()`, which owns input validation
+     * before this raw persistence boundary.
+     */
+    async aggregateGroupedTotals(matchArg, groupArg, limitArg, opts) {
+        opts?.signal?.throwIfAborted();
+        return this.runWithOrdinarySession(opts?.session, false, async (rawSessionArg) => {
+            await this.init();
+            const pipeline = [];
+            if (matchArg && Object.keys(matchArg).length > 0) {
+                pipeline.push({ $match: matchArg });
+            }
+            pipeline.push({ $group: groupArg });
+            pipeline.push({ $limit: limitArg });
+            opts?.signal?.throwIfAborted();
+            const cursor = this.mongoDbCollection.aggregate(pipeline, {
+                session: rawSessionArg,
+                ...(opts?.timeoutMS !== undefined ? { timeoutMS: opts.timeoutMS, timeoutMode: 'cursorLifetime' } : {}),
+                signal: opts?.signal,
+                ...(opts?.maxTimeMS !== undefined
+                    ? { maxTimeMS: opts.maxTimeMS }
+                    : {}),
+            });
+            return runCursorOperation(cursor, (cursorArg) => cursorArg.toArray(), opts?.signal);
+        });
+    }
+    async insertMany(dbDocsArg, opts) {
+        if (!Array.isArray(dbDocsArg) || dbDocsArg.length === 0) {
+            throw new SmartdataPersistenceError('invalid_argument', `insertMany requires a non-empty document batch for collection "${this.collectionName}".`);
+        }
+        const preparedObjects = this.modelSchema?.ordinaryPersistence ? [] : undefined;
+        if (preparedObjects) {
+            for (const dbDocArg of dbDocsArg) {
+                preparedObjects.push(this.prepareOrdinaryInsert(await dbDocArg.createSavableObject()));
+            }
+        }
+        return this.runWithOrdinarySession(opts?.session, true, async (rawSessionArg) => {
+            await this.init();
+            for (const dbDocArg of dbDocsArg) {
+                await this.checkDoc(dbDocArg);
+            }
+            const firstDocument = dbDocsArg[0];
+            await this.markUniqueIndexes(firstDocument.uniqueIndexes);
+            if (firstDocument.regularIndexes
+                && firstDocument.regularIndexes.length > 0) {
+                await this.createRegularIndexes(firstDocument.regularIndexes);
+            }
+            const saveableObjects = preparedObjects ?? [];
+            if (!preparedObjects) {
+                for (const dbDocArg of dbDocsArg) {
+                    saveableObjects.push(await dbDocArg.createSavableObject());
+                }
+            }
+            try {
+                return await this.mongoDbCollection.insertMany(saveableObjects, {
+                    session: rawSessionArg,
+                    ordered: opts?.ordered !== false,
+                });
+            }
+            catch (err) {
+                return normalizeOrdinaryPersistenceError(err, `Insert conflicts with a unique index in collection "${this.collectionName}".`);
+            }
+        });
+    }
+    /** Model.insertManyIfAbsent owns identity and new-instance validation. */
+    async insertManyIfAbsent(documentsArg, identityFieldArg, optsArg) {
+        const prepared = [];
+        let bytes = 0;
+        // Validate the entire batch before any write, including opted-in whole
+        // stored-document policies and collection-level object validation.
+        for (const document of documentsArg) {
+            await this.checkDoc(document);
+            const stored = this.prepareOrdinaryInsert(await document.createSavableObject());
+            const bson = plugins.mongodb.BSON.serialize(stored);
+            bytes += bson.byteLength;
+            if (bytes > 16 * 1024 * 1024) {
+                throw new SmartdataPersistenceError('invalid_argument', 'insertManyIfAbsent accepts at most 16 MiB of serialized documents.');
+            }
+            prepared.push(plugins.mongodb.BSON.deserialize(bson));
+        }
+        return this.runWithOrdinarySession(optsArg.session, true, async (rawSessionArg) => {
+            await this.init();
+            const first = documentsArg[0];
+            await this.markUniqueIndexes(first.uniqueIndexes);
+            await this.createRegularIndexes(first.regularIndexes || []);
+            try {
+                const result = await this.mongoDbCollection.bulkWrite(prepared.map((document) => ({
+                    updateOne: {
+                        filter: { [identityFieldArg]: document[identityFieldArg] },
+                        update: { $setOnInsert: document },
+                        upsert: true,
+                    },
+                })), { ordered: false, session: rawSessionArg, timeoutMS: optsArg.timeoutMS });
+                if (result.upsertedCount + result.matchedCount !== prepared.length) {
+                    throw new SmartdataPersistenceError('unsupported_operation', 'insertManyIfAbsent requires an acknowledged result for every identity.');
+                }
+                return { insertedCount: result.upsertedCount, matchedCount: result.matchedCount };
+            }
+            catch (errorArg) {
+                return normalizeOrdinaryPersistenceError(errorArg, `Insert conflicts with a unique index in collection "${this.collectionName}".`);
+            }
+        });
+    }
+    /**
+     * inserts object into the DbCollection
+     */
+    async update(dbDocArg, opts) {
+        if (this.modelSchema?.ordinaryPersistence) {
+            throw new SmartdataPersistenceError('unsupported_operation', 'Validated ordinary models require a transactional postimage update.');
+        }
+        return this.runWithOrdinarySession(opts?.session, true, async (rawSessionArg) => {
+            await this.init();
+            await this.checkDoc(dbDocArg);
+            await this.markUniqueIndexes(dbDocArg.uniqueIndexes);
+            if (dbDocArg.regularIndexes && dbDocArg.regularIndexes.length > 0) {
+                await this.createRegularIndexes(dbDocArg.regularIndexes);
+            }
+            const identifiableObject = await dbDocArg.createIdentifiableObject();
+            this.assertConstrainingIdentifiableObject(identifiableObject, 'update');
+            const saveableObject = await dbDocArg.createSavableObject();
+            const updateableObject = {};
+            for (const key of Object.keys(saveableObject)) {
+                if (identifiableObject[key]) {
+                    continue;
+                }
+                updateableObject[key] = saveableObject[key];
+            }
+            try {
+                return await this.mongoDbCollection.updateOne(identifiableObject, { $set: updateableObject }, { upsert: true, session: rawSessionArg });
+            }
+            catch (errorArg) {
+                return normalizeOrdinaryPersistenceError(errorArg, `Update conflicts with a unique index in collection "${this.collectionName}".`);
+            }
+        });
+    }
+    async delete(dbDocArg, opts) {
+        return this.runWithOrdinarySession(opts?.session, true, async (rawSessionArg) => {
+            await this.init();
+            await this.checkDoc(dbDocArg);
+            const identifiableObject = await dbDocArg.createIdentifiableObject();
+            this.assertConstrainingIdentifiableObject(identifiableObject, 'delete');
+            return this.mongoDbCollection.deleteOne(identifiableObject, {
+                session: rawSessionArg,
+            });
+        });
+    }
+    /**
+     * Rejects instance-level document targeting when the model declares no
+     * identity fields. An empty identity filter would otherwise address an
+     * arbitrary document in the collection.
+     */
+    assertConstrainingIdentifiableObject(identifiableObjectArg, operationLabelArg) {
+        if (Object.keys(identifiableObjectArg).length === 0) {
+            throw new SmartdataPersistenceError('invalid_configuration', `Instance ${operationLabelArg} on collection "${this.collectionName}" requires declared identity fields; without them the operation would target an arbitrary document.`);
+        }
+    }
+    async getCount(filterObject, opts) {
+        if (opts?.hint !== undefined && (typeof opts.hint !== 'string' ||
+            (opts.hint !== '_id_' && !this.modelSchema?.indexes.some((indexArg) => indexArg.name === opts.hint)))) {
+            throw new SmartdataPersistenceError('invalid_argument', 'Query hint must name an index declared by this model or the built-in _id_ index.');
+        }
+        return this.runWithOrdinarySession(opts?.session, false, async (rawSessionArg) => {
+            await this.init();
+            opts?.signal?.throwIfAborted();
+            const pipeline = [{ $match: filterObject }];
+            if (opts?.limit !== undefined) {
+                pipeline.push({ $limit: opts.limit });
+            }
+            pipeline.push({ $count: 'count' });
+            const cursor = this.mongoDbCollection.aggregate(pipeline, {
+                hint: opts?.hint,
+                maxTimeMS: opts?.maxTimeMS,
+                timeoutMS: opts?.timeoutMS,
+                signal: opts?.signal,
+                session: rawSessionArg,
+            });
+            return runCursorOperation(cursor, async (cursorArg) => (await cursorArg.next())?.count ?? 0, opts?.signal);
+        });
+    }
+    async getIndexInfo() {
+        await this.init();
+        const indexes = await this.mongoDbCollection.listIndexes().toArray();
+        return indexes.map((indexArg) => {
+            let fields;
+            if (indexArg.key._fts === 'text') {
+                const weights = typeof indexArg.weights === 'object' &&
+                    indexArg.weights !== null &&
+                    !Array.isArray(indexArg.weights)
+                    ? indexArg.weights
+                    : {};
+                fields = Object.keys(weights).map((path) => ({
+                    path,
+                    direction: 'text',
+                }));
+            }
+            else {
+                fields = Object.entries(indexArg.key).map(([path, direction]) => {
+                    if (direction !== 1 && direction !== -1) {
+                        throw new SmartdataPersistenceError('unsupported_operation', `Index "${indexArg.name}" uses an unsupported direction.`);
+                    }
+                    return {
+                        path,
+                        direction,
+                    };
+                });
+            }
+            return {
+                name: indexArg.name,
+                fields,
+                unique: indexArg.unique === true,
+                sparse: indexArg.sparse === true,
+                expireAfterSeconds: typeof indexArg.expireAfterSeconds === 'number'
+                    ? indexArg.expireAfterSeconds
+                    : undefined,
+            };
+        });
+    }
+    /**
+     * Runs an integrity check on the collection.
+     * Compares estimated vs actual document count and checks for duplicates on unique index fields.
+     */
+    async checkCollectionIntegrity() {
+        await this.init();
+        const result = {
+            ok: true,
+            estimatedCount: 0,
+            actualCount: 0,
+            duplicateFields: [],
+        };
+        try {
+            result.estimatedCount = await this.mongoDbCollection.estimatedDocumentCount();
+            result.actualCount = await this.mongoDbCollection.countDocuments({});
+            if (result.estimatedCount !== result.actualCount) {
+                result.ok = false;
+                logger.log('warn', `Integrity check on "${this.collectionName}": estimatedDocumentCount=${result.estimatedCount} ` +
+                    `but countDocuments=${result.actualCount}. Possible data inconsistency.`);
+            }
+            // Check for duplicates on each tracked unique index field
+            for (const field of this.uniqueIndexes) {
+                try {
+                    const pipeline = [
+                        { $group: { _id: `$${field}`, count: { $sum: 1 } } },
+                        { $match: { count: { $gt: 1 } } },
+                        { $count: 'total' },
+                    ];
+                    const countResult = await this.mongoDbCollection.aggregate(pipeline).toArray();
+                    const dupCount = countResult[0]?.total || 0;
+                    if (dupCount > 0) {
+                        result.ok = false;
+                        result.duplicateFields.push({ field, duplicateValues: dupCount });
+                        logger.log('warn', `Integrity check on "${this.collectionName}": field "${field}" has ${dupCount} values with duplicates ` +
+                            `despite being marked as unique.`);
+                    }
+                }
+                catch (fieldErr) {
+                    logger.log('warn', `Integrity check: could not verify uniqueness of "${field}" in "${this.collectionName}": ${fieldErr?.message || String(fieldErr)}`);
+                }
+            }
+        }
+        catch (err) {
+            result.ok = false;
+            logger.log('error', `Integrity check failed for "${this.collectionName}": ${err?.message || String(err)}`);
+        }
+        return result;
+    }
+    /**
+     * checks a Doc for constraints
+     * if this.objectValidation is not set it passes.
+     */
+    checkDoc(docArg) {
+        const done = plugins.smartpromise.defer();
+        let validationResult = true;
+        if (this.objectValidation) {
+            validationResult = this.objectValidation(docArg);
+        }
+        if (validationResult) {
+            done.resolve();
+        }
+        else {
+            done.reject('validation of object did not pass');
+        }
+        return done.promise;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.collection.js","sourceRoot":"","sources":["../../ts/nosqldb/classes.collection.ts"],"names":[],"mappings":"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"}