@push.rocks/smartdb 1.0.1

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

@@ -0,0 +1,291 @@
+import * as plugins from '../../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, getIndexEngine } = 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: [],
+                },
+            };
+        }
+        // Try to use index-accelerated query
+        const indexEngine = getIndexEngine(collection);
+        const candidateIds = await indexEngine.findCandidateIds(filter);
+        let documents;
+        if (candidateIds !== null) {
+            // Index hit - fetch only candidate documents
+            documents = await storage.findByIds(database, collection, candidateIds);
+            // Still apply filter for any conditions the index couldn't fully satisfy
+            documents = QueryEngine.filter(documents, filter);
+        }
+        else {
+            // No suitable index - full collection scan
+            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, getIndexEngine } = 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 };
+        }
+        // Try to use index-accelerated query
+        const indexEngine = getIndexEngine(collection);
+        const candidateIds = await indexEngine.findCandidateIds(query);
+        let documents;
+        if (candidateIds !== null) {
+            // Index hit - fetch only candidate documents
+            documents = await storage.findByIds(database, collection, candidateIds);
+            documents = QueryEngine.filter(documents, query);
+        }
+        else {
+            // No suitable index - full collection scan
+            documents = await storage.findAll(database, collection);
+            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, getIndexEngine } = 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: [] };
+        }
+        // Try to use index-accelerated query
+        const indexEngine = getIndexEngine(collection);
+        const candidateIds = await indexEngine.findCandidateIds(query);
+        let documents;
+        if (candidateIds !== null) {
+            documents = await storage.findByIds(database, collection, candidateIds);
+        }
+        else {
+            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/ts_smartdb/server/handlers/FindHandler.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,11 @@
+import * as plugins from '../../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/ts_smartdb/server/handlers/HelloHandler.js

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

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

@@ -0,0 +1,20 @@
+import * as plugins from '../../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/ts_smartdb/server/handlers/IndexHandler.js

@@ -0,0 +1,183 @@
+import * as plugins from '../../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/ts_smartdb/server/handlers/InsertHandler.d.ts

@@ -0,0 +1,8 @@
+import * as plugins from '../../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>;
+}