@push.rocks/smartdb 1.0.1

package/dist_ts/ts_smartdb/server/SmartdbServer.d.ts

@@ -0,0 +1,102 @@
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+/**
+ * Server configuration options
+ */
+export interface ISmartdbServerOptions {
+    /** Port to listen on (default: 27017) - ignored if socketPath is set */
+    port?: number;
+    /** Host to bind to (default: 127.0.0.1) - ignored if socketPath is set */
+    host?: string;
+    /** Unix socket path - if set, server listens on socket instead of TCP */
+    socketPath?: 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;
+}
+/**
+ * SmartdbServer - 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 { SmartdbServer } from '@push.rocks/smartmongo/smartdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const server = new SmartdbServer({ port: 27017 });
+ * await server.start();
+ *
+ * const client = new MongoClient('mongodb://127.0.0.1:27017');
+ * await client.connect();
+ * ```
+ */
+export declare class SmartdbServer {
+    private options;
+    private server;
+    private storage;
+    private commandRouter;
+    private connections;
+    private connectionIdCounter;
+    private isRunning;
+    private startTime;
+    private useSocket;
+    constructor(options?: ISmartdbServerOptions);
+    /**
+     * Get the storage adapter (for testing/debugging)
+     */
+    getStorage(): IStorageAdapter;
+    /**
+     * Get server uptime in seconds
+     */
+    getUptime(): number;
+    /**
+     * Get current connection count
+     */
+    getConnectionCount(): number;
+    /**
+     * Start the server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the server
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle a new client connection
+     */
+    private handleConnection;
+    /**
+     * Handle incoming data from a client
+     */
+    private handleData;
+    /**
+     * Process complete messages from the buffer
+     */
+    private processMessages;
+    /**
+     * Get the connection URI for this server
+     */
+    getConnectionUri(): string;
+    /**
+     * Get the socket path (if using Unix socket mode)
+     */
+    get socketPath(): string | undefined;
+    /**
+     * Check if the server is running
+     */
+    get running(): boolean;
+    /**
+     * Get the port the server is listening on
+     */
+    get port(): number;
+    /**
+     * Get the host the server is bound to
+     */
+    get host(): string;
+}

package/dist_ts/ts_smartdb/server/SmartdbServer.js

@@ -0,0 +1,279 @@
+import * as net from 'net';
+import * as fs from 'fs/promises';
+import * as plugins from '../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';
+/**
+ * SmartdbServer - 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 { SmartdbServer } from '@push.rocks/smartmongo/smartdb';
+ * import { MongoClient } from 'mongodb';
+ *
+ * const server = new SmartdbServer({ port: 27017 });
+ * await server.start();
+ *
+ * const client = new MongoClient('mongodb://127.0.0.1:27017');
+ * await client.connect();
+ * ```
+ */
+export class SmartdbServer {
+    options;
+    server = null;
+    storage;
+    commandRouter;
+    connections = new Map();
+    connectionIdCounter = 0;
+    isRunning = false;
+    startTime = new Date();
+    useSocket;
+    constructor(options = {}) {
+        this.useSocket = !!options.socketPath;
+        this.options = {
+            port: options.port ?? 27017,
+            host: options.host ?? '127.0.0.1',
+            socketPath: options.socketPath ?? '',
+            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();
+        // Clean up stale socket file if using Unix socket
+        if (this.useSocket && this.options.socketPath) {
+            try {
+                await fs.unlink(this.options.socketPath);
+            }
+            catch (err) {
+                // Ignore ENOENT (file doesn't exist)
+                if (err.code !== 'ENOENT') {
+                    throw err;
+                }
+            }
+        }
+        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);
+                }
+            });
+            if (this.useSocket && this.options.socketPath) {
+                // Listen on Unix socket
+                this.server.listen(this.options.socketPath, () => {
+                    this.isRunning = true;
+                    this.startTime = new Date();
+                    resolve();
+                });
+            }
+            else {
+                // Listen on TCP
+                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(async () => {
+                this.isRunning = false;
+                this.server = null;
+                // Clean up socket file if using Unix socket
+                if (this.useSocket && this.options.socketPath) {
+                    try {
+                        await fs.unlink(this.options.socketPath);
+                    }
+                    catch (err) {
+                        // Ignore ENOENT (file doesn't exist)
+                        if (err.code !== 'ENOENT') {
+                            console.error('Failed to remove socket file:', err);
+                        }
+                    }
+                }
+                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() {
+        if (this.useSocket && this.options.socketPath) {
+            // URL-encode the socket path (replace / with %2F)
+            const encodedPath = encodeURIComponent(this.options.socketPath);
+            return `mongodb://${encodedPath}`;
+        }
+        return `mongodb://${this.options.host}:${this.options.port}`;
+    }
+    /**
+     * Get the socket path (if using Unix socket mode)
+     */
+    get socketPath() {
+        return this.useSocket ? this.options.socketPath : undefined;
+    }
+    /**
+     * 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,{"version":3,"file":"SmartdbServer.js","sourceRoot":"","sources":["../../../ts/ts_smartdb/server/SmartdbServer.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,117 @@
+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/
+ */
+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;
+}