@push.rocks/smartdb 1.0.1 → 2.1.1

package/ts/ts_smartdb/server/CommandRouter.ts

@@ -1,289 +0,0 @@
-import * as plugins from '../plugins.js';
-import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
-import type { IParsedCommand } from './WireProtocol.js';
-import type { SmartdbServer } from './SmartdbServer.js';
-import { IndexEngine } from '../engine/IndexEngine.js';
-import { TransactionEngine } from '../engine/TransactionEngine.js';
-import { SessionEngine } from '../engine/SessionEngine.js';
-
-// Import handlers
-import { HelloHandler } from './handlers/HelloHandler.js';
-import { InsertHandler } from './handlers/InsertHandler.js';
-import { FindHandler } from './handlers/FindHandler.js';
-import { UpdateHandler } from './handlers/UpdateHandler.js';
-import { DeleteHandler } from './handlers/DeleteHandler.js';
-import { AggregateHandler } from './handlers/AggregateHandler.js';
-import { IndexHandler } from './handlers/IndexHandler.js';
-import { AdminHandler } from './handlers/AdminHandler.js';
-
-/**
- * Handler context passed to command handlers
- */
-export interface IHandlerContext {
-  storage: IStorageAdapter;
-  server: SmartdbServer;
-  database: string;
-  command: plugins.bson.Document;
-  documentSequences?: Map<string, plugins.bson.Document[]>;
-  /** Get or create an IndexEngine for a collection */
-  getIndexEngine: (collName: string) => IndexEngine;
-  /** Transaction engine instance */
-  transactionEngine: TransactionEngine;
-  /** Current transaction ID (if in a transaction) */
-  txnId?: string;
-  /** Session ID (from lsid) */
-  sessionId?: string;
-  /** Session engine instance */
-  sessionEngine: SessionEngine;
-}
-
-/**
- * Command handler interface
- */
-export interface ICommandHandler {
-  handle(context: IHandlerContext): Promise<plugins.bson.Document>;
-}
-
-/**
- * CommandRouter - Routes incoming commands to appropriate handlers
- */
-export class CommandRouter {
-  private storage: IStorageAdapter;
-  private server: SmartdbServer;
-  private handlers: Map<string, ICommandHandler> = new Map();
-
-  // Cursor state for getMore operations
-  private cursors: Map<bigint, ICursorState> = new Map();
-  private cursorIdCounter: bigint = BigInt(1);
-
-  // Index engine cache: db.collection -> IndexEngine
-  private indexEngines: Map<string, IndexEngine> = new Map();
-
-  // Transaction engine (shared across all handlers)
-  private transactionEngine: TransactionEngine;
-
-  // Session engine (shared across all handlers)
-  private sessionEngine: SessionEngine;
-
-  constructor(storage: IStorageAdapter, server: SmartdbServer) {
-    this.storage = storage;
-    this.server = server;
-    this.transactionEngine = new TransactionEngine(storage);
-    this.sessionEngine = new SessionEngine();
-    // Link session engine to transaction engine for auto-abort on session expiry
-    this.sessionEngine.setTransactionEngine(this.transactionEngine);
-    this.registerHandlers();
-  }
-
-  /**
-   * Get or create an IndexEngine for a database.collection
-   */
-  getIndexEngine(dbName: string, collName: string): IndexEngine {
-    const key = `${dbName}.${collName}`;
-    let engine = this.indexEngines.get(key);
-    if (!engine) {
-      engine = new IndexEngine(dbName, collName, this.storage);
-      this.indexEngines.set(key, engine);
-    }
-    return engine;
-  }
-
-  /**
-   * Clear index engine cache for a collection (used when collection is dropped)
-   */
-  clearIndexEngineCache(dbName: string, collName?: string): void {
-    if (collName) {
-      this.indexEngines.delete(`${dbName}.${collName}`);
-    } else {
-      // Clear all engines for the database
-      for (const key of this.indexEngines.keys()) {
-        if (key.startsWith(`${dbName}.`)) {
-          this.indexEngines.delete(key);
-        }
-      }
-    }
-  }
-
-  /**
-   * Register all command handlers
-   */
-  private registerHandlers(): void {
-    // Create handler instances with shared state
-    const helloHandler = new HelloHandler();
-    const findHandler = new FindHandler(this.cursors, () => this.cursorIdCounter++);
-    const insertHandler = new InsertHandler();
-    const updateHandler = new UpdateHandler();
-    const deleteHandler = new DeleteHandler();
-    const aggregateHandler = new AggregateHandler(this.cursors, () => this.cursorIdCounter++);
-    const indexHandler = new IndexHandler();
-    const adminHandler = new AdminHandler();
-
-    // Handshake commands
-    this.handlers.set('hello', helloHandler);
-    this.handlers.set('ismaster', helloHandler);
-    this.handlers.set('isMaster', helloHandler);
-
-    // CRUD commands
-    this.handlers.set('find', findHandler);
-    this.handlers.set('insert', insertHandler);
-    this.handlers.set('update', updateHandler);
-    this.handlers.set('delete', deleteHandler);
-    this.handlers.set('findAndModify', updateHandler);
-    this.handlers.set('getMore', findHandler);
-    this.handlers.set('killCursors', findHandler);
-
-    // Aggregation
-    this.handlers.set('aggregate', aggregateHandler);
-    this.handlers.set('count', findHandler);
-    this.handlers.set('distinct', findHandler);
-
-    // Index operations
-    this.handlers.set('createIndexes', indexHandler);
-    this.handlers.set('dropIndexes', indexHandler);
-    this.handlers.set('listIndexes', indexHandler);
-
-    // Admin/Database operations
-    this.handlers.set('ping', adminHandler);
-    this.handlers.set('listDatabases', adminHandler);
-    this.handlers.set('listCollections', adminHandler);
-    this.handlers.set('drop', adminHandler);
-    this.handlers.set('dropDatabase', adminHandler);
-    this.handlers.set('create', adminHandler);
-    this.handlers.set('serverStatus', adminHandler);
-    this.handlers.set('buildInfo', adminHandler);
-    this.handlers.set('whatsmyuri', adminHandler);
-    this.handlers.set('getLog', adminHandler);
-    this.handlers.set('hostInfo', adminHandler);
-    this.handlers.set('replSetGetStatus', adminHandler);
-    this.handlers.set('isMaster', helloHandler);
-    this.handlers.set('saslStart', adminHandler);
-    this.handlers.set('saslContinue', adminHandler);
-    this.handlers.set('endSessions', adminHandler);
-    this.handlers.set('abortTransaction', adminHandler);
-    this.handlers.set('commitTransaction', adminHandler);
-    this.handlers.set('collStats', adminHandler);
-    this.handlers.set('dbStats', adminHandler);
-    this.handlers.set('connectionStatus', adminHandler);
-    this.handlers.set('currentOp', adminHandler);
-    this.handlers.set('collMod', adminHandler);
-    this.handlers.set('renameCollection', adminHandler);
-  }
-
-  /**
-   * Route a command to its handler
-   */
-  async route(parsedCommand: IParsedCommand): Promise<plugins.bson.Document> {
-    const { commandName, command, database, documentSequences } = parsedCommand;
-
-    // Extract session ID from lsid using SessionEngine helper
-    let sessionId = SessionEngine.extractSessionId(command.lsid);
-    let txnId: string | undefined;
-
-    // If we have a session ID, register/touch the session
-    if (sessionId) {
-      this.sessionEngine.getOrCreateSession(sessionId);
-    }
-
-    // Check if this starts a new transaction
-    if (command.startTransaction && sessionId) {
-      txnId = this.transactionEngine.startTransaction(sessionId);
-      this.sessionEngine.startTransaction(sessionId, txnId, command.txnNumber);
-    } else if (sessionId && this.sessionEngine.isInTransaction(sessionId)) {
-      // Continue existing transaction
-      txnId = this.sessionEngine.getTransactionId(sessionId);
-      // Verify transaction is still active
-      if (txnId && !this.transactionEngine.isActive(txnId)) {
-        this.sessionEngine.endTransaction(sessionId);
-        txnId = undefined;
-      }
-    }
-
-    // Create handler context
-    const context: IHandlerContext = {
-      storage: this.storage,
-      server: this.server,
-      database,
-      command,
-      documentSequences,
-      getIndexEngine: (collName: string) => this.getIndexEngine(database, collName),
-      transactionEngine: this.transactionEngine,
-      sessionEngine: this.sessionEngine,
-      txnId,
-      sessionId,
-    };
-
-    // Find handler
-    const handler = this.handlers.get(commandName);
-
-    if (!handler) {
-      // Unknown command
-      return {
-        ok: 0,
-        errmsg: `no such command: '${commandName}'`,
-        code: 59,
-        codeName: 'CommandNotFound',
-      };
-    }
-
-    try {
-      return await handler.handle(context);
-    } catch (error: any) {
-      // Handle known error types
-      if (error.code) {
-        return {
-          ok: 0,
-          errmsg: error.message,
-          code: error.code,
-          codeName: error.codeName || 'UnknownError',
-        };
-      }
-
-      // Generic error
-      return {
-        ok: 0,
-        errmsg: error.message || 'Internal error',
-        code: 1,
-        codeName: 'InternalError',
-      };
-    }
-  }
-
-  /**
-   * Close the command router and cleanup resources
-   */
-  close(): void {
-    // Close session engine (stops cleanup interval, clears sessions)
-    this.sessionEngine.close();
-    // Clear cursors
-    this.cursors.clear();
-    // Clear index engine cache
-    this.indexEngines.clear();
-  }
-
-  /**
-   * Get session engine (for administrative purposes)
-   */
-  getSessionEngine(): SessionEngine {
-    return this.sessionEngine;
-  }
-
-  /**
-   * Get transaction engine (for administrative purposes)
-   */
-  getTransactionEngine(): TransactionEngine {
-    return this.transactionEngine;
-  }
-}
-
-/**
- * Cursor state for multi-batch queries
- */
-export interface ICursorState {
-  id: bigint;
-  database: string;
-  collection: string;
-  documents: plugins.bson.Document[];
-  position: number;
-  batchSize: number;
-  createdAt: Date;
-}

