@push.rocks/smartmongo 2.0.12 → 2.1.0

package/ts/congodb/server/handlers/FindHandler.ts

@@ -0,0 +1,301 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext, ICursorState } from '../CommandRouter.js';
+import { QueryEngine } from '../../engine/QueryEngine.js';
+
+/**
+ * FindHandler - Handles find, getMore, killCursors, count, distinct commands
+ */
+export class FindHandler implements ICommandHandler {
+  private cursors: Map<bigint, ICursorState>;
+  private nextCursorId: () => bigint;
+
+  constructor(
+    cursors: Map<bigint, ICursorState>,
+    nextCursorId: () => bigint
+  ) {
+    this.cursors = cursors;
+    this.nextCursorId = nextCursorId;
+  }
+
+  async handle(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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
+   */
+  private async handleFind(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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) as any[];
+    }
+
+    // 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
+   */
+  private async handleGetMore(context: IHandlerContext): Promise<plugins.bson.Document> {
+    const { database, command } = context;
+
+    const cursorIdInput = command.getMore;
+    const collection = command.collection;
+    const batchSize = command.batchSize || 101;
+
+    // Convert cursorId to bigint
+    let cursorId: bigint;
+    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
+   */
+  private async handleKillCursors(context: IHandlerContext): Promise<plugins.bson.Document> {
+    const { command } = context;
+
+    const collection = command.killCursors;
+    const cursorIds = command.cursors || [];
+
+    const cursorsKilled: plugins.bson.Long[] = [];
+    const cursorsNotFound: plugins.bson.Long[] = [];
+    const cursorsUnknown: plugins.bson.Long[] = [];
+
+    for (const idInput of cursorIds) {
+      let cursorId: bigint;
+      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
+   */
+  private async handleCount(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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
+   */
+  private async handleDistinct(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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 };
+  }
+}

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

@@ -0,0 +1,78 @@
+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 class HelloHandler implements ICommandHandler {
+  async handle(context: IHandlerContext): Promise<plugins.bson.Document> {
+    const { command, server } = context;
+
+    // Build response with server capabilities
+    const response: plugins.bson.Document = {
+      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;
+  }
+}

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

@@ -0,0 +1,207 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+import { IndexEngine } from '../../engine/IndexEngine.js';
+
+// Cache of index engines per collection
+const indexEngines: Map<string, IndexEngine> = new Map();
+
+/**
+ * Get or create an IndexEngine for a collection
+ */
+function getIndexEngine(storage: any, database: string, collection: string): IndexEngine {
+  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 implements ICommandHandler {
+  async handle(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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
+   */
+  private async handleCreateIndexes(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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: string[] = [];
+    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: any) {
+      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
+   */
+  private async handleDropIndexes(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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: any) {
+      return {
+        ok: 0,
+        errmsg: error.message || 'Failed to drop index',
+        code: error.code || 27,
+        codeName: error.codeName || 'IndexNotFound',
+      };
+    }
+  }
+
+  /**
+   * Handle listIndexes command
+   */
+  private async handleListIndexes(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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,
+      },
+    };
+  }
+}

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

@@ -0,0 +1,91 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+
+/**
+ * InsertHandler - Handles insert commands
+ */
+export class InsertHandler implements ICommandHandler {
+  async handle(context: IHandlerContext): Promise<plugins.bson.Document> {
+    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: plugins.bson.Document[] = 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: plugins.bson.Document[] = [];
+    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: any) {
+        const writeError: plugins.bson.Document = {
+          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: plugins.bson.Document = {
+      ok: 1,
+      n: insertedCount,
+    };
+
+    if (writeErrors.length > 0) {
+      response.writeErrors = writeErrors;
+    }
+
+    return response;
+  }
+}