@brightchain/db 0.20.0

package/src/lib/collection.js

@@ -0,0 +1,991 @@
+"use strict";
+/**
+ * Collection – the main API surface for interacting with a document collection.
+ *
+ * Provides a MongoDB-compatible interface including:
+ *   insertOne, insertMany, findOne, find, updateOne, updateMany,
+ *   deleteOne, deleteMany, replaceOne, countDocuments, distinct,
+ *   aggregate, createIndex, dropIndex, watch
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HeadRegistry = exports.Collection = void 0;
+exports.calculateBlockId = calculateBlockId;
+const sha3_1 = require("@noble/hashes/sha3");
+const crypto_1 = require("crypto");
+const aggregation_1 = require("./aggregation");
+const cursor_1 = require("./cursor");
+const errors_1 = require("./errors");
+const indexing_1 = require("./indexing");
+const queryEngine_1 = require("./queryEngine");
+const schemaValidation_1 = require("./schemaValidation");
+const updateEngine_1 = require("./updateEngine");
+/**
+ * Calculate a content-addressable block ID from data.
+ * Uses SHA3-512, the same algorithm as BrightChain's ChecksumService,
+ * but without requiring the global service provider to be initialised.
+ */
+function calculateBlockId(data) {
+    const bytes = data instanceof Buffer ? new Uint8Array(data) : data;
+    const hash = (0, sha3_1.sha3_512)(bytes);
+    return Buffer.from(hash).toString('hex');
+}
+/**
+ * A single document collection backed by a BrightChain block store.
+ */
+class Collection {
+    constructor(name, store, dbName, headRegistry, options) {
+        this.name = name;
+        this.store = store;
+        this.dbName = dbName;
+        this.headRegistry = headRegistry;
+        /** In-memory document index: logical _id → block checksum */
+        this.docIndex = new Map();
+        /** In-memory document cache for fast reads */
+        this.docCache = new Map();
+        /** Index manager */
+        this.indexManager = new indexing_1.IndexManager();
+        /** Change listeners */
+        this.changeListeners = new Set();
+        /** Whether initial index has been loaded */
+        this.loaded = false;
+        /** Write concern for this collection */
+        this.writeConcern = { w: 1 };
+        /** Read preference for this collection */
+        this.readPreference = 'primary';
+        /** TTL index timers */
+        this.ttlTimers = new Map();
+        /** Text index config: field name → weight */
+        this.textIndexFields = {};
+        if (options?.writeConcern)
+            this.writeConcern = options.writeConcern;
+        if (options?.readPreference)
+            this.readPreference = options.readPreference;
+    }
+    /** Set the collection resolver for cross-collection operations */
+    setCollectionResolver(resolver) {
+        this.collectionResolver = resolver;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Index loading / persistence
+    // ═══════════════════════════════════════════════════════
+    async ensureLoaded() {
+        if (this.loaded)
+            return;
+        if (!this.loading) {
+            this.loading = this.loadFromStore().finally(() => {
+                this.loading = undefined;
+            });
+        }
+        return this.loading;
+    }
+    async loadFromStore() {
+        const headBlockId = this.headRegistry.getHead(this.dbName, this.name);
+        if (headBlockId) {
+            try {
+                const handle = this.store.get(headBlockId);
+                const blockData = handle.fullData;
+                const meta = JSON.parse(Buffer.from(blockData).toString('utf8'));
+                // Restore document index
+                if (meta.mappings) {
+                    for (const [logicalId, blockId] of Object.entries(meta.mappings)) {
+                        this.docIndex.set(logicalId, blockId);
+                    }
+                }
+                // Restore index metadata
+                if (meta.indexes) {
+                    // Load all docs first for index rebuild
+                    const docs = await this.loadAllDocs();
+                    this.indexManager.restoreFromJSON(meta.indexes, docs);
+                }
+            }
+            catch {
+                // Head block not found – start fresh
+            }
+        }
+        this.loaded = true;
+    }
+    async loadAllDocs() {
+        const docs = [];
+        for (const [logicalId, blockId] of this.docIndex.entries()) {
+            const doc = await this.readDocFromStore(blockId);
+            if (doc) {
+                this.docCache.set(logicalId, doc);
+                docs.push(doc);
+            }
+        }
+        return docs;
+    }
+    async persistMeta() {
+        const meta = {
+            mappings: Object.fromEntries(this.docIndex.entries()),
+            indexes: this.indexManager.toJSON(),
+        };
+        const payload = Buffer.from(JSON.stringify(meta), 'utf8');
+        const blockId = calculateBlockId(payload);
+        const exists = await this.store.has(blockId);
+        if (!exists) {
+            await this.store.put(blockId, payload);
+        }
+        await this.headRegistry.setHead(this.dbName, this.name, blockId);
+    }
+    // ═══════════════════════════════════════════════════════
+    // Low-level document I/O
+    // ═══════════════════════════════════════════════════════
+    async readDocFromStore(blockId) {
+        try {
+            const handle = this.store.get(blockId);
+            const blockData = handle.fullData;
+            return JSON.parse(Buffer.from(blockData).toString('utf8'));
+        }
+        catch {
+            return null;
+        }
+    }
+    async readDoc(logicalId) {
+        // Check cache first
+        if (this.docCache.has(logicalId)) {
+            return this.docCache.get(logicalId) ?? null;
+        }
+        const blockId = this.docIndex.get(logicalId);
+        if (!blockId)
+            return null;
+        const doc = await this.readDocFromStore(blockId);
+        if (doc) {
+            this.docCache.set(logicalId, doc);
+        }
+        return doc;
+    }
+    async writeDoc(doc, logicalId) {
+        const id = logicalId ?? doc._id ?? (0, crypto_1.randomUUID)().replace(/-/g, '');
+        const docWithId = { ...doc, _id: id };
+        const payload = Buffer.from(JSON.stringify(docWithId), 'utf8');
+        const blockId = calculateBlockId(payload);
+        const exists = await this.store.has(blockId);
+        if (!exists) {
+            await this.store.put(blockId, payload);
+        }
+        // Remove old index entries if updating
+        const oldDoc = this.docCache.get(id);
+        if (oldDoc) {
+            this.indexManager.removeDocument(oldDoc);
+        }
+        this.docIndex.set(id, blockId);
+        this.docCache.set(id, docWithId);
+        // Add to indexes (may throw DuplicateKeyError)
+        try {
+            this.indexManager.addDocument(docWithId);
+        }
+        catch (err) {
+            // Roll back the write
+            if (oldDoc) {
+                const oldPayload = Buffer.from(JSON.stringify(oldDoc), 'utf8');
+                const oldBlockId = calculateBlockId(oldPayload);
+                this.docIndex.set(id, oldBlockId);
+                this.docCache.set(id, oldDoc);
+                this.indexManager.addDocument(oldDoc);
+            }
+            else {
+                this.docIndex.delete(id);
+                this.docCache.delete(id);
+            }
+            throw err;
+        }
+        await this.persistMeta();
+        return docWithId;
+    }
+    /**
+     * Remove a document from the collection index.
+     *
+     * Copy-on-write: blocks in the store are never deleted. This method only
+     * removes the logical mapping so the document is no longer reachable.
+     * The underlying block remains in the store as an orphan and could be
+     * reclaimed by a separate garbage-collection process if desired.
+     */
+    async removeDoc(logicalId) {
+        const doc = this.docCache.get(logicalId);
+        if (doc) {
+            this.indexManager.removeDocument(doc);
+        }
+        const blockId = this.docIndex.get(logicalId);
+        if (!blockId)
+            return false;
+        // Copy-on-write: do NOT call this.store.delete(blockId).
+        // Blocks are immutable; we only remove the mapping.
+        this.docIndex.delete(logicalId);
+        this.docCache.delete(logicalId);
+        await this.persistMeta();
+        return true;
+    }
+    // ═══════════════════════════════════════════════════════
+    // CRUD operations
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Insert a single document.
+     */
+    async insertOne(doc, options) {
+        await this.ensureLoaded();
+        if (options?.session && options.session.inTransaction) {
+            const session = options.session;
+            const id = doc._id ?? (0, crypto_1.randomUUID)().replace(/-/g, '');
+            const docWithId = { ...doc, _id: id };
+            const validated = this.validateBeforeWrite(docWithId);
+            session.addOp({ type: 'insert', collection: this.name, doc: validated });
+            return { acknowledged: true, insertedId: id };
+        }
+        const validated = this.validateBeforeWrite(doc);
+        const written = await this.writeDoc(validated);
+        this.emitChange('insert', written);
+        return { acknowledged: true, insertedId: written._id };
+    }
+    /**
+     * Insert multiple documents.
+     */
+    async insertMany(docs, options) {
+        await this.ensureLoaded();
+        const insertedIds = {};
+        for (let i = 0; i < docs.length; i++) {
+            const result = await this.insertOne(docs[i], options);
+            insertedIds[i] = result.insertedId;
+        }
+        return {
+            acknowledged: true,
+            insertedCount: docs.length,
+            insertedIds,
+        };
+    }
+    /**
+     * Find a single document matching the filter.
+     */
+    async findOne(filter = {}, options) {
+        await this.ensureLoaded();
+        this.configureTextSearch();
+        // Try index lookup
+        const candidates = this.indexManager.findCandidates(filter);
+        if (candidates) {
+            for (const id of candidates) {
+                const doc = await this.readDoc(id);
+                if (doc && (0, queryEngine_1.matchesFilter)(doc, filter)) {
+                    return options?.projection
+                        ? (0, queryEngine_1.applyProjection)(doc, options.projection)
+                        : doc;
+                }
+            }
+            return null;
+        }
+        // Full scan
+        for (const id of this.docIndex.keys()) {
+            const doc = await this.readDoc(id);
+            if (doc && (0, queryEngine_1.matchesFilter)(doc, filter)) {
+                return options?.projection
+                    ? (0, queryEngine_1.applyProjection)(doc, options.projection)
+                    : doc;
+            }
+        }
+        return null;
+    }
+    /**
+     * Find documents matching the filter. Returns a cursor for chaining.
+     */
+    find(filter = {}, options) {
+        const cursor = new cursor_1.Cursor(async () => {
+            await this.ensureLoaded();
+            this.configureTextSearch();
+            // Try index lookup
+            const candidates = this.indexManager.findCandidates(filter);
+            const idsToScan = candidates ?? new Set(this.docIndex.keys());
+            const results = [];
+            for (const id of idsToScan) {
+                const doc = await this.readDoc(id);
+                if (doc && (0, queryEngine_1.matchesFilter)(doc, filter)) {
+                    results.push(options?.projection
+                        ? (0, queryEngine_1.applyProjection)(doc, options.projection)
+                        : doc);
+                }
+            }
+            return results;
+        });
+        if (options?.sort)
+            cursor.sort(options.sort);
+        if (options?.skip)
+            cursor.skip(options.skip);
+        if (options?.limit)
+            cursor.limit(options.limit);
+        return cursor;
+    }
+    /**
+     * Find a document by its _id.
+     */
+    async findById(id) {
+        await this.ensureLoaded();
+        return this.readDoc(id);
+    }
+    /**
+     * Update a single document matching the filter.
+     */
+    async updateOne(filter, update, options) {
+        await this.ensureLoaded();
+        const doc = await this.findOne(filter);
+        if (!doc && options?.upsert) {
+            const baseDoc = {};
+            // Apply filter as initial fields (for exact matches)
+            for (const [key, value] of Object.entries(filter)) {
+                if (!key.startsWith('$') && typeof value !== 'object') {
+                    baseDoc[key] = value;
+                }
+            }
+            const updated = (0, updateEngine_1.applyUpdate)(baseDoc, update);
+            const result = await this.insertOne(updated, options);
+            return {
+                acknowledged: true,
+                matchedCount: 0,
+                modifiedCount: 0,
+                upsertedCount: 1,
+                upsertedId: result.insertedId,
+            };
+        }
+        if (!doc) {
+            return {
+                acknowledged: true,
+                matchedCount: 0,
+                modifiedCount: 0,
+                upsertedCount: 0,
+            };
+        }
+        if (options?.session && options.session.inTransaction) {
+            const session = options.session;
+            const updated = (0, updateEngine_1.applyUpdate)(doc, update);
+            const validated = this.validateBeforeWrite(updated, true);
+            session.addOp({
+                type: 'update',
+                collection: this.name,
+                docId: doc._id,
+                before: doc,
+                after: validated,
+            });
+            return {
+                acknowledged: true,
+                matchedCount: 1,
+                modifiedCount: 1,
+                upsertedCount: 0,
+            };
+        }
+        const updated = (0, updateEngine_1.applyUpdate)(doc, update);
+        const validated = this.validateBeforeWrite(updated, true);
+        await this.writeDoc(validated, doc._id);
+        this.emitChange('update', updated, {
+            updatedFields: (0, updateEngine_1.isOperatorUpdate)(update)
+                ? update['$set']
+                : undefined,
+        });
+        return {
+            acknowledged: true,
+            matchedCount: 1,
+            modifiedCount: 1,
+            upsertedCount: 0,
+        };
+    }
+    /**
+     * Update all documents matching the filter.
+     */
+    async updateMany(filter, update, options) {
+        await this.ensureLoaded();
+        const docs = await this.find(filter).toArray();
+        let modified = 0;
+        for (const doc of docs) {
+            const updated = (0, updateEngine_1.applyUpdate)(doc, update);
+            if (options?.session && options.session.inTransaction) {
+                options.session.addOp({
+                    type: 'update',
+                    collection: this.name,
+                    docId: doc._id,
+                    before: doc,
+                    after: updated,
+                });
+            }
+            else {
+                await this.writeDoc(updated, doc._id);
+                this.emitChange('update', updated);
+            }
+            modified++;
+        }
+        return {
+            acknowledged: true,
+            matchedCount: docs.length,
+            modifiedCount: modified,
+            upsertedCount: 0,
+        };
+    }
+    /**
+     * Delete a single document matching the filter.
+     */
+    async deleteOne(filter, options) {
+        await this.ensureLoaded();
+        const doc = await this.findOne(filter);
+        if (!doc)
+            return { acknowledged: true, deletedCount: 0 };
+        if (options?.session && options.session.inTransaction) {
+            options.session.addOp({
+                type: 'delete',
+                collection: this.name,
+                docId: doc._id,
+                doc,
+            });
+            return { acknowledged: true, deletedCount: 1 };
+        }
+        const removed = await this.removeDoc(doc._id);
+        if (removed)
+            this.emitChange('delete', doc);
+        return { acknowledged: true, deletedCount: removed ? 1 : 0 };
+    }
+    /**
+     * Delete all documents matching the filter.
+     */
+    async deleteMany(filter, options) {
+        await this.ensureLoaded();
+        const docs = await this.find(filter).toArray();
+        let deleted = 0;
+        for (const doc of docs) {
+            if (options?.session && options.session.inTransaction) {
+                options.session.addOp({
+                    type: 'delete',
+                    collection: this.name,
+                    docId: doc._id,
+                    doc,
+                });
+                deleted++;
+            }
+            else {
+                const removed = await this.removeDoc(doc._id);
+                if (removed) {
+                    this.emitChange('delete', doc);
+                    deleted++;
+                }
+            }
+        }
+        return { acknowledged: true, deletedCount: deleted };
+    }
+    /**
+     * Replace a single document matching the filter.
+     */
+    async replaceOne(filter, replacement, options) {
+        await this.ensureLoaded();
+        const doc = await this.findOne(filter);
+        if (!doc && options?.upsert) {
+            const result = await this.insertOne(replacement, options);
+            return {
+                acknowledged: true,
+                matchedCount: 0,
+                modifiedCount: 0,
+                upsertedCount: 1,
+                upsertedId: result.insertedId,
+            };
+        }
+        if (!doc) {
+            return {
+                acknowledged: true,
+                matchedCount: 0,
+                modifiedCount: 0,
+                upsertedCount: 0,
+            };
+        }
+        const replacementWithId = { ...replacement, _id: doc._id };
+        await this.writeDoc(replacementWithId, doc._id);
+        this.emitChange('replace', replacementWithId);
+        return {
+            acknowledged: true,
+            matchedCount: 1,
+            modifiedCount: 1,
+            upsertedCount: 0,
+        };
+    }
+    /**
+     * Count documents matching the filter.
+     */
+    async countDocuments(filter = {}) {
+        const docs = await this.find(filter).toArray();
+        return docs.length;
+    }
+    /**
+     * Estimated document count (fast, from index size).
+     */
+    async estimatedDocumentCount() {
+        await this.ensureLoaded();
+        return this.docIndex.size;
+    }
+    /**
+     * Get distinct values for a field.
+     */
+    async distinct(field, filter = {}) {
+        const docs = await this.find(filter).toArray();
+        const values = new Set();
+        const result = [];
+        for (const doc of docs) {
+            const val = doc[field];
+            const key = JSON.stringify(val);
+            if (!values.has(key)) {
+                values.add(key);
+                result.push(val);
+            }
+        }
+        return result;
+    }
+    /**
+     * Run an aggregation pipeline.
+     */
+    async aggregate(pipeline) {
+        await this.ensureLoaded();
+        const allDocs = await this.find().toArray();
+        const lookupResolver = this.collectionResolver
+            ? async (collName) => {
+                const coll = this.collectionResolver(collName);
+                return coll.find().toArray();
+            }
+            : undefined;
+        return (0, aggregation_1.runAggregation)(allDocs, pipeline, lookupResolver);
+    }
+    // ═══════════════════════════════════════════════════════
+    // Schema validation
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Set a schema for this collection. Documents will be validated on
+     * insert and (if level is 'strict') on update.
+     */
+    setSchema(schema) {
+        this.schema = schema;
+    }
+    /**
+     * Get the current schema (if any).
+     */
+    getSchema() {
+        return this.schema;
+    }
+    /**
+     * Remove validation schema.
+     */
+    removeSchema() {
+        this.schema = undefined;
+    }
+    /**
+     * Validate a document without inserting it.
+     * @returns array of validation errors (empty if valid)
+     */
+    validateDoc(doc) {
+        if (!this.schema)
+            return [];
+        try {
+            (0, schemaValidation_1.validateDocument)(doc, this.schema, this.name);
+            return [];
+        }
+        catch (err) {
+            if (err instanceof errors_1.ValidationError)
+                return err.validationErrors;
+            throw err;
+        }
+    }
+    /**
+     * Internal: validate and apply defaults before write.
+     */
+    validateBeforeWrite(doc, isUpdate = false) {
+        if (!this.schema)
+            return doc;
+        if (isUpdate && this.schema.validationLevel === 'moderate')
+            return doc;
+        const withDefaults = (0, schemaValidation_1.applyDefaults)(doc, this.schema);
+        (0, schemaValidation_1.validateDocument)(withDefaults, this.schema, this.name);
+        return withDefaults;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Text search index
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Create a text index for full-text search.
+     *
+     * @param options - The fields to index and their weights
+     * @returns The index name
+     *
+     * @example
+     * ```typescript
+     * await coll.createTextIndex({ fields: { title: 10, body: 1 } });
+     * const results = await coll.find({ $text: { $search: 'hello world' } }).toArray();
+     * ```
+     */
+    createTextIndex(options) {
+        this.textIndexFields = { ...options.fields };
+        return options.name ?? 'text_index';
+    }
+    /**
+     * Drop the text index.
+     */
+    dropTextIndex() {
+        this.textIndexFields = {};
+    }
+    /**
+     * Check if a text index exists.
+     */
+    hasTextIndex() {
+        return Object.keys(this.textIndexFields).length > 0;
+    }
+    // ═══════════════════════════════════════════════════════
+    // TTL index
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Create a TTL index that automatically removes documents whose
+     * date field is older than `expireAfterSeconds`.
+     *
+     * TTL expiry is checked periodically (every 60 seconds by default).
+     */
+    async createTTLIndex(field, expireAfterSeconds, intervalMs = 60000) {
+        const name = await this.createIndex({ [field]: 1 }, { expireAfterSeconds, name: `ttl_${field}` });
+        // Set up periodic sweep
+        const timer = setInterval(async () => {
+            await this.sweepTTL(field, expireAfterSeconds);
+        }, intervalMs);
+        // Allow timer to not prevent process exit
+        if (timer.unref)
+            timer.unref();
+        this.ttlTimers.set(name, timer);
+        return name;
+    }
+    /**
+     * Stop a TTL index timer (does not drop the index itself).
+     */
+    stopTTL(indexName) {
+        const timer = this.ttlTimers.get(indexName);
+        if (timer) {
+            clearInterval(timer);
+            this.ttlTimers.delete(indexName);
+        }
+    }
+    /**
+     * Run a single TTL sweep: delete documents where `field` is older
+     * than `expireAfterSeconds` from now.
+     */
+    async sweepTTL(field, expireAfterSeconds) {
+        await this.ensureLoaded();
+        const cutoff = new Date(Date.now() - expireAfterSeconds * 1000);
+        const expired = [];
+        for (const id of this.docIndex.keys()) {
+            const doc = await this.readDoc(id);
+            if (!doc)
+                continue;
+            const value = doc[field];
+            let dateValue = null;
+            if (value instanceof Date) {
+                dateValue = value;
+            }
+            else if (typeof value === 'string' || typeof value === 'number') {
+                const parsed = new Date(value);
+                if (!isNaN(parsed.getTime()))
+                    dateValue = parsed;
+            }
+            if (dateValue && dateValue <= cutoff) {
+                expired.push(id);
+            }
+        }
+        for (const id of expired) {
+            const doc = await this.readDoc(id);
+            if (doc) {
+                await this.removeDoc(id);
+                this.emitChange('delete', doc);
+            }
+        }
+        return expired.length;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Bulk write
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Execute multiple write operations in a single call.
+     *
+     * @param operations - Array of write operations
+     * @param options - Bulk write options (ordered = stop on first error)
+     * @returns Aggregated result of all operations
+     * @throws BulkWriteError if any operations fail and ordered is true
+     *
+     * @example
+     * ```typescript
+     * await coll.bulkWrite([
+     *   { insertOne: { document: { name: 'Alice' } } },
+     *   { updateOne: { filter: { name: 'Bob' }, update: { $set: { age: 30 } } } },
+     *   { deleteOne: { filter: { name: 'Charlie' } } },
+     * ]);
+     * ```
+     */
+    async bulkWrite(operations, options) {
+        await this.ensureLoaded();
+        const ordered = options?.ordered ?? true;
+        const result = {
+            acknowledged: true,
+            insertedCount: 0,
+            matchedCount: 0,
+            modifiedCount: 0,
+            deletedCount: 0,
+            upsertedCount: 0,
+            insertedIds: {},
+            upsertedIds: {},
+        };
+        const errors = [];
+        for (let i = 0; i < operations.length; i++) {
+            try {
+                const op = operations[i];
+                if ('insertOne' in op) {
+                    const r = await this.insertOne(op.insertOne.document, options);
+                    result.insertedCount++;
+                    result.insertedIds[i] = r.insertedId;
+                }
+                else if ('updateOne' in op) {
+                    const r = await this.updateOne(op.updateOne.filter, op.updateOne.update, { ...options, upsert: op.updateOne.upsert });
+                    result.matchedCount += r.matchedCount;
+                    result.modifiedCount += r.modifiedCount;
+                    result.upsertedCount += r.upsertedCount;
+                    if (r.upsertedId)
+                        result.upsertedIds[i] = r.upsertedId;
+                }
+                else if ('updateMany' in op) {
+                    const r = await this.updateMany(op.updateMany.filter, op.updateMany.update, options);
+                    result.matchedCount += r.matchedCount;
+                    result.modifiedCount += r.modifiedCount;
+                }
+                else if ('deleteOne' in op) {
+                    const r = await this.deleteOne(op.deleteOne.filter, options);
+                    result.deletedCount += r.deletedCount;
+                }
+                else if ('deleteMany' in op) {
+                    const r = await this.deleteMany(op.deleteMany.filter, options);
+                    result.deletedCount += r.deletedCount;
+                }
+                else if ('replaceOne' in op) {
+                    const r = await this.replaceOne(op.replaceOne.filter, op.replaceOne.replacement, { ...options, upsert: op.replaceOne.upsert });
+                    result.matchedCount += r.matchedCount;
+                    result.modifiedCount += r.modifiedCount;
+                    result.upsertedCount += r.upsertedCount;
+                    if (r.upsertedId)
+                        result.upsertedIds[i] = r.upsertedId;
+                }
+            }
+            catch (err) {
+                const error = {
+                    index: i,
+                    code: err instanceof Error && 'code' in err
+                        ? err.code
+                        : 500,
+                    message: String(err),
+                };
+                errors.push(error);
+                if (ordered) {
+                    throw new errors_1.BulkWriteError(errors, i);
+                }
+            }
+        }
+        if (errors.length > 0) {
+            throw new errors_1.BulkWriteError(errors, operations.length - errors.length);
+        }
+        return result;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Write concern / Read preference
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Get the current write concern for this collection.
+     */
+    getWriteConcern() {
+        return { ...this.writeConcern };
+    }
+    /**
+     * Set the write concern for this collection.
+     */
+    setWriteConcern(wc) {
+        this.writeConcern = { ...wc };
+    }
+    /**
+     * Get the current read preference for this collection.
+     */
+    getReadPreference() {
+        return this.readPreference;
+    }
+    /**
+     * Set the read preference for this collection.
+     */
+    setReadPreference(rp) {
+        this.readPreference = rp;
+    }
+    // ═══════════════════════════════════════════════════════
+    // Index operations
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Create an index on this collection.
+     */
+    async createIndex(spec, options) {
+        await this.ensureLoaded();
+        const name = this.indexManager.createIndex(spec, options);
+        // Build index from existing docs
+        for (const id of this.docIndex.keys()) {
+            const doc = await this.readDoc(id);
+            if (doc) {
+                this.indexManager.getIndex(name)?.addDocument(doc);
+            }
+        }
+        await this.persistMeta();
+        return name;
+    }
+    /**
+     * Drop an index by name.
+     */
+    async dropIndex(name) {
+        await this.ensureLoaded();
+        this.indexManager.dropIndex(name);
+        await this.persistMeta();
+    }
+    /**
+     * List all indexes on this collection.
+     */
+    listIndexes() {
+        return this.indexManager.listIndexes();
+    }
+    // ═══════════════════════════════════════════════════════
+    // Change stream
+    // ═══════════════════════════════════════════════════════
+    /**
+     * Watch for changes on this collection.
+     */
+    watch(listener) {
+        this.changeListeners.add(listener);
+        return () => {
+            this.changeListeners.delete(listener);
+        };
+    }
+    emitChange(operationType, doc, updateDescription) {
+        if (this.changeListeners.size === 0)
+            return;
+        const event = {
+            operationType,
+            documentKey: { _id: doc._id },
+            fullDocument: operationType !== 'delete' ? doc : undefined,
+            updateDescription: operationType === 'update' ? updateDescription : undefined,
+            ns: { db: this.dbName, coll: this.name },
+            timestamp: new Date(),
+        };
+        for (const listener of this.changeListeners) {
+            try {
+                listener(event);
+            }
+            catch {
+                // Don't let listener errors break the operation
+            }
+        }
+    }
+    // ═══════════════════════════════════════════════════════
+    // Transaction helpers (called by the session on commit)
+    // ═══════════════════════════════════════════════════════
+    /** Apply a transaction insert */
+    async _txInsert(doc) {
+        await this.writeDoc(doc, doc._id);
+        this.emitChange('insert', doc);
+    }
+    /** Apply a transaction update – writes a new block (copy-on-write). */
+    async _txUpdate(docId, after) {
+        await this.writeDoc(after, docId);
+        this.emitChange('update', after);
+    }
+    /** Apply a transaction delete – removes mapping only (copy-on-write). */
+    async _txDelete(docId, doc) {
+        await this.removeDoc(docId);
+        this.emitChange('delete', doc);
+    }
+    /**
+     * Rollback a transaction insert.
+     * Copy-on-write: just remove the mapping; the block remains in the store.
+     */
+    async _txRollbackInsert(docId) {
+        await this.removeDoc(docId);
+    }
+    /**
+     * Rollback a transaction update.
+     * Copy-on-write: restore the old mapping. The old block still exists in
+     * the store (blocks are never deleted), so writeDoc will detect it via
+     * store.has() and simply re-point the index.
+     */
+    async _txRollbackUpdate(docId, before) {
+        await this.writeDoc(before, docId);
+    }
+    /**
+     * Rollback a transaction delete.
+     * Copy-on-write: re-insert the mapping. The block still exists in the
+     * store since blocks are never deleted.
+     */
+    async _txRollbackDelete(doc) {
+        await this.writeDoc(doc, doc._id);
+    }
+    /**
+     * Drop the entire collection – remove all document mappings and indexes.
+     *
+     * Copy-on-write: blocks in the store are never deleted. Only the
+     * collection's internal index and cache are cleared.
+     */
+    async drop() {
+        await this.ensureLoaded();
+        // Stop all TTL timers
+        for (const timer of this.ttlTimers.values()) {
+            clearInterval(timer);
+        }
+        this.ttlTimers.clear();
+        // Remove all index entries
+        for (const id of this.docIndex.keys()) {
+            const doc = this.docCache.get(id);
+            if (doc)
+                this.indexManager.removeDocument(doc);
+        }
+        this.docIndex.clear();
+        this.docCache.clear();
+        await this.headRegistry.removeHead(this.dbName, this.name);
+    }
+    /** Configure the query engine's text search fields from our text index */
+    configureTextSearch() {
+        const fields = Object.keys(this.textIndexFields);
+        (0, queryEngine_1.setTextSearchFields)(fields);
+    }
+}
+exports.Collection = Collection;
+// ═══════════════════════════════════════════════════════
+// Head registry – tracks latest metadata block per collection
+// ═══════════════════════════════════════════════════════
+class HeadRegistry {
+    constructor() {
+        this.heads = new Map();
+    }
+    static getInstance() {
+        if (!HeadRegistry.instance) {
+            HeadRegistry.instance = new HeadRegistry();
+        }
+        return HeadRegistry.instance;
+    }
+    /** Create a new independent registry (for testing) */
+    static createIsolated() {
+        return new HeadRegistry();
+    }
+    makeKey(dbName, collectionName) {
+        return `${dbName}:${collectionName}`;
+    }
+    getHead(dbName, collectionName) {
+        return this.heads.get(this.makeKey(dbName, collectionName));
+    }
+    setHead(dbName, collectionName, blockId) {
+        this.heads.set(this.makeKey(dbName, collectionName), blockId);
+    }
+    removeHead(dbName, collectionName) {
+        this.heads.delete(this.makeKey(dbName, collectionName));
+    }
+    clear() {
+        this.heads.clear();
+    }
+    /**
+     * Load head pointers from the persistence layer.
+     * For the in-memory implementation this is a no-op.
+     * Exists for API compatibility with IHeadRegistry / persistent registries.
+     */
+    async load() {
+        // No-op — in-memory heads are always current.
+    }
+}
+exports.HeadRegistry = HeadRegistry;
+//# sourceMappingURL=collection.js.map