@push.rocks/smartdb 1.0.1 → 2.0.0

package/ts/ts_smartdb/server/handlers/FindHandler.ts

@@ -1,330 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { ICommandHandler, IHandlerContext, ICursorState } from '../CommandRouter.js';
-import type { IStoredDocument } from '../../types/interfaces.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, 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: IStoredDocument[];
-    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) 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, 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: IStoredDocument[];
-    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
-   */
-  private async handleDistinct(context: IHandlerContext): Promise<plugins.bson.Document> {
-    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: IStoredDocument[];
-    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 };
-  }
-}

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

@@ -1,78 +0,0 @@
-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 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/ts_smartdb/server/handlers/IndexHandler.ts

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

@@ -1,97 +0,0 @@
-import * as plugins from '../../plugins.js';
-import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
-import type { IStoredDocument } from '../../types/interfaces.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);
-
-    const indexEngine = context.getIndexEngine(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();
-        }
-
-        // Check index constraints before insert (doc now has _id)
-        await indexEngine.onInsert(doc as IStoredDocument);
-
-        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;
-  }
-}