package/ts/ts_smartdb/server/WireProtocol.ts

@@ -1,416 +0,0 @@
-import * as plugins from '../plugins.js';
-
-/**
- * MongoDB Wire Protocol Implementation
- * Handles parsing and encoding of MongoDB wire protocol messages (OP_MSG primarily)
- *
- * Wire Protocol Message Format:
- * - Header (16 bytes): messageLength (4), requestID (4), responseTo (4), opCode (4)
- * - OP_MSG: flagBits (4), sections[], optional checksum (4)
- *
- * References:
- * - https://www.mongodb.com/docs/manual/reference/mongodb-wire-protocol/
- */
-
-// OpCodes
-export const OP_REPLY = 1;        // Legacy reply
-export const OP_UPDATE = 2001;    // Legacy update
-export const OP_INSERT = 2002;    // Legacy insert
-export const OP_QUERY = 2004;     // Legacy query (still used for initial handshake)
-export const OP_GET_MORE = 2005;  // Legacy getMore
-export const OP_DELETE = 2006;    // Legacy delete
-export const OP_KILL_CURSORS = 2007; // Legacy kill cursors
-export const OP_COMPRESSED = 2012;   // Compressed message
-export const OP_MSG = 2013;       // Modern protocol (MongoDB 3.6+)
-
-// OP_MSG Section Types
-export const SECTION_BODY = 0;           // Single BSON document
-export const SECTION_DOCUMENT_SEQUENCE = 1; // Document sequence for bulk operations
-
-// OP_MSG Flag Bits
-export const MSG_FLAG_CHECKSUM_PRESENT = 1 << 0;
-export const MSG_FLAG_MORE_TO_COME = 1 << 1;
-export const MSG_FLAG_EXHAUST_ALLOWED = 1 << 16;
-
-/**
- * Parsed message header
- */
-export interface IMessageHeader {
-  messageLength: number;
-  requestID: number;
-  responseTo: number;
-  opCode: number;
-}
-
-/**
- * Parsed OP_MSG message
- */
-export interface IOpMsgMessage {
-  header: IMessageHeader;
-  flagBits: number;
-  sections: IOpMsgSection[];
-  checksum?: number;
-}
-
-/**
- * OP_MSG section (either body or document sequence)
- */
-export interface IOpMsgSection {
-  type: number;
-  payload: plugins.bson.Document;
-  sequenceIdentifier?: string;
-  documents?: plugins.bson.Document[];
-}
-
-/**
- * Parsed OP_QUERY message (legacy, but used for initial handshake)
- */
-export interface IOpQueryMessage {
-  header: IMessageHeader;
-  flags: number;
-  fullCollectionName: string;
-  numberToSkip: number;
-  numberToReturn: number;
-  query: plugins.bson.Document;
-  returnFieldsSelector?: plugins.bson.Document;
-}
-
-/**
- * Parsed command from any message type
- */
-export interface IParsedCommand {
-  commandName: string;
-  command: plugins.bson.Document;
-  database: string;
-  requestID: number;
-  opCode: number;
-  documentSequences?: Map<string, plugins.bson.Document[]>;
-}
-
-/**
- * Wire Protocol parser and encoder
- */
-export class WireProtocol {
-  /**
-   * Parse a complete message from a buffer
-   * Returns the parsed command and the number of bytes consumed
-   */
-  static parseMessage(buffer: Buffer): { command: IParsedCommand; bytesConsumed: number } | null {
-    if (buffer.length < 16) {
-      return null; // Not enough data for header
-    }
-
-    const header = this.parseHeader(buffer);
-
-    if (buffer.length < header.messageLength) {
-      return null; // Not enough data for complete message
-    }
-
-    const messageBuffer = buffer.subarray(0, header.messageLength);
-
-    switch (header.opCode) {
-      case OP_MSG:
-        return this.parseOpMsg(messageBuffer, header);
-      case OP_QUERY:
-        return this.parseOpQuery(messageBuffer, header);
-      default:
-        throw new Error(`Unsupported opCode: ${header.opCode}`);
-    }
-  }
-
-  /**
-   * Parse message header (16 bytes)
-   */
-  private static parseHeader(buffer: Buffer): IMessageHeader {
-    return {
-      messageLength: buffer.readInt32LE(0),
-      requestID: buffer.readInt32LE(4),
-      responseTo: buffer.readInt32LE(8),
-      opCode: buffer.readInt32LE(12),
-    };
-  }
-
-  /**
-   * Parse OP_MSG message
-   */
-  private static parseOpMsg(buffer: Buffer, header: IMessageHeader): { command: IParsedCommand; bytesConsumed: number } {
-    let offset = 16; // Skip header
-
-    const flagBits = buffer.readUInt32LE(offset);
-    offset += 4;
-
-    const sections: IOpMsgSection[] = [];
-    const documentSequences = new Map<string, plugins.bson.Document[]>();
-
-    // Parse sections until we reach the end (or checksum)
-    const messageEnd = (flagBits & MSG_FLAG_CHECKSUM_PRESENT)
-      ? header.messageLength - 4
-      : header.messageLength;
-
-    while (offset < messageEnd) {
-      const sectionType = buffer.readUInt8(offset);
-      offset += 1;
-
-      if (sectionType === SECTION_BODY) {
-        // Single BSON document
-        const docSize = buffer.readInt32LE(offset);
-        const docBuffer = buffer.subarray(offset, offset + docSize);
-        const doc = plugins.bson.deserialize(docBuffer);
-        sections.push({ type: SECTION_BODY, payload: doc });
-        offset += docSize;
-      } else if (sectionType === SECTION_DOCUMENT_SEQUENCE) {
-        // Document sequence
-        const sectionSize = buffer.readInt32LE(offset);
-        const sectionEnd = offset + sectionSize;
-        offset += 4;
-
-        // Read sequence identifier (C string)
-        let identifierEnd = offset;
-        while (buffer[identifierEnd] !== 0 && identifierEnd < sectionEnd) {
-          identifierEnd++;
-        }
-        const identifier = buffer.subarray(offset, identifierEnd).toString('utf8');
-        offset = identifierEnd + 1; // Skip null terminator
-
-        // Read documents
-        const documents: plugins.bson.Document[] = [];
-        while (offset < sectionEnd) {
-          const docSize = buffer.readInt32LE(offset);
-          const docBuffer = buffer.subarray(offset, offset + docSize);
-          documents.push(plugins.bson.deserialize(docBuffer));
-          offset += docSize;
-        }
-
-        sections.push({
-          type: SECTION_DOCUMENT_SEQUENCE,
-          payload: {},
-          sequenceIdentifier: identifier,
-          documents
-        });
-        documentSequences.set(identifier, documents);
-      } else {
-        throw new Error(`Unknown section type: ${sectionType}`);
-      }
-    }
-
-    // The first section body contains the command
-    const commandSection = sections.find(s => s.type === SECTION_BODY);
-    if (!commandSection) {
-      throw new Error('OP_MSG missing command body section');
-    }
-
-    const command = commandSection.payload;
-    const commandName = Object.keys(command)[0];
-    const database = command.$db || 'admin';
-
-    return {
-      command: {
-        commandName,
-        command,
-        database,
-        requestID: header.requestID,
-        opCode: header.opCode,
-        documentSequences: documentSequences.size > 0 ? documentSequences : undefined,
-      },
-      bytesConsumed: header.messageLength,
-    };
-  }
-
-  /**
-   * Parse OP_QUERY message (legacy, used for initial handshake)
-   */
-  private static parseOpQuery(buffer: Buffer, header: IMessageHeader): { command: IParsedCommand; bytesConsumed: number } {
-    let offset = 16; // Skip header
-
-    const flags = buffer.readInt32LE(offset);
-    offset += 4;
-
-    // Read full collection name (C string)
-    let nameEnd = offset;
-    while (buffer[nameEnd] !== 0 && nameEnd < buffer.length) {
-      nameEnd++;
-    }
-    const fullCollectionName = buffer.subarray(offset, nameEnd).toString('utf8');
-    offset = nameEnd + 1;
-
-    const numberToSkip = buffer.readInt32LE(offset);
-    offset += 4;
-
-    const numberToReturn = buffer.readInt32LE(offset);
-    offset += 4;
-
-    // Read query document
-    const querySize = buffer.readInt32LE(offset);
-    const queryBuffer = buffer.subarray(offset, offset + querySize);
-    const query = plugins.bson.deserialize(queryBuffer);
-    offset += querySize;
-
-    // Extract database from collection name (format: "dbname.$cmd" or "dbname.collection")
-    const parts = fullCollectionName.split('.');
-    const database = parts[0];
-
-    // For OP_QUERY to .$cmd, the query IS the command
-    let commandName = 'find';
-    let command = query;
-
-    if (parts[1] === '$cmd') {
-      // This is a command
-      commandName = Object.keys(query)[0];
-      // Handle special commands like isMaster, hello
-      if (commandName === 'isMaster' || commandName === 'ismaster') {
-        commandName = 'hello';
-      }
-    }
-
-    return {
-      command: {
-        commandName,
-        command,
-        database,
-        requestID: header.requestID,
-        opCode: header.opCode,
-      },
-      bytesConsumed: header.messageLength,
-    };
-  }
-
-  /**
-   * Encode a response as OP_MSG
-   */
-  static encodeOpMsgResponse(
-    responseTo: number,
-    response: plugins.bson.Document,
-    requestID: number = Math.floor(Math.random() * 0x7FFFFFFF)
-  ): Buffer {
-    // Add $db if not present (optional in response)
-    const responseDoc = { ...response };
-
-    // Serialize the response document
-    const bodyBson = plugins.bson.serialize(responseDoc);
-
-    // Calculate message length
-    // Header (16) + flagBits (4) + section type (1) + body BSON
-    const messageLength = 16 + 4 + 1 + bodyBson.length;
-
-    const buffer = Buffer.alloc(messageLength);
-    let offset = 0;
-
-    // Write header
-    buffer.writeInt32LE(messageLength, offset);     // messageLength
-    offset += 4;
-    buffer.writeInt32LE(requestID, offset);         // requestID
-    offset += 4;
-    buffer.writeInt32LE(responseTo, offset);        // responseTo
-    offset += 4;
-    buffer.writeInt32LE(OP_MSG, offset);            // opCode
-    offset += 4;
-
-    // Write flagBits (0 = no flags)
-    buffer.writeUInt32LE(0, offset);
-    offset += 4;
-
-    // Write section type 0 (body)
-    buffer.writeUInt8(SECTION_BODY, offset);
-    offset += 1;
-
-    // Write body BSON
-    Buffer.from(bodyBson).copy(buffer, offset);
-
-    return buffer;
-  }
-
-  /**
-   * Encode a response as OP_REPLY (legacy, for OP_QUERY responses)
-   */
-  static encodeOpReplyResponse(
-    responseTo: number,
-    documents: plugins.bson.Document[],
-    requestID: number = Math.floor(Math.random() * 0x7FFFFFFF),
-    cursorId: bigint = BigInt(0)
-  ): Buffer {
-    // Serialize all documents
-    const docBuffers = documents.map(doc => plugins.bson.serialize(doc));
-    const totalDocsSize = docBuffers.reduce((sum, buf) => sum + buf.length, 0);
-
-    // Message format:
-    // Header (16) + responseFlags (4) + cursorID (8) + startingFrom (4) + numberReturned (4) + documents
-    const messageLength = 16 + 4 + 8 + 4 + 4 + totalDocsSize;
-
-    const buffer = Buffer.alloc(messageLength);
-    let offset = 0;
-
-    // Write header
-    buffer.writeInt32LE(messageLength, offset);     // messageLength
-    offset += 4;
-    buffer.writeInt32LE(requestID, offset);         // requestID
-    offset += 4;
-    buffer.writeInt32LE(responseTo, offset);        // responseTo
-    offset += 4;
-    buffer.writeInt32LE(OP_REPLY, offset);          // opCode
-    offset += 4;
-
-    // Write OP_REPLY fields
-    buffer.writeInt32LE(0, offset);                 // responseFlags (0 = no errors)
-    offset += 4;
-    buffer.writeBigInt64LE(cursorId, offset);       // cursorID
-    offset += 8;
-    buffer.writeInt32LE(0, offset);                 // startingFrom
-    offset += 4;
-    buffer.writeInt32LE(documents.length, offset);  // numberReturned
-    offset += 4;
-
-    // Write documents
-    for (const docBuffer of docBuffers) {
-      Buffer.from(docBuffer).copy(buffer, offset);
-      offset += docBuffer.length;
-    }
-
-    return buffer;
-  }
-
-  /**
-   * Encode an error response
-   */
-  static encodeErrorResponse(
-    responseTo: number,
-    errorCode: number,
-    errorMessage: string,
-    commandName?: string
-  ): Buffer {
-    const response: plugins.bson.Document = {
-      ok: 0,
-      errmsg: errorMessage,
-      code: errorCode,
-      codeName: this.getErrorCodeName(errorCode),
-    };
-
-    return this.encodeOpMsgResponse(responseTo, response);
-  }
-
-  /**
-   * Get error code name from error code
-   */
-  private static getErrorCodeName(code: number): string {
-    const errorNames: Record<number, string> = {
-      0: 'OK',
-      1: 'InternalError',
-      2: 'BadValue',
-      11000: 'DuplicateKey',
-      11001: 'DuplicateKeyValue',
-      13: 'Unauthorized',
-      26: 'NamespaceNotFound',
-      27: 'IndexNotFound',
-      48: 'NamespaceExists',
-      59: 'CommandNotFound',
-      66: 'ImmutableField',
-      73: 'InvalidNamespace',
-      85: 'IndexOptionsConflict',
-      112: 'WriteConflict',
-      121: 'DocumentValidationFailure',
-      211: 'KeyNotFound',
-      251: 'NoSuchTransaction',
-    };
-
-    return errorNames[code] || 'UnknownError';
-  }
-}