@push.rocks/smartmongo 2.2.0 → 3.0.0

package/dist_ts/tsmdb/server/handlers/FindHandler.js

@@ -0,0 +1,261 @@
+import * as plugins from '../../tsmdb.plugins.js';
+import { QueryEngine } from '../../engine/QueryEngine.js';
+/**
+ * FindHandler - Handles find, getMore, killCursors, count, distinct commands
+ */
+export class FindHandler {
+    cursors;
+    nextCursorId;
+    constructor(cursors, nextCursorId) {
+        this.cursors = cursors;
+        this.nextCursorId = nextCursorId;
+    }
+    async handle(context) {
+        const { command } = context;
+        // Determine which operation to perform
+        if (command.find) {
+            return this.handleFind(context);
+        }
+        else if (command.getMore !== undefined) {
+            return this.handleGetMore(context);
+        }
+        else if (command.killCursors) {
+            return this.handleKillCursors(context);
+        }
+        else if (command.count) {
+            return this.handleCount(context);
+        }
+        else if (command.distinct) {
+            return this.handleDistinct(context);
+        }
+        return {
+            ok: 0,
+            errmsg: 'Unknown find-related command',
+            code: 59,
+            codeName: 'CommandNotFound',
+        };
+    }
+    /**
+     * Handle find command
+     */
+    async handleFind(context) {
+        const { storage, database, command } = context;
+        const collection = command.find;
+        const filter = command.filter || {};
+        const projection = command.projection;
+        const sort = command.sort;
+        const skip = command.skip || 0;
+        const limit = command.limit || 0;
+        const batchSize = command.batchSize || 101;
+        const singleBatch = command.singleBatch || false;
+        // Ensure collection exists
+        const exists = await storage.collectionExists(database, collection);
+        if (!exists) {
+            // Return empty cursor for non-existent collection
+            return {
+                ok: 1,
+                cursor: {
+                    id: plugins.bson.Long.fromNumber(0),
+                    ns: `${database}.${collection}`,
+                    firstBatch: [],
+                },
+            };
+        }
+        // Get all documents
+        let documents = await storage.findAll(database, collection);
+        // Apply filter
+        documents = QueryEngine.filter(documents, filter);
+        // Apply sort
+        if (sort) {
+            documents = QueryEngine.sort(documents, sort);
+        }
+        // Apply skip
+        if (skip > 0) {
+            documents = documents.slice(skip);
+        }
+        // Apply limit
+        if (limit > 0) {
+            documents = documents.slice(0, limit);
+        }
+        // Apply projection
+        if (projection) {
+            documents = QueryEngine.project(documents, projection);
+        }
+        // Determine how many documents to return in first batch
+        const effectiveBatchSize = Math.min(batchSize, documents.length);
+        const firstBatch = documents.slice(0, effectiveBatchSize);
+        const remaining = documents.slice(effectiveBatchSize);
+        // Create cursor if there are more documents
+        let cursorId = BigInt(0);
+        if (remaining.length > 0 && !singleBatch) {
+            cursorId = this.nextCursorId();
+            this.cursors.set(cursorId, {
+                id: cursorId,
+                database,
+                collection,
+                documents: remaining,
+                position: 0,
+                batchSize,
+                createdAt: new Date(),
+            });
+        }
+        return {
+            ok: 1,
+            cursor: {
+                id: plugins.bson.Long.fromBigInt(cursorId),
+                ns: `${database}.${collection}`,
+                firstBatch,
+            },
+        };
+    }
+    /**
+     * Handle getMore command
+     */
+    async handleGetMore(context) {
+        const { database, command } = context;
+        const cursorIdInput = command.getMore;
+        const collection = command.collection;
+        const batchSize = command.batchSize || 101;
+        // Convert cursorId to bigint
+        let cursorId;
+        if (typeof cursorIdInput === 'bigint') {
+            cursorId = cursorIdInput;
+        }
+        else if (cursorIdInput instanceof plugins.bson.Long) {
+            cursorId = cursorIdInput.toBigInt();
+        }
+        else {
+            cursorId = BigInt(cursorIdInput);
+        }
+        const cursor = this.cursors.get(cursorId);
+        if (!cursor) {
+            return {
+                ok: 0,
+                errmsg: `cursor id ${cursorId} not found`,
+                code: 43,
+                codeName: 'CursorNotFound',
+            };
+        }
+        // Verify namespace
+        if (cursor.database !== database || cursor.collection !== collection) {
+            return {
+                ok: 0,
+                errmsg: 'cursor namespace mismatch',
+                code: 43,
+                codeName: 'CursorNotFound',
+            };
+        }
+        // Get next batch
+        const start = cursor.position;
+        const end = Math.min(start + batchSize, cursor.documents.length);
+        const nextBatch = cursor.documents.slice(start, end);
+        cursor.position = end;
+        // Check if cursor is exhausted
+        let returnCursorId = cursorId;
+        if (cursor.position >= cursor.documents.length) {
+            this.cursors.delete(cursorId);
+            returnCursorId = BigInt(0);
+        }
+        return {
+            ok: 1,
+            cursor: {
+                id: plugins.bson.Long.fromBigInt(returnCursorId),
+                ns: `${database}.${collection}`,
+                nextBatch,
+            },
+        };
+    }
+    /**
+     * Handle killCursors command
+     */
+    async handleKillCursors(context) {
+        const { command } = context;
+        const collection = command.killCursors;
+        const cursorIds = command.cursors || [];
+        const cursorsKilled = [];
+        const cursorsNotFound = [];
+        const cursorsUnknown = [];
+        for (const idInput of cursorIds) {
+            let cursorId;
+            if (typeof idInput === 'bigint') {
+                cursorId = idInput;
+            }
+            else if (idInput instanceof plugins.bson.Long) {
+                cursorId = idInput.toBigInt();
+            }
+            else {
+                cursorId = BigInt(idInput);
+            }
+            if (this.cursors.has(cursorId)) {
+                this.cursors.delete(cursorId);
+                cursorsKilled.push(plugins.bson.Long.fromBigInt(cursorId));
+            }
+            else {
+                cursorsNotFound.push(plugins.bson.Long.fromBigInt(cursorId));
+            }
+        }
+        return {
+            ok: 1,
+            cursorsKilled,
+            cursorsNotFound,
+            cursorsUnknown,
+            cursorsAlive: [],
+        };
+    }
+    /**
+     * Handle count command
+     */
+    async handleCount(context) {
+        const { storage, database, command } = context;
+        const collection = command.count;
+        const query = command.query || {};
+        const skip = command.skip || 0;
+        const limit = command.limit || 0;
+        // Check if collection exists
+        const exists = await storage.collectionExists(database, collection);
+        if (!exists) {
+            return { ok: 1, n: 0 };
+        }
+        // Get all documents
+        let documents = await storage.findAll(database, collection);
+        // Apply filter
+        documents = QueryEngine.filter(documents, query);
+        // Apply skip
+        if (skip > 0) {
+            documents = documents.slice(skip);
+        }
+        // Apply limit
+        if (limit > 0) {
+            documents = documents.slice(0, limit);
+        }
+        return { ok: 1, n: documents.length };
+    }
+    /**
+     * Handle distinct command
+     */
+    async handleDistinct(context) {
+        const { storage, database, command } = context;
+        const collection = command.distinct;
+        const key = command.key;
+        const query = command.query || {};
+        if (!key) {
+            return {
+                ok: 0,
+                errmsg: 'distinct requires a key',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Check if collection exists
+        const exists = await storage.collectionExists(database, collection);
+        if (!exists) {
+            return { ok: 1, values: [] };
+        }
+        // Get all documents
+        const documents = await storage.findAll(database, collection);
+        // Get distinct values
+        const values = QueryEngine.distinct(documents, key, query);
+        return { ok: 1, values };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"FindHandler.js","sourceRoot":"","sources":["../../../../ts/tsmdb/server/handlers/FindHandler.ts"],"names":[],"mappings":"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"}

package/dist_ts/{congodb → tsmdb}/server/handlers/HelloHandler.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
 /**
  * HelloHandler - Handles hello/isMaster handshake commands

package/dist_ts/{congodb → tsmdb}/server/handlers/HelloHandler.js

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 /**
  * HelloHandler - Handles hello/isMaster handshake commands
  *
@@ -59,4 +59,4 @@ export class HelloHandler {
         return response;
     }
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSGVsbG9IYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvY29uZ29kYi9zZXJ2ZXIvaGFuZGxlcnMvSGVsbG9IYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sMEJBQTBCLENBQUM7QUFHcEQ7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQUN2QixLQUFLLENBQUMsTUFBTSxDQUFDLE9BQXdCO1FBQ25DLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDO1FBRXBDLDBDQUEwQztRQUMxQyxNQUFNLFFBQVEsR0FBMEI7WUFDdEMsUUFBUSxFQUFFLElBQUk7WUFDZCxFQUFFLEVBQUUsQ0FBQztZQUVMLGdCQUFnQjtZQUNoQixpQkFBaUIsRUFBRSxRQUFRLEVBQVksUUFBUTtZQUMvQyxtQkFBbUIsRUFBRSxRQUFRLEVBQVUsUUFBUTtZQUMvQyxpQkFBaUIsRUFBRSxNQUFNLEVBQWMsMkJBQTJCO1lBRWxFLGFBQWE7WUFDYixTQUFTLEVBQUUsSUFBSSxJQUFJLEVBQUU7WUFFckIsa0JBQWtCO1lBQ2xCLDRCQUE0QixFQUFFLEVBQUU7WUFFaEMsa0JBQWtCO1lBQ2xCLFlBQVksRUFBRSxDQUFDO1lBRWYsMkRBQTJEO1lBQzNELGNBQWMsRUFBRSxDQUFDO1lBQ2pCLGNBQWMsRUFBRSxFQUFFO1lBRWxCLGNBQWM7WUFDZCxRQUFRLEVBQUUsS0FBSztZQUVmLGtDQUFrQztZQUNsQyxpQkFBaUIsRUFBRSxJQUFJO1lBRXZCLGtCQUFrQjtZQUNsQixlQUFlLEVBQUU7Z0JBQ2YsU0FBUyxFQUFFLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0JBQ3RDLE9BQU8sRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO2FBQ3pDO1NBQ0YsQ0FBQztRQUVGLCtCQUErQjtRQUMvQixJQUFJLE9BQU8sQ0FBQyxLQUFLLElBQUksT0FBTyxDQUFDLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN6QyxRQUFRLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztRQUMxQixDQUFDO1FBRUQseUJBQXlCO1FBQ3pCLElBQUksT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ25CLDRDQUE0QztZQUM1QywwREFBMEQ7UUFDNUQsQ0FBQztRQUVELCtCQUErQjtRQUMvQixJQUFJLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1lBQy9CLFFBQVEsQ0FBQyxrQkFBa0IsR0FBRztZQUM1QixtRUFBbUU7YUFDcEUsQ0FBQztRQUNKLENBQUM7UUFFRCxxQ0FBcUM7UUFDckMsSUFBSSxPQUFPLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDeEIsUUFBUSxDQUFDLFdBQVcsR0FBRyxFQUFFLENBQUM7UUFDNUIsQ0FBQztRQUVELHNCQUFzQjtRQUN0QixRQUFRLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUUzQixPQUFPLFFBQVEsQ0FBQztJQUNsQixDQUFDO0NBQ0YifQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSGVsbG9IYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvdHNtZGIvc2VydmVyL2hhbmRsZXJzL0hlbGxvSGFuZGxlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHdCQUF3QixDQUFDO0FBR2xEOzs7OztHQUtHO0FBQ0gsTUFBTSxPQUFPLFlBQVk7SUFDdkIsS0FBSyxDQUFDLE1BQU0sQ0FBQyxPQUF3QjtRQUNuQyxNQUFNLEVBQUUsT0FBTyxFQUFFLE1BQU0sRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUVwQywwQ0FBMEM7UUFDMUMsTUFBTSxRQUFRLEdBQTBCO1lBQ3RDLFFBQVEsRUFBRSxJQUFJO1lBQ2QsRUFBRSxFQUFFLENBQUM7WUFFTCxnQkFBZ0I7WUFDaEIsaUJBQWlCLEVBQUUsUUFBUSxFQUFZLFFBQVE7WUFDL0MsbUJBQW1CLEVBQUUsUUFBUSxFQUFVLFFBQVE7WUFDL0MsaUJBQWlCLEVBQUUsTUFBTSxFQUFjLDJCQUEyQjtZQUVsRSxhQUFhO1lBQ2IsU0FBUyxFQUFFLElBQUksSUFBSSxFQUFFO1lBRXJCLGtCQUFrQjtZQUNsQiw0QkFBNEIsRUFBRSxFQUFFO1lBRWhDLGtCQUFrQjtZQUNsQixZQUFZLEVBQUUsQ0FBQztZQUVmLDJEQUEyRDtZQUMzRCxjQUFjLEVBQUUsQ0FBQztZQUNqQixjQUFjLEVBQUUsRUFBRTtZQUVsQixjQUFjO1lBQ2QsUUFBUSxFQUFFLEtBQUs7WUFFZixrQ0FBa0M7WUFDbEMsaUJBQWlCLEVBQUUsSUFBSTtZQUV2QixrQkFBa0I7WUFDbEIsZUFBZSxFQUFFO2dCQUNmLFNBQVMsRUFBRSxJQUFJLE9BQU8sQ0FBQyxJQUFJLENBQUMsUUFBUSxFQUFFO2dCQUN0QyxPQUFPLEVBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQzthQUN6QztTQUNGLENBQUM7UUFFRiwrQkFBK0I7UUFDL0IsSUFBSSxPQUFPLENBQUMsS0FBSyxJQUFJLE9BQU8sQ0FBQyxLQUFLLEtBQUssQ0FBQyxFQUFFLENBQUM7WUFDekMsUUFBUSxDQUFDLE9BQU8sR0FBRyxJQUFJLENBQUM7UUFDMUIsQ0FBQztRQUVELHlCQUF5QjtRQUN6QixJQUFJLE9BQU8sQ0FBQyxNQUFNLEVBQUUsQ0FBQztZQUNuQiw0Q0FBNEM7WUFDNUMsMERBQTBEO1FBQzVELENBQUM7UUFFRCwrQkFBK0I7UUFDL0IsSUFBSSxPQUFPLENBQUMsa0JBQWtCLEVBQUUsQ0FBQztZQUMvQixRQUFRLENBQUMsa0JBQWtCLEdBQUc7WUFDNUIsbUVBQW1FO2FBQ3BFLENBQUM7UUFDSixDQUFDO1FBRUQscUNBQXFDO1FBQ3JDLElBQUksT0FBTyxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQ3hCLFFBQVEsQ0FBQyxXQUFXLEdBQUcsRUFBRSxDQUFDO1FBQzVCLENBQUM7UUFFRCxzQkFBc0I7UUFDdEIsUUFBUSxDQUFDLE9BQU8sR0FBRyxPQUFPLENBQUM7UUFFM0IsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztDQUNGIn0=

package/dist_ts/{congodb → tsmdb}/server/handlers/IndexHandler.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
 /**
  * IndexHandler - Handles createIndexes, dropIndexes, listIndexes commands

package/dist_ts/tsmdb/server/handlers/IndexHandler.js

@@ -0,0 +1,183 @@
+import * as plugins from '../../tsmdb.plugins.js';
+import { IndexEngine } from '../../engine/IndexEngine.js';
+// Cache of index engines per collection
+const indexEngines = new Map();
+/**
+ * Get or create an IndexEngine for a collection
+ */
+function getIndexEngine(storage, database, collection) {
+    const key = `${database}.${collection}`;
+    let engine = indexEngines.get(key);
+    if (!engine) {
+        engine = new IndexEngine(database, collection, storage);
+        indexEngines.set(key, engine);
+    }
+    return engine;
+}
+/**
+ * IndexHandler - Handles createIndexes, dropIndexes, listIndexes commands
+ */
+export class IndexHandler {
+    async handle(context) {
+        const { command } = context;
+        if (command.createIndexes) {
+            return this.handleCreateIndexes(context);
+        }
+        else if (command.dropIndexes) {
+            return this.handleDropIndexes(context);
+        }
+        else if (command.listIndexes) {
+            return this.handleListIndexes(context);
+        }
+        return {
+            ok: 0,
+            errmsg: 'Unknown index command',
+            code: 59,
+            codeName: 'CommandNotFound',
+        };
+    }
+    /**
+     * Handle createIndexes command
+     */
+    async handleCreateIndexes(context) {
+        const { storage, database, command } = context;
+        const collection = command.createIndexes;
+        const indexes = command.indexes || [];
+        if (!Array.isArray(indexes)) {
+            return {
+                ok: 0,
+                errmsg: 'indexes must be an array',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Ensure collection exists
+        await storage.createCollection(database, collection);
+        const indexEngine = getIndexEngine(storage, database, collection);
+        const createdNames = [];
+        let numIndexesBefore = 0;
+        let numIndexesAfter = 0;
+        try {
+            const existingIndexes = await indexEngine.listIndexes();
+            numIndexesBefore = existingIndexes.length;
+            for (const indexSpec of indexes) {
+                const key = indexSpec.key;
+                const options = {
+                    name: indexSpec.name,
+                    unique: indexSpec.unique,
+                    sparse: indexSpec.sparse,
+                    expireAfterSeconds: indexSpec.expireAfterSeconds,
+                    background: indexSpec.background,
+                    partialFilterExpression: indexSpec.partialFilterExpression,
+                };
+                const name = await indexEngine.createIndex(key, options);
+                createdNames.push(name);
+            }
+            const finalIndexes = await indexEngine.listIndexes();
+            numIndexesAfter = finalIndexes.length;
+        }
+        catch (error) {
+            return {
+                ok: 0,
+                errmsg: error.message || 'Failed to create index',
+                code: error.code || 1,
+                codeName: error.codeName || 'InternalError',
+            };
+        }
+        return {
+            ok: 1,
+            numIndexesBefore,
+            numIndexesAfter,
+            createdCollectionAutomatically: false,
+            commitQuorum: 'votingMembers',
+        };
+    }
+    /**
+     * Handle dropIndexes command
+     */
+    async handleDropIndexes(context) {
+        const { storage, database, command } = context;
+        const collection = command.dropIndexes;
+        const indexName = command.index;
+        // Check if collection exists
+        const exists = await storage.collectionExists(database, collection);
+        if (!exists) {
+            return {
+                ok: 0,
+                errmsg: `ns not found ${database}.${collection}`,
+                code: 26,
+                codeName: 'NamespaceNotFound',
+            };
+        }
+        const indexEngine = getIndexEngine(storage, database, collection);
+        try {
+            if (indexName === '*') {
+                // Drop all indexes except _id
+                await indexEngine.dropAllIndexes();
+            }
+            else if (typeof indexName === 'string') {
+                // Drop specific index by name
+                await indexEngine.dropIndex(indexName);
+            }
+            else if (typeof indexName === 'object') {
+                // Drop index by key specification
+                const indexes = await indexEngine.listIndexes();
+                const keyStr = JSON.stringify(indexName);
+                for (const idx of indexes) {
+                    if (JSON.stringify(idx.key) === keyStr) {
+                        await indexEngine.dropIndex(idx.name);
+                        break;
+                    }
+                }
+            }
+            return { ok: 1, nIndexesWas: 1 };
+        }
+        catch (error) {
+            return {
+                ok: 0,
+                errmsg: error.message || 'Failed to drop index',
+                code: error.code || 27,
+                codeName: error.codeName || 'IndexNotFound',
+            };
+        }
+    }
+    /**
+     * Handle listIndexes command
+     */
+    async handleListIndexes(context) {
+        const { storage, database, command } = context;
+        const collection = command.listIndexes;
+        const cursor = command.cursor || {};
+        const batchSize = cursor.batchSize || 101;
+        // Check if collection exists
+        const exists = await storage.collectionExists(database, collection);
+        if (!exists) {
+            return {
+                ok: 0,
+                errmsg: `ns not found ${database}.${collection}`,
+                code: 26,
+                codeName: 'NamespaceNotFound',
+            };
+        }
+        const indexEngine = getIndexEngine(storage, database, collection);
+        const indexes = await indexEngine.listIndexes();
+        // Format indexes for response
+        const indexDocs = indexes.map(idx => ({
+            v: idx.v || 2,
+            key: idx.key,
+            name: idx.name,
+            ...(idx.unique ? { unique: idx.unique } : {}),
+            ...(idx.sparse ? { sparse: idx.sparse } : {}),
+            ...(idx.expireAfterSeconds !== undefined ? { expireAfterSeconds: idx.expireAfterSeconds } : {}),
+        }));
+        return {
+            ok: 1,
+            cursor: {
+                id: plugins.bson.Long.fromNumber(0),
+                ns: `${database}.${collection}`,
+                firstBatch: indexDocs,
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/{congodb → tsmdb}/server/handlers/InsertHandler.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
 /**
  * InsertHandler - Handles insert commands

package/dist_ts/tsmdb/server/handlers/InsertHandler.js

@@ -0,0 +1,76 @@
+import * as plugins from '../../tsmdb.plugins.js';
+/**
+ * InsertHandler - Handles insert commands
+ */
+export class InsertHandler {
+    async handle(context) {
+        const { storage, database, command, documentSequences } = context;
+        const collection = command.insert;
+        if (typeof collection !== 'string') {
+            return {
+                ok: 0,
+                errmsg: 'insert command requires a collection name',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Get documents from command or document sequences
+        let documents = command.documents || [];
+        // Check for OP_MSG document sequences (for bulk inserts)
+        if (documentSequences && documentSequences.has('documents')) {
+            documents = documentSequences.get('documents');
+        }
+        if (!Array.isArray(documents) || documents.length === 0) {
+            return {
+                ok: 0,
+                errmsg: 'insert command requires documents array',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        const ordered = command.ordered !== false;
+        const writeErrors = [];
+        let insertedCount = 0;
+        // Ensure collection exists
+        await storage.createCollection(database, collection);
+        // Insert documents
+        for (let i = 0; i < documents.length; i++) {
+            const doc = documents[i];
+            try {
+                // Ensure _id exists
+                if (!doc._id) {
+                    doc._id = new plugins.bson.ObjectId();
+                }
+                await storage.insertOne(database, collection, doc);
+                insertedCount++;
+            }
+            catch (error) {
+                const writeError = {
+                    index: i,
+                    code: error.code || 11000,
+                    errmsg: error.message || 'Insert failed',
+                };
+                // Check for duplicate key error
+                if (error.message?.includes('Duplicate key')) {
+                    writeError.code = 11000;
+                    writeError.keyPattern = { _id: 1 };
+                    writeError.keyValue = { _id: doc._id };
+                }
+                writeErrors.push(writeError);
+                if (ordered) {
+                    // Stop on first error for ordered inserts
+                    break;
+                }
+            }
+        }
+        const response = {
+            ok: 1,
+            n: insertedCount,
+        };
+        if (writeErrors.length > 0) {
+            response.writeErrors = writeErrors;
+        }
+        return response;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zZXJ0SGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL3RzbWRiL3NlcnZlci9oYW5kbGVycy9JbnNlcnRIYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sd0JBQXdCLENBQUM7QUFHbEQ7O0dBRUc7QUFDSCxNQUFNLE9BQU8sYUFBYTtJQUN4QixLQUFLLENBQUMsTUFBTSxDQUFDLE9BQXdCO1FBQ25DLE1BQU0sRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUVsRSxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDO1FBQ2xDLElBQUksT0FBTyxVQUFVLEtBQUssUUFBUSxFQUFFLENBQUM7WUFDbkMsT0FBTztnQkFDTCxFQUFFLEVBQUUsQ0FBQztnQkFDTCxNQUFNLEVBQUUsMkNBQTJDO2dCQUNuRCxJQUFJLEVBQUUsQ0FBQztnQkFDUCxRQUFRLEVBQUUsVUFBVTthQUNyQixDQUFDO1FBQ0osQ0FBQztRQUVELG1EQUFtRDtRQUNuRCxJQUFJLFNBQVMsR0FBNEIsT0FBTyxDQUFDLFNBQVMsSUFBSSxFQUFFLENBQUM7UUFFakUseURBQXlEO1FBQ3pELElBQUksaUJBQWlCLElBQUksaUJBQWlCLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBQyxFQUFFLENBQUM7WUFDNUQsU0FBUyxHQUFHLGlCQUFpQixDQUFDLEdBQUcsQ0FBQyxXQUFXLENBQUUsQ0FBQztRQUNsRCxDQUFDO1FBRUQsSUFBSSxDQUFDLEtBQUssQ0FBQyxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksU0FBUyxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN4RCxPQUFPO2dCQUNMLEVBQUUsRUFBRSxDQUFDO2dCQUNMLE1BQU0sRUFBRSx5Q0FBeUM7Z0JBQ2pELElBQUksRUFBRSxDQUFDO2dCQUNQLFFBQVEsRUFBRSxVQUFVO2FBQ3JCLENBQUM7UUFDSixDQUFDO1FBRUQsTUFBTSxPQUFPLEdBQUcsT0FBTyxDQUFDLE9BQU8sS0FBSyxLQUFLLENBQUM7UUFDMUMsTUFBTSxXQUFXLEdBQTRCLEVBQUUsQ0FBQztRQUNoRCxJQUFJLGFBQWEsR0FBRyxDQUFDLENBQUM7UUFFdEIsMkJBQTJCO1FBQzNCLE1BQU0sT0FBTyxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUVyRCxtQkFBbUI7UUFDbkIsS0FBSyxJQUFJLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLFNBQVMsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztZQUMxQyxNQUFNLEdBQUcsR0FBRyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUM7WUFFekIsSUFBSSxDQUFDO2dCQUNILG9CQUFvQjtnQkFDcEIsSUFBSSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsQ0FBQztvQkFDYixHQUFHLENBQUMsR0FBRyxHQUFHLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUUsQ0FBQztnQkFDeEMsQ0FBQztnQkFFRCxNQUFNLE9BQU8sQ0FBQyxTQUFTLENBQUMsUUFBUSxFQUFFLFVBQVUsRUFBRSxHQUFHLENBQUMsQ0FBQztnQkFDbkQsYUFBYSxFQUFFLENBQUM7WUFDbEIsQ0FBQztZQUFDLE9BQU8sS0FBVSxFQUFFLENBQUM7Z0JBQ3BCLE1BQU0sVUFBVSxHQUEwQjtvQkFDeEMsS0FBSyxFQUFFLENBQUM7b0JBQ1IsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLElBQUksS0FBSztvQkFDekIsTUFBTSxFQUFFLEtBQUssQ0FBQyxPQUFPLElBQUksZUFBZTtpQkFDekMsQ0FBQztnQkFFRixnQ0FBZ0M7Z0JBQ2hDLElBQUksS0FBSyxDQUFDLE9BQU8sRUFBRSxRQUFRLENBQUMsZUFBZSxDQUFDLEVBQUUsQ0FBQztvQkFDN0MsVUFBVSxDQUFDLElBQUksR0FBRyxLQUFLLENBQUM7b0JBQ3hCLFVBQVUsQ0FBQyxVQUFVLEdBQUcsRUFBRSxHQUFHLEVBQUUsQ0FBQyxFQUFFLENBQUM7b0JBQ25DLFVBQVUsQ0FBQyxRQUFRLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDO2dCQUN6QyxDQUFDO2dCQUVELFdBQVcsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7Z0JBRTdCLElBQUksT0FBTyxFQUFFLENBQUM7b0JBQ1osMENBQTBDO29CQUMxQyxNQUFNO2dCQUNSLENBQUM7WUFDSCxDQUFDO1FBQ0gsQ0FBQztRQUVELE1BQU0sUUFBUSxHQUEwQjtZQUN0QyxFQUFFLEVBQUUsQ0FBQztZQUNMLENBQUMsRUFBRSxhQUFhO1NBQ2pCLENBQUM7UUFFRixJQUFJLFdBQVcsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDM0IsUUFBUSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDckMsQ0FBQztRQUVELE9BQU8sUUFBUSxDQUFDO0lBQ2xCLENBQUM7Q0FDRiJ9

package/dist_ts/{congodb → tsmdb}/server/handlers/UpdateHandler.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
 /**
  * UpdateHandler - Handles update, findAndModify commands