@push.rocks/smartmongo 2.2.0 → 4.0.0

package/dist_ts/tsmdb/server/TsmdbServer.js

@@ -0,0 +1,229 @@
+import * as net from 'net';
+import * as plugins from '../tsmdb.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';
+/**
+ * TsmdbServer - 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 { TsmdbServer } from '@push.rocks/smartmongo/tsmdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const server = new TsmdbServer({ port: 27017 });
+ * await server.start();
+ *
+ * const client = new MongoClient('mongodb://127.0.0.1:27017');
+ * await client.connect();
+ * ```
+ */
+export class TsmdbServer {
+    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 command router (cleans up session engine, cursors, etc.)
+        this.commandRouter.close();
+        // 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 → tsmdb}/server/WireProtocol.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 /**
  * MongoDB Wire Protocol Implementation
  * Handles parsing and encoding of MongoDB wire protocol messages (OP_MSG primarily)

package/dist_ts/tsmdb/server/WireProtocol.js

@@ -0,0 +1,298 @@
+import * as plugins from '../tsmdb.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/tsmdb/server/WireProtocol.ts"],"names":[],"mappings":"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"}

package/dist_ts/{congodb → tsmdb}/server/handlers/AdminHandler.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../../congodb.plugins.js';
+import * as plugins from '../../tsmdb.plugins.js';
 import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
 /**
  * AdminHandler - Handles administrative commands