@push.rocks/smartmongo 2.0.12 → 2.1.0

package/dist_ts/congodb/server/CongoServer.js

@@ -0,0 +1,227 @@
+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';
+/**
+ * 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 {
+    options;
+    server = null;
+    storage;
+    commandRouter;
+    connections = new Map();
+    connectionIdCounter = 0;
+    isRunning = false;
+    startTime = new Date();
+    constructor(options = {}) {
+        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() {
+        return this.storage;
+    }
+    /**
+     * Get server uptime in seconds
+     */
+    getUptime() {
+        return Math.floor((Date.now() - this.startTime.getTime()) / 1000);
+    }
+    /**
+     * Get current connection count
+     */
+    getConnectionCount() {
+        return this.connections.size;
+    }
+    /**
+     * Start the server
+     */
+    async start() {
+        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() {
+        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
+     */
+    handleConnection(socket) {
+        const connectionId = ++this.connectionIdCounter;
+        const state = {
+            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
+     */
+    handleData(state, data) {
+        // 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
+     */
+    async processMessages(state) {
+        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;
+                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) {
+                // 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() {
+        return `mongodb://${this.options.host}:${this.options.port}`;
+    }
+    /**
+     * Check if the server is running
+     */
+    get running() {
+        return this.isRunning;
+    }
+    /**
+     * Get the port the server is listening on
+     */
+    get port() {
+        return this.options.port;
+    }
+    /**
+     * Get the host the server is bound to
+     */
+    get host() {
+        return this.options.host;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/congodb/server/WireProtocol.d.ts

@@ -0,0 +1,117 @@
+import * as plugins from '../congodb.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/
+ */
+export declare const OP_REPLY = 1;
+export declare const OP_UPDATE = 2001;
+export declare const OP_INSERT = 2002;
+export declare const OP_QUERY = 2004;
+export declare const OP_GET_MORE = 2005;
+export declare const OP_DELETE = 2006;
+export declare const OP_KILL_CURSORS = 2007;
+export declare const OP_COMPRESSED = 2012;
+export declare const OP_MSG = 2013;
+export declare const SECTION_BODY = 0;
+export declare const SECTION_DOCUMENT_SEQUENCE = 1;
+export declare const MSG_FLAG_CHECKSUM_PRESENT: number;
+export declare const MSG_FLAG_MORE_TO_COME: number;
+export declare const MSG_FLAG_EXHAUST_ALLOWED: number;
+/**
+ * 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 declare 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;
+    /**
+     * Parse message header (16 bytes)
+     */
+    private static parseHeader;
+    /**
+     * Parse OP_MSG message
+     */
+    private static parseOpMsg;
+    /**
+     * Parse OP_QUERY message (legacy, used for initial handshake)
+     */
+    private static parseOpQuery;
+    /**
+     * Encode a response as OP_MSG
+     */
+    static encodeOpMsgResponse(responseTo: number, response: plugins.bson.Document, requestID?: number): Buffer;
+    /**
+     * Encode a response as OP_REPLY (legacy, for OP_QUERY responses)
+     */
+    static encodeOpReplyResponse(responseTo: number, documents: plugins.bson.Document[], requestID?: number, cursorId?: bigint): Buffer;
+    /**
+     * Encode an error response
+     */
+    static encodeErrorResponse(responseTo: number, errorCode: number, errorMessage: string, commandName?: string): Buffer;
+    /**
+     * Get error code name from error code
+     */
+    private static getErrorCodeName;
+}

package/dist_ts/congodb/server/WireProtocol.js

@@ -0,0 +1,298 @@
+import * as plugins from '../congodb.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;
+/**
+ * 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) {
+        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)
+     */
+    static parseHeader(buffer) {
+        return {
+            messageLength: buffer.readInt32LE(0),
+            requestID: buffer.readInt32LE(4),
+            responseTo: buffer.readInt32LE(8),
+            opCode: buffer.readInt32LE(12),
+        };
+    }
+    /**
+     * Parse OP_MSG message
+     */
+    static parseOpMsg(buffer, header) {
+        let offset = 16; // Skip header
+        const flagBits = buffer.readUInt32LE(offset);
+        offset += 4;
+        const sections = [];
+        const documentSequences = new Map();
+        // 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 = [];
+                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)
+     */
+    static parseOpQuery(buffer, header) {
+        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, response, requestID = Math.floor(Math.random() * 0x7FFFFFFF)) {
+        // 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, documents, requestID = Math.floor(Math.random() * 0x7FFFFFFF), cursorId = BigInt(0)) {
+        // 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, errorCode, errorMessage, commandName) {
+        const response = {
+            ok: 0,
+            errmsg: errorMessage,
+            code: errorCode,
+            codeName: this.getErrorCodeName(errorCode),
+        };
+        return this.encodeOpMsgResponse(responseTo, response);
+    }
+    /**
+     * Get error code name from error code
+     */
+    static getErrorCodeName(code) {
+        const errorNames = {
+            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';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WireProtocol.js","sourceRoot":"","sources":["../../../ts/congodb/server/WireProtocol.ts"],"names":[],"mappings":"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"}