@push.rocks/smartmongo 2.0.12 → 2.1.0

package/ts/congodb/index.ts

@@ -0,0 +1,37 @@
+// CongoDB - MongoDB Wire Protocol compatible in-memory database server
+// Use the official MongoDB driver to connect to CongoServer
+
+// Re-export plugins for external use
+import * as plugins from './congodb.plugins.js';
+export { plugins };
+
+// Export BSON types for convenience
+export { ObjectId, Binary, Timestamp, Long, Decimal128, UUID } from 'bson';
+
+// Export all types
+export * from './types/interfaces.js';
+
+// Export errors
+export * from './errors/CongoErrors.js';
+
+// Export storage adapters
+export type { IStorageAdapter } from './storage/IStorageAdapter.js';
+export { MemoryStorageAdapter } from './storage/MemoryStorageAdapter.js';
+export { FileStorageAdapter } from './storage/FileStorageAdapter.js';
+export { OpLog } from './storage/OpLog.js';
+
+// Export engines
+export { QueryEngine } from './engine/QueryEngine.js';
+export { UpdateEngine } from './engine/UpdateEngine.js';
+export { AggregationEngine } from './engine/AggregationEngine.js';
+export { IndexEngine } from './engine/IndexEngine.js';
+export { TransactionEngine } from './engine/TransactionEngine.js';
+
+// Export server (the main entry point for using CongoDB)
+export { CongoServer } from './server/CongoServer.js';
+export type { ICongoServerOptions } from './server/CongoServer.js';
+
+// Export wire protocol utilities (for advanced usage)
+export { WireProtocol } from './server/WireProtocol.js';
+export { CommandRouter } from './server/CommandRouter.js';
+export type { ICommandHandler, IHandlerContext, ICursorState } from './server/CommandRouter.js';

package/ts/congodb/server/CommandRouter.ts

