@push.rocks/smartmongo 2.0.14 → 2.2.0

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

@@ -0,0 +1,261 @@
+import * as plugins from '../../congodb.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/congodb/server/handlers/FindHandler.ts"],"names":[],"mappings":"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"}

package/dist_ts/congodb/server/handlers/HelloHandler.d.ts

@@ -0,0 +1,11 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+/**
+ * HelloHandler - Handles hello/isMaster handshake commands
+ *
+ * This is the first command sent by MongoDB drivers to establish a connection.
+ * It returns server capabilities and configuration.
+ */
+export declare class HelloHandler implements ICommandHandler {
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+}

package/dist_ts/congodb/server/handlers/HelloHandler.js

@@ -0,0 +1,62 @@
+import * as plugins from '../../congodb.plugins.js';
+/**
+ * HelloHandler - Handles hello/isMaster handshake commands
+ *
+ * This is the first command sent by MongoDB drivers to establish a connection.
+ * It returns server capabilities and configuration.
+ */
+export class HelloHandler {
+    async handle(context) {
+        const { command, server } = context;
+        // Build response with server capabilities
+        const response = {
+            ismaster: true,
+            ok: 1,
+            // Maximum sizes
+            maxBsonObjectSize: 16777216, // 16 MB
+            maxMessageSizeBytes: 48000000, // 48 MB
+            maxWriteBatchSize: 100000, // 100k documents per batch
+            // Timestamps
+            localTime: new Date(),
+            // Session support
+            logicalSessionTimeoutMinutes: 30,
+            // Connection info
+            connectionId: 1,
+            // Wire protocol versions (support MongoDB 3.6 through 7.0)
+            minWireVersion: 0,
+            maxWireVersion: 21,
+            // Server mode
+            readOnly: false,
+            // Topology info (standalone mode)
+            isWritablePrimary: true,
+            // Additional info
+            topologyVersion: {
+                processId: new plugins.bson.ObjectId(),
+                counter: plugins.bson.Long.fromNumber(0),
+            },
+        };
+        // Handle hello-specific fields
+        if (command.hello || command.hello === 1) {
+            response.helloOk = true;
+        }
+        // Handle client metadata
+        if (command.client) {
+            // Client is providing metadata about itself
+            // We just acknowledge it - no need to do anything special
+        }
+        // Handle SASL mechanisms query
+        if (command.saslSupportedMechs) {
+            response.saslSupportedMechs = [
+            // We don't actually support auth, but the driver needs to see this
+            ];
+        }
+        // Compression support (none for now)
+        if (command.compression) {
+            response.compression = [];
+        }
+        // Server version info
+        response.version = '7.0.0';
+        return response;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSGVsbG9IYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvY29uZ29kYi9zZXJ2ZXIvaGFuZGxlcnMvSGVsbG9IYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sMEJBQTBCLENBQUM7QUFHcEQ7Ozs7O0dBS0c7QUFDSCxNQUFNLE9BQU8sWUFBWTtJQUN2QixLQUFLLENBQUMsTUFBTSxDQUFDLE9BQXdCO1FBQ25DLE1BQU0sRUFBRSxPQUFPLEVBQUUsTUFBTSxFQUFFLEdBQUcsT0FBTyxDQUFDO1FBRXBDLDBDQUEwQztRQUMxQyxNQUFNLFFBQVEsR0FBMEI7WUFDdEMsUUFBUSxFQUFFLElBQUk7WUFDZCxFQUFFLEVBQUUsQ0FBQztZQUVMLGdCQUFnQjtZQUNoQixpQkFBaUIsRUFBRSxRQUFRLEVBQVksUUFBUTtZQUMvQyxtQkFBbUIsRUFBRSxRQUFRLEVBQVUsUUFBUTtZQUMvQyxpQkFBaUIsRUFBRSxNQUFNLEVBQWMsMkJBQTJCO1lBRWxFLGFBQWE7WUFDYixTQUFTLEVBQUUsSUFBSSxJQUFJLEVBQUU7WUFFckIsa0JBQWtCO1lBQ2xCLDRCQUE0QixFQUFFLEVBQUU7WUFFaEMsa0JBQWtCO1lBQ2xCLFlBQVksRUFBRSxDQUFDO1lBRWYsMkRBQTJEO1lBQzNELGNBQWMsRUFBRSxDQUFDO1lBQ2pCLGNBQWMsRUFBRSxFQUFFO1lBRWxCLGNBQWM7WUFDZCxRQUFRLEVBQUUsS0FBSztZQUVmLGtDQUFrQztZQUNsQyxpQkFBaUIsRUFBRSxJQUFJO1lBRXZCLGtCQUFrQjtZQUNsQixlQUFlLEVBQUU7Z0JBQ2YsU0FBUyxFQUFFLElBQUksT0FBTyxDQUFDLElBQUksQ0FBQyxRQUFRLEVBQUU7Z0JBQ3RDLE9BQU8sRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO2FBQ3pDO1NBQ0YsQ0FBQztRQUVGLCtCQUErQjtRQUMvQixJQUFJLE9BQU8sQ0FBQyxLQUFLLElBQUksT0FBTyxDQUFDLEtBQUssS0FBSyxDQUFDLEVBQUUsQ0FBQztZQUN6QyxRQUFRLENBQUMsT0FBTyxHQUFHLElBQUksQ0FBQztRQUMxQixDQUFDO1FBRUQseUJBQXlCO1FBQ3pCLElBQUksT0FBTyxDQUFDLE1BQU0sRUFBRSxDQUFDO1lBQ25CLDRDQUE0QztZQUM1QywwREFBMEQ7UUFDNUQsQ0FBQztRQUVELCtCQUErQjtRQUMvQixJQUFJLE9BQU8sQ0FBQyxrQkFBa0IsRUFBRSxDQUFDO1lBQy9CLFFBQVEsQ0FBQyxrQkFBa0IsR0FBRztZQUM1QixtRUFBbUU7YUFDcEUsQ0FBQztRQUNKLENBQUM7UUFFRCxxQ0FBcUM7UUFDckMsSUFBSSxPQUFPLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDeEIsUUFBUSxDQUFDLFdBQVcsR0FBRyxFQUFFLENBQUM7UUFDNUIsQ0FBQztRQUVELHNCQUFzQjtRQUN0QixRQUFRLENBQUMsT0FBTyxHQUFHLE9BQU8sQ0FBQztRQUUzQixPQUFPLFFBQVEsQ0FBQztJQUNsQixDQUFDO0NBQ0YifQ==

package/dist_ts/congodb/server/handlers/IndexHandler.d.ts

@@ -0,0 +1,20 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+/**
+ * IndexHandler - Handles createIndexes, dropIndexes, listIndexes commands
+ */
+export declare class IndexHandler implements ICommandHandler {
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+    /**
+     * Handle createIndexes command
+     */
+    private handleCreateIndexes;
+    /**
+     * Handle dropIndexes command
+     */
+    private handleDropIndexes;
+    /**
+     * Handle listIndexes command
+     */
+    private handleListIndexes;
+}

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

@@ -0,0 +1,183 @@
+import * as plugins from '../../congodb.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5kZXhIYW5kbGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vdHMvY29uZ29kYi9zZXJ2ZXIvaGFuZGxlcnMvSW5kZXhIYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sS0FBSyxPQUFPLE1BQU0sMEJBQTBCLENBQUM7QUFFcEQsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLDZCQUE2QixDQUFDO0FBRTFELHdDQUF3QztBQUN4QyxNQUFNLFlBQVksR0FBNkIsSUFBSSxHQUFHLEVBQUUsQ0FBQztBQUV6RDs7R0FFRztBQUNILFNBQVMsY0FBYyxDQUFDLE9BQVksRUFBRSxRQUFnQixFQUFFLFVBQWtCO0lBQ3hFLE1BQU0sR0FBRyxHQUFHLEdBQUcsUUFBUSxJQUFJLFVBQVUsRUFBRSxDQUFDO0lBQ3hDLElBQUksTUFBTSxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLENBQUM7SUFFbkMsSUFBSSxDQUFDLE1BQU0sRUFBRSxDQUFDO1FBQ1osTUFBTSxHQUFHLElBQUksV0FBVyxDQUFDLFFBQVEsRUFBRSxVQUFVLEVBQUUsT0FBTyxDQUFDLENBQUM7UUFDeEQsWUFBWSxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDaEMsQ0FBQztJQUVELE9BQU8sTUFBTSxDQUFDO0FBQ2hCLENBQUM7QUFFRDs7R0FFRztBQUNILE1BQU0sT0FBTyxZQUFZO0lBQ3ZCLEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBd0I7UUFDbkMsTUFBTSxFQUFFLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUU1QixJQUFJLE9BQU8sQ0FBQyxhQUFhLEVBQUUsQ0FBQztZQUMxQixPQUFPLElBQUksQ0FBQyxtQkFBbUIsQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUMzQyxDQUFDO2FBQU0sSUFBSSxPQUFPLENBQUMsV0FBVyxFQUFFLENBQUM7WUFDL0IsT0FBTyxJQUFJLENBQUMsaUJBQWlCLENBQUMsT0FBTyxDQUFDLENBQUM7UUFDekMsQ0FBQzthQUFNLElBQUksT0FBTyxDQUFDLFdBQVcsRUFBRSxDQUFDO1lBQy9CLE9BQU8sSUFBSSxDQUFDLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxDQUFDO1FBQ3pDLENBQUM7UUFFRCxPQUFPO1lBQ0wsRUFBRSxFQUFFLENBQUM7WUFDTCxNQUFNLEVBQUUsdUJBQXVCO1lBQy9CLElBQUksRUFBRSxFQUFFO1lBQ1IsUUFBUSxFQUFFLGlCQUFpQjtTQUM1QixDQUFDO0lBQ0osQ0FBQztJQUVEOztPQUVHO0lBQ0ssS0FBSyxDQUFDLG1CQUFtQixDQUFDLE9BQXdCO1FBQ3hELE1BQU0sRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUUvQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsYUFBYSxDQUFDO1FBQ3pDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxPQUFPLElBQUksRUFBRSxDQUFDO1FBRXRDLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLE9BQU8sQ0FBQyxFQUFFLENBQUM7WUFDNUIsT0FBTztnQkFDTCxFQUFFLEVBQUUsQ0FBQztnQkFDTCxNQUFNLEVBQUUsMEJBQTBCO2dCQUNsQyxJQUFJLEVBQUUsQ0FBQztnQkFDUCxRQUFRLEVBQUUsVUFBVTthQUNyQixDQUFDO1FBQ0osQ0FBQztRQUVELDJCQUEyQjtRQUMzQixNQUFNLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxRQUFRLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFFckQsTUFBTSxXQUFXLEdBQUcsY0FBYyxDQUFDLE9BQU8sRUFBRSxRQUFRLEVBQUUsVUFBVSxDQUFDLENBQUM7UUFDbEUsTUFBTSxZQUFZLEdBQWEsRUFBRSxDQUFDO1FBQ2xDLElBQUksZ0JBQWdCLEdBQUcsQ0FBQyxDQUFDO1FBQ3pCLElBQUksZUFBZSxHQUFHLENBQUMsQ0FBQztRQUV4QixJQUFJLENBQUM7WUFDSCxNQUFNLGVBQWUsR0FBRyxNQUFNLFdBQVcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUN4RCxnQkFBZ0IsR0FBRyxlQUFlLENBQUMsTUFBTSxDQUFDO1lBRTFDLEtBQUssTUFBTSxTQUFTLElBQUksT0FBTyxFQUFFLENBQUM7Z0JBQ2hDLE1BQU0sR0FBRyxHQUFHLFNBQVMsQ0FBQyxHQUFHLENBQUM7Z0JBQzFCLE1BQU0sT0FBTyxHQUFHO29CQUNkLElBQUksRUFBRSxTQUFTLENBQUMsSUFBSTtvQkFDcEIsTUFBTSxFQUFFLFNBQVMsQ0FBQyxNQUFNO29CQUN4QixNQUFNLEVBQUUsU0FBUyxDQUFDLE1BQU07b0JBQ3hCLGtCQUFrQixFQUFFLFNBQVMsQ0FBQyxrQkFBa0I7b0JBQ2hELFVBQVUsRUFBRSxTQUFTLENBQUMsVUFBVTtvQkFDaEMsdUJBQXVCLEVBQUUsU0FBUyxDQUFDLHVCQUF1QjtpQkFDM0QsQ0FBQztnQkFFRixNQUFNLElBQUksR0FBRyxNQUFNLFdBQVcsQ0FBQyxXQUFXLENBQUMsR0FBRyxFQUFFLE9BQU8sQ0FBQyxDQUFDO2dCQUN6RCxZQUFZLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxDQUFDO1lBQzFCLENBQUM7WUFFRCxNQUFNLFlBQVksR0FBRyxNQUFNLFdBQVcsQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUNyRCxlQUFlLEdBQUcsWUFBWSxDQUFDLE1BQU0sQ0FBQztRQUN4QyxDQUFDO1FBQUMsT0FBTyxLQUFVLEVBQUUsQ0FBQztZQUNwQixPQUFPO2dCQUNMLEVBQUUsRUFBRSxDQUFDO2dCQUNMLE1BQU0sRUFBRSxLQUFLLENBQUMsT0FBTyxJQUFJLHdCQUF3QjtnQkFDakQsSUFBSSxFQUFFLEtBQUssQ0FBQyxJQUFJLElBQUksQ0FBQztnQkFDckIsUUFBUSxFQUFFLEtBQUssQ0FBQyxRQUFRLElBQUksZUFBZTthQUM1QyxDQUFDO1FBQ0osQ0FBQztRQUVELE9BQU87WUFDTCxFQUFFLEVBQUUsQ0FBQztZQUNMLGdCQUFnQjtZQUNoQixlQUFlO1lBQ2YsOEJBQThCLEVBQUUsS0FBSztZQUNyQyxZQUFZLEVBQUUsZUFBZTtTQUM5QixDQUFDO0lBQ0osQ0FBQztJQUVEOztPQUVHO0lBQ0ssS0FBSyxDQUFDLGlCQUFpQixDQUFDLE9BQXdCO1FBQ3RELE1BQU0sRUFBRSxPQUFPLEVBQUUsUUFBUSxFQUFFLE9BQU8sRUFBRSxHQUFHLE9BQU8sQ0FBQztRQUUvQyxNQUFNLFVBQVUsR0FBRyxPQUFPLENBQUMsV0FBVyxDQUFDO1FBQ3ZDLE1BQU0sU0FBUyxHQUFHLE9BQU8sQ0FBQyxLQUFLLENBQUM7UUFFaEMsNkJBQTZCO1FBQzdCLE1BQU0sTUFBTSxHQUFHLE1BQU0sT0FBTyxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUNwRSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDWixPQUFPO2dCQUNMLEVBQUUsRUFBRSxDQUFDO2dCQUNMLE1BQU0sRUFBRSxnQkFBZ0IsUUFBUSxJQUFJLFVBQVUsRUFBRTtnQkFDaEQsSUFBSSxFQUFFLEVBQUU7Z0JBQ1IsUUFBUSxFQUFFLG1CQUFtQjthQUM5QixDQUFDO1FBQ0osQ0FBQztRQUVELE1BQU0sV0FBVyxHQUFHLGNBQWMsQ0FBQyxPQUFPLEVBQUUsUUFBUSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBRWxFLElBQUksQ0FBQztZQUNILElBQUksU0FBUyxLQUFLLEdBQUcsRUFBRSxDQUFDO2dCQUN0Qiw4QkFBOEI7Z0JBQzlCLE1BQU0sV0FBVyxDQUFDLGNBQWMsRUFBRSxDQUFDO1lBQ3JDLENBQUM7aUJBQU0sSUFBSSxPQUFPLFNBQVMsS0FBSyxRQUFRLEVBQUUsQ0FBQztnQkFDekMsOEJBQThCO2dCQUM5QixNQUFNLFdBQVcsQ0FBQyxTQUFTLENBQUMsU0FBUyxDQUFDLENBQUM7WUFDekMsQ0FBQztpQkFBTSxJQUFJLE9BQU8sU0FBUyxLQUFLLFFBQVEsRUFBRSxDQUFDO2dCQUN6QyxrQ0FBa0M7Z0JBQ2xDLE1BQU0sT0FBTyxHQUFHLE1BQU0sV0FBVyxDQUFDLFdBQVcsRUFBRSxDQUFDO2dCQUNoRCxNQUFNLE1BQU0sR0FBRyxJQUFJLENBQUMsU0FBUyxDQUFDLFNBQVMsQ0FBQyxDQUFDO2dCQUV6QyxLQUFLLE1BQU0sR0FBRyxJQUFJLE9BQU8sRUFBRSxDQUFDO29CQUMxQixJQUFJLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxLQUFLLE1BQU0sRUFBRSxDQUFDO3dCQUN2QyxNQUFNLFdBQVcsQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLElBQUksQ0FBQyxDQUFDO3dCQUN0QyxNQUFNO29CQUNSLENBQUM7Z0JBQ0gsQ0FBQztZQUNILENBQUM7WUFFRCxPQUFPLEVBQUUsRUFBRSxFQUFFLENBQUMsRUFBRSxXQUFXLEVBQUUsQ0FBQyxFQUFFLENBQUM7UUFDbkMsQ0FBQztRQUFDLE9BQU8sS0FBVSxFQUFFLENBQUM7WUFDcEIsT0FBTztnQkFDTCxFQUFFLEVBQUUsQ0FBQztnQkFDTCxNQUFNLEVBQUUsS0FBSyxDQUFDLE9BQU8sSUFBSSxzQkFBc0I7Z0JBQy9DLElBQUksRUFBRSxLQUFLLENBQUMsSUFBSSxJQUFJLEVBQUU7Z0JBQ3RCLFFBQVEsRUFBRSxLQUFLLENBQUMsUUFBUSxJQUFJLGVBQWU7YUFDNUMsQ0FBQztRQUNKLENBQUM7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSyxLQUFLLENBQUMsaUJBQWlCLENBQUMsT0FBd0I7UUFDdEQsTUFBTSxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLEdBQUcsT0FBTyxDQUFDO1FBRS9DLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxXQUFXLENBQUM7UUFDdkMsTUFBTSxNQUFNLEdBQUcsT0FBTyxDQUFDLE1BQU0sSUFBSSxFQUFFLENBQUM7UUFDcEMsTUFBTSxTQUFTLEdBQUcsTUFBTSxDQUFDLFNBQVMsSUFBSSxHQUFHLENBQUM7UUFFMUMsNkJBQTZCO1FBQzdCLE1BQU0sTUFBTSxHQUFHLE1BQU0sT0FBTyxDQUFDLGdCQUFnQixDQUFDLFFBQVEsRUFBRSxVQUFVLENBQUMsQ0FBQztRQUNwRSxJQUFJLENBQUMsTUFBTSxFQUFFLENBQUM7WUFDWixPQUFPO2dCQUNMLEVBQUUsRUFBRSxDQUFDO2dCQUNMLE1BQU0sRUFBRSxnQkFBZ0IsUUFBUSxJQUFJLFVBQVUsRUFBRTtnQkFDaEQsSUFBSSxFQUFFLEVBQUU7Z0JBQ1IsUUFBUSxFQUFFLG1CQUFtQjthQUM5QixDQUFDO1FBQ0osQ0FBQztRQUVELE1BQU0sV0FBVyxHQUFHLGNBQWMsQ0FBQyxPQUFPLEVBQUUsUUFBUSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBQ2xFLE1BQU0sT0FBTyxHQUFHLE1BQU0sV0FBVyxDQUFDLFdBQVcsRUFBRSxDQUFDO1FBRWhELDhCQUE4QjtRQUM5QixNQUFNLFNBQVMsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsQ0FBQztZQUNwQyxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUMsSUFBSSxDQUFDO1lBQ2IsR0FBRyxFQUFFLEdBQUcsQ0FBQyxHQUFHO1lBQ1osSUFBSSxFQUFFLEdBQUcsQ0FBQyxJQUFJO1lBQ2QsR0FBRyxDQUFDLEdBQUcsQ0FBQyxNQUFNLENBQUMsQ0FBQyxDQUFDLEVBQUUsTUFBTSxFQUFFLEdBQUcsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1lBQzdDLEdBQUcsQ0FBQyxHQUFHLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLE1BQU0sRUFBRSxHQUFHLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQztZQUM3QyxHQUFHLENBQUMsR0FBRyxDQUFDLGtCQUFrQixLQUFLLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxrQkFBa0IsRUFBRSxHQUFHLENBQUMsa0JBQWtCLEVBQUUsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDO1NBQ2hHLENBQUMsQ0FBQyxDQUFDO1FBRUosT0FBTztZQUNMLEVBQUUsRUFBRSxDQUFDO1lBQ0wsTUFBTSxFQUFFO2dCQUNOLEVBQUUsRUFBRSxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO2dCQUNuQyxFQUFFLEVBQUUsR0FBRyxRQUFRLElBQUksVUFBVSxFQUFFO2dCQUMvQixVQUFVLEVBQUUsU0FBUzthQUN0QjtTQUNGLENBQUM7SUFDSixDQUFDO0NBQ0YifQ==

package/dist_ts/congodb/server/handlers/InsertHandler.d.ts

@@ -0,0 +1,8 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+/**
+ * InsertHandler - Handles insert commands
+ */
+export declare class InsertHandler implements ICommandHandler {
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+}

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

@@ -0,0 +1,76 @@
+import * as plugins from '../../congodb.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiSW5zZXJ0SGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3RzL2NvbmdvZGIvc2VydmVyL2hhbmRsZXJzL0luc2VydEhhbmRsZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSwwQkFBMEIsQ0FBQztBQUdwRDs7R0FFRztBQUNILE1BQU0sT0FBTyxhQUFhO0lBQ3hCLEtBQUssQ0FBQyxNQUFNLENBQUMsT0FBd0I7UUFDbkMsTUFBTSxFQUFFLE9BQU8sRUFBRSxRQUFRLEVBQUUsT0FBTyxFQUFFLGlCQUFpQixFQUFFLEdBQUcsT0FBTyxDQUFDO1FBRWxFLE1BQU0sVUFBVSxHQUFHLE9BQU8sQ0FBQyxNQUFNLENBQUM7UUFDbEMsSUFBSSxPQUFPLFVBQVUsS0FBSyxRQUFRLEVBQUUsQ0FBQztZQUNuQyxPQUFPO2dCQUNMLEVBQUUsRUFBRSxDQUFDO2dCQUNMLE1BQU0sRUFBRSwyQ0FBMkM7Z0JBQ25ELElBQUksRUFBRSxDQUFDO2dCQUNQLFFBQVEsRUFBRSxVQUFVO2FBQ3JCLENBQUM7UUFDSixDQUFDO1FBRUQsbURBQW1EO1FBQ25ELElBQUksU0FBUyxHQUE0QixPQUFPLENBQUMsU0FBUyxJQUFJLEVBQUUsQ0FBQztRQUVqRSx5REFBeUQ7UUFDekQsSUFBSSxpQkFBaUIsSUFBSSxpQkFBaUIsQ0FBQyxHQUFHLENBQUMsV0FBVyxDQUFDLEVBQUUsQ0FBQztZQUM1RCxTQUFTLEdBQUcsaUJBQWlCLENBQUMsR0FBRyxDQUFDLFdBQVcsQ0FBRSxDQUFDO1FBQ2xELENBQUM7UUFFRCxJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxTQUFTLENBQUMsSUFBSSxTQUFTLENBQUMsTUFBTSxLQUFLLENBQUMsRUFBRSxDQUFDO1lBQ3hELE9BQU87Z0JBQ0wsRUFBRSxFQUFFLENBQUM7Z0JBQ0wsTUFBTSxFQUFFLHlDQUF5QztnQkFDakQsSUFBSSxFQUFFLENBQUM7Z0JBQ1AsUUFBUSxFQUFFLFVBQVU7YUFDckIsQ0FBQztRQUNKLENBQUM7UUFFRCxNQUFNLE9BQU8sR0FBRyxPQUFPLENBQUMsT0FBTyxLQUFLLEtBQUssQ0FBQztRQUMxQyxNQUFNLFdBQVcsR0FBNEIsRUFBRSxDQUFDO1FBQ2hELElBQUksYUFBYSxHQUFHLENBQUMsQ0FBQztRQUV0QiwyQkFBMkI7UUFDM0IsTUFBTSxPQUFPLENBQUMsZ0JBQWdCLENBQUMsUUFBUSxFQUFFLFVBQVUsQ0FBQyxDQUFDO1FBRXJELG1CQUFtQjtRQUNuQixLQUFLLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDLEdBQUcsU0FBUyxDQUFDLE1BQU0sRUFBRSxDQUFDLEVBQUUsRUFBRSxDQUFDO1lBQzFDLE1BQU0sR0FBRyxHQUFHLFNBQVMsQ0FBQyxDQUFDLENBQUMsQ0FBQztZQUV6QixJQUFJLENBQUM7Z0JBQ0gsb0JBQW9CO2dCQUNwQixJQUFJLENBQUMsR0FBRyxDQUFDLEdBQUcsRUFBRSxDQUFDO29CQUNiLEdBQUcsQ0FBQyxHQUFHLEdBQUcsSUFBSSxPQUFPLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBRSxDQUFDO2dCQUN4QyxDQUFDO2dCQUVELE1BQU0sT0FBTyxDQUFDLFNBQVMsQ0FBQyxRQUFRLEVBQUUsVUFBVSxFQUFFLEdBQUcsQ0FBQyxDQUFDO2dCQUNuRCxhQUFhLEVBQUUsQ0FBQztZQUNsQixDQUFDO1lBQUMsT0FBTyxLQUFVLEVBQUUsQ0FBQztnQkFDcEIsTUFBTSxVQUFVLEdBQTBCO29CQUN4QyxLQUFLLEVBQUUsQ0FBQztvQkFDUixJQUFJLEVBQUUsS0FBSyxDQUFDLElBQUksSUFBSSxLQUFLO29CQUN6QixNQUFNLEVBQUUsS0FBSyxDQUFDLE9BQU8sSUFBSSxlQUFlO2lCQUN6QyxDQUFDO2dCQUVGLGdDQUFnQztnQkFDaEMsSUFBSSxLQUFLLENBQUMsT0FBTyxFQUFFLFFBQVEsQ0FBQyxlQUFlLENBQUMsRUFBRSxDQUFDO29CQUM3QyxVQUFVLENBQUMsSUFBSSxHQUFHLEtBQUssQ0FBQztvQkFDeEIsVUFBVSxDQUFDLFVBQVUsR0FBRyxFQUFFLEdBQUcsRUFBRSxDQUFDLEVBQUUsQ0FBQztvQkFDbkMsVUFBVSxDQUFDLFFBQVEsR0FBRyxFQUFFLEdBQUcsRUFBRSxHQUFHLENBQUMsR0FBRyxFQUFFLENBQUM7Z0JBQ3pDLENBQUM7Z0JBRUQsV0FBVyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQztnQkFFN0IsSUFBSSxPQUFPLEVBQUUsQ0FBQztvQkFDWiwwQ0FBMEM7b0JBQzFDLE1BQU07Z0JBQ1IsQ0FBQztZQUNILENBQUM7UUFDSCxDQUFDO1FBRUQsTUFBTSxRQUFRLEdBQTBCO1lBQ3RDLEVBQUUsRUFBRSxDQUFDO1lBQ0wsQ0FBQyxFQUFFLGFBQWE7U0FDakIsQ0FBQztRQUVGLElBQUksV0FBVyxDQUFDLE1BQU0sR0FBRyxDQUFDLEVBQUUsQ0FBQztZQUMzQixRQUFRLENBQUMsV0FBVyxHQUFHLFdBQVcsQ0FBQztRQUNyQyxDQUFDO1FBRUQsT0FBTyxRQUFRLENBQUM7SUFDbEIsQ0FBQztDQUNGIn0=