@@ -0,0 +1,180 @@
+import * as plugins from '../congodb.plugins.js';
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+import type { IParsedCommand } from './WireProtocol.js';
+import type { CongoServer } from './CongoServer.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: CongoServer;
+  database: string;
+  command: plugins.bson.Document;
+  documentSequences?: Map<string, plugins.bson.Document[]>;
+}
+
+/**
+ * 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: CongoServer;
+  private handlers: Map<string, ICommandHandler> = new Map();
+
+  // Cursor state for getMore operations
+  private cursors: Map<bigint, ICursorState> = new Map();
+  private cursorIdCounter: bigint = BigInt(1);
+
+  constructor(storage: IStorageAdapter, server: CongoServer) {
+    this.storage = storage;
+    this.server = server;
+    this.registerHandlers();
+  }
+
+  /**
+   * 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;
+
+    // Create handler context
+    const context: IHandlerContext = {
+      storage: this.storage,
+      server: this.server,
+      database,
+      command,
+      documentSequences,
+    };
+
+    // 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',
+      };
+    }
+  }
+}
+
+/**
+ * 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/congodb/server/CongoServer.ts

@@ -0,0 +1,298 @@
+import * as net from 'net';
+import * as plugins from '../congodb.plugins.js';
+import { WireProtocol, OP_QUERY } from './WireProtocol.js';
+import { CommandRouter } from './CommandRouter.js';
+import { MemoryStorageAdapter } from '../storage/MemoryStorageAdapter.js';
+import { FileStorageAdapter } from '../storage/FileStorageAdapter.js';
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+
+/**
+ * Server configuration options
+ */
+export interface ICongoServerOptions {
+  /** Port to listen on (default: 27017) */
+  port?: number;
+  /** Host to bind to (default: 127.0.0.1) */
+  host?: string;
+  /** Storage type: 'memory' or 'file' (default: 'memory') */
+  storage?: 'memory' | 'file';
+  /** Path for file storage (required if storage is 'file') */
+  storagePath?: string;
+  /** Enable persistence for memory storage */
+  persistPath?: string;
+  /** Persistence interval in ms (default: 60000) */
+  persistIntervalMs?: number;
+}
+
+/**
+ * Connection state for each client
+ */
+interface IConnectionState {
+  id: number;
+  socket: net.Socket;
+  buffer: Buffer;
+  authenticated: boolean;
+  database: string;
+}
+
+/**
+ * CongoServer - MongoDB Wire Protocol compatible server
+ *
+ * This server implements the MongoDB wire protocol (OP_MSG) to allow
+ * official MongoDB drivers to connect and perform operations.
+ *
+ * @example
+ * ```typescript
+ * import { CongoServer } from '@push.rocks/smartmongo/congodb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const server = new CongoServer({ port: 27017 });
+ * await server.start();
+ *
+ * const client = new MongoClient('mongodb://127.0.0.1:27017');
+ * await client.connect();
+ * ```
+ */
+export class CongoServer {
+  private options: Required<ICongoServerOptions>;
+  private server: net.Server | null = null;
+  private storage: IStorageAdapter;
+  private commandRouter: CommandRouter;
+  private connections: Map<number, IConnectionState> = new Map();
+  private connectionIdCounter = 0;
+  private isRunning = false;
+  private startTime: Date = new Date();
+
+  constructor(options: ICongoServerOptions = {}) {
+    this.options = {
+      port: options.port ?? 27017,
+      host: options.host ?? '127.0.0.1',
+      storage: options.storage ?? 'memory',
+      storagePath: options.storagePath ?? './data',
+      persistPath: options.persistPath ?? '',
+      persistIntervalMs: options.persistIntervalMs ?? 60000,
+    };
+
+    // Create storage adapter
+    if (this.options.storage === 'file') {
+      this.storage = new FileStorageAdapter(this.options.storagePath);
+    } else {
+      this.storage = new MemoryStorageAdapter({
+        persistPath: this.options.persistPath || undefined,
+        persistIntervalMs: this.options.persistPath ? this.options.persistIntervalMs : undefined,
+      });
+    }
+
+    // Create command router
+    this.commandRouter = new CommandRouter(this.storage, this);
+  }
+
+  /**
+   * Get the storage adapter (for testing/debugging)
+   */
+  getStorage(): IStorageAdapter {
+    return this.storage;
+  }
+
+  /**
+   * Get server uptime in seconds
+   */
+  getUptime(): number {
+    return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+  }
+
+  /**
+   * Get current connection count
+   */
+  getConnectionCount(): number {
+    return this.connections.size;
+  }
+
+  /**
+   * Start the server
+   */
+  async start(): Promise<void> {
+    if (this.isRunning) {
+      throw new Error('Server is already running');
+    }
+
+    // Initialize storage
+    await this.storage.initialize();
+
+    return new Promise((resolve, reject) => {
+      this.server = net.createServer((socket) => {
+        this.handleConnection(socket);
+      });
+
+      this.server.on('error', (err) => {
+        if (!this.isRunning) {
+          reject(err);
+        } else {
+          console.error('Server error:', err);
+        }
+      });
+
+      this.server.listen(this.options.port, this.options.host, () => {
+        this.isRunning = true;
+        this.startTime = new Date();
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Stop the server
+   */
+  async stop(): Promise<void> {
+    if (!this.isRunning || !this.server) {
+      return;
+    }
+
+    // Close all connections
+    for (const conn of this.connections.values()) {
+      conn.socket.destroy();
+    }
+    this.connections.clear();
+
+    // Close storage
+    await this.storage.close();
+
+    return new Promise((resolve) => {
+      this.server!.close(() => {
+        this.isRunning = false;
+        this.server = null;
+        resolve();
+      });
+    });
+  }
+
+  /**
+   * Handle a new client connection
+   */
+  private handleConnection(socket: net.Socket): void {
+    const connectionId = ++this.connectionIdCounter;
+
+    const state: IConnectionState = {
+      id: connectionId,
+      socket,
+      buffer: Buffer.alloc(0),
+      authenticated: true, // No auth required for now
+      database: 'test',
+    };
+
+    this.connections.set(connectionId, state);
+
+    socket.on('data', (data) => {
+      this.handleData(state, Buffer.isBuffer(data) ? data : Buffer.from(data));
+    });
+
+    socket.on('close', () => {
+      this.connections.delete(connectionId);
+    });
+
+    socket.on('error', (err) => {
+      // Connection errors are expected when clients disconnect
+      this.connections.delete(connectionId);
+    });
+  }
+
+  /**
+   * Handle incoming data from a client
+   */
+  private handleData(state: IConnectionState, data: Buffer): void {
+    // Append new data to buffer
+    state.buffer = Buffer.concat([state.buffer, data]);
+
+    // Process messages from buffer
+    this.processMessages(state);
+  }
+
+  /**
+   * Process complete messages from the buffer
+   */
+  private async processMessages(state: IConnectionState): Promise<void> {
+    while (state.buffer.length >= 16) {
+      try {
+        const result = WireProtocol.parseMessage(state.buffer);
+
+        if (!result) {
+          // Not enough data for a complete message
+          break;
+        }
+
+        const { command, bytesConsumed } = result;
+
+        // Remove processed bytes from buffer
+        state.buffer = state.buffer.subarray(bytesConsumed);
+
+        // Process the command
+        const response = await this.commandRouter.route(command);
+
+        // Encode and send response
+        let responseBuffer: Buffer;
+        if (command.opCode === OP_QUERY) {
+          // Legacy OP_QUERY gets OP_REPLY response
+          responseBuffer = WireProtocol.encodeOpReplyResponse(
+            command.requestID,
+            [response]
+          );
+        } else {
+          // OP_MSG gets OP_MSG response
+          responseBuffer = WireProtocol.encodeOpMsgResponse(
+            command.requestID,
+            response
+          );
+        }
+
+        if (!state.socket.destroyed) {
+          state.socket.write(responseBuffer);
+        }
+      } catch (error: any) {
+        // Send error response
+        const errorResponse = WireProtocol.encodeErrorResponse(
+          0, // We don't have the requestID at this point
+          1,
+          error.message || 'Internal error'
+        );
+
+        if (!state.socket.destroyed) {
+          state.socket.write(errorResponse);
+        }
+
+        // Clear buffer on parse errors to avoid infinite loops
+        if (error.message?.includes('opCode') || error.message?.includes('section')) {
+          state.buffer = Buffer.alloc(0);
+        }
+        break;
+      }
+    }
+  }
+
+  /**
+   * Get the connection URI for this server
+   */
+  getConnectionUri(): string {
+    return `mongodb://${this.options.host}:${this.options.port}`;
+  }
+
+  /**
+   * Check if the server is running
+   */
+  get running(): boolean {
+    return this.isRunning;
+  }
+
+  /**
+   * Get the port the server is listening on
+   */
+  get port(): number {
+    return this.options.port;
+  }
+
+  /**
+   * Get the host the server is bound to
+   */
+  get host(): string {
+    return this.options.host;
+  }
+}