@push.rocks/smartmongo 2.2.0 → 4.0.0

package/dist_ts/tsmdb/errors/TsmdbErrors.js

@@ -0,0 +1,155 @@
+/**
+ * Base error class for all TsmDB errors
+ * Mirrors MongoDB driver error hierarchy
+ */
+export class TsmdbError extends Error {
+    code;
+    codeName;
+    constructor(message, code, codeName) {
+        super(message);
+        this.name = 'TsmdbError';
+        this.code = code;
+        this.codeName = codeName;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Error thrown during connection issues
+ */
+export class TsmdbConnectionError extends TsmdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'TsmdbConnectionError';
+    }
+}
+/**
+ * Error thrown when an operation times out
+ */
+export class TsmdbTimeoutError extends TsmdbError {
+    constructor(message) {
+        super(message, 50, 'MaxTimeMSExpired');
+        this.name = 'TsmdbTimeoutError';
+    }
+}
+/**
+ * Error thrown during write operations
+ */
+export class TsmdbWriteError extends TsmdbError {
+    writeErrors;
+    result;
+    constructor(message, code, writeErrors) {
+        super(message, code);
+        this.name = 'TsmdbWriteError';
+        this.writeErrors = writeErrors;
+    }
+}
+/**
+ * Error thrown for duplicate key violations
+ */
+export class TsmdbDuplicateKeyError extends TsmdbWriteError {
+    keyPattern;
+    keyValue;
+    constructor(message, keyPattern, keyValue) {
+        super(message, 11000);
+        this.name = 'TsmdbDuplicateKeyError';
+        this.codeName = 'DuplicateKey';
+        this.keyPattern = keyPattern;
+        this.keyValue = keyValue;
+    }
+}
+/**
+ * Error thrown for bulk write failures
+ */
+export class TsmdbBulkWriteError extends TsmdbError {
+    writeErrors;
+    result;
+    constructor(message, writeErrors, result) {
+        super(message, 65);
+        this.name = 'TsmdbBulkWriteError';
+        this.writeErrors = writeErrors;
+        this.result = result;
+    }
+}
+/**
+ * Error thrown during transaction operations
+ */
+export class TsmdbTransactionError extends TsmdbError {
+    constructor(message, code) {
+        super(message, code);
+        this.name = 'TsmdbTransactionError';
+    }
+}
+/**
+ * Error thrown when a transaction is aborted due to conflict
+ */
+export class TsmdbWriteConflictError extends TsmdbTransactionError {
+    constructor(message = 'Write conflict during transaction') {
+        super(message, 112);
+        this.name = 'TsmdbWriteConflictError';
+        this.codeName = 'WriteConflict';
+    }
+}
+/**
+ * Error thrown for invalid arguments
+ */
+export class TsmdbArgumentError extends TsmdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'TsmdbArgumentError';
+    }
+}
+/**
+ * Error thrown when an operation is not supported
+ */
+export class TsmdbNotSupportedError extends TsmdbError {
+    constructor(message) {
+        super(message, 115);
+        this.name = 'TsmdbNotSupportedError';
+        this.codeName = 'CommandNotSupported';
+    }
+}
+/**
+ * Error thrown when cursor is exhausted or closed
+ */
+export class TsmdbCursorError extends TsmdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'TsmdbCursorError';
+    }
+}
+/**
+ * Error thrown when a namespace (database.collection) is invalid
+ */
+export class TsmdbNamespaceError extends TsmdbError {
+    constructor(message) {
+        super(message, 73);
+        this.name = 'TsmdbNamespaceError';
+        this.codeName = 'InvalidNamespace';
+    }
+}
+/**
+ * Error thrown when an index operation fails
+ */
+export class TsmdbIndexError extends TsmdbError {
+    constructor(message, code) {
+        super(message, code || 86);
+        this.name = 'TsmdbIndexError';
+    }
+}
+/**
+ * Convert any error to a TsmdbError
+ */
+export function toTsmdbError(error) {
+    if (error instanceof TsmdbError) {
+        return error;
+    }
+    const tsmdbError = new TsmdbError(error.message || String(error));
+    if (error.code) {
+        tsmdbError.code = error.code;
+    }
+    if (error.codeName) {
+        tsmdbError.codeName = error.codeName;
+    }
+    return tsmdbError;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/{congodb → tsmdb}/index.d.ts

@@ -1,19 +1,26 @@
-import * as plugins from './congodb.plugins.js';
+import * as plugins from './tsmdb.plugins.js';
 export { plugins };
 export { ObjectId, Binary, Timestamp, Long, Decimal128, UUID } from 'bson';
 export * from './types/interfaces.js';
-export * from './errors/CongoErrors.js';
+export * from './errors/TsmdbErrors.js';
 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 { WAL } from './storage/WAL.js';
+export type { IWalEntry, TWalOperation } from './storage/WAL.js';
 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 { CongoServer } from './server/CongoServer.js';
-export type { ICongoServerOptions } from './server/CongoServer.js';
+export { QueryPlanner } from './engine/QueryPlanner.js';
+export type { IQueryPlan, TQueryPlanType } from './engine/QueryPlanner.js';
+export { SessionEngine } from './engine/SessionEngine.js';
+export type { ISession, ISessionEngineOptions } from './engine/SessionEngine.js';
+export { TsmdbServer } from './server/TsmdbServer.js';
+export type { ITsmdbServerOptions } from './server/TsmdbServer.js';
 export { WireProtocol } from './server/WireProtocol.js';
 export { CommandRouter } from './server/CommandRouter.js';
 export type { ICommandHandler, IHandlerContext, ICursorState } from './server/CommandRouter.js';
+export * from './utils/checksum.js';

package/dist_ts/tsmdb/index.js

@@ -0,0 +1,31 @@
+// TsmDB - MongoDB Wire Protocol compatible in-memory database server
+// Use the official MongoDB driver to connect to TsmdbServer
+// Re-export plugins for external use
+import * as plugins from './tsmdb.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/TsmdbErrors.js';
+export { MemoryStorageAdapter } from './storage/MemoryStorageAdapter.js';
+export { FileStorageAdapter } from './storage/FileStorageAdapter.js';
+export { OpLog } from './storage/OpLog.js';
+export { WAL } from './storage/WAL.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 { QueryPlanner } from './engine/QueryPlanner.js';
+export { SessionEngine } from './engine/SessionEngine.js';
+// Export server (the main entry point for using TsmDB)
+export { TsmdbServer } from './server/TsmdbServer.js';
+// Export wire protocol utilities (for advanced usage)
+export { WireProtocol } from './server/WireProtocol.js';
+export { CommandRouter } from './server/CommandRouter.js';
+// Export utilities
+export * from './utils/checksum.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c21kYi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxxRUFBcUU7QUFDckUsNERBQTREO0FBRTVELHFDQUFxQztBQUNyQyxPQUFPLEtBQUssT0FBTyxNQUFNLG9CQUFvQixDQUFDO0FBQzlDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUVuQixvQ0FBb0M7QUFDcEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRTNFLG1CQUFtQjtBQUNuQixjQUFjLHVCQUF1QixDQUFDO0FBRXRDLGdCQUFnQjtBQUNoQixjQUFjLHlCQUF5QixDQUFDO0FBSXhDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMzQyxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFHdkMsaUJBQWlCO0FBQ2pCLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDbEUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3RELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUV4RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFHMUQsdURBQXVEO0FBQ3ZELE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUd0RCxzREFBc0Q7QUFDdEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUcxRCxtQkFBbUI7QUFDbkIsY0FBYyxxQkFBcUIsQ0FBQyJ9

package/dist_ts/tsmdb/server/CommandRouter.d.ts

@@ -0,0 +1,87 @@
+import * as plugins from '../tsmdb.plugins.js';
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+import type { IParsedCommand } from './WireProtocol.js';
+import type { TsmdbServer } from './TsmdbServer.js';
+import { IndexEngine } from '../engine/IndexEngine.js';
+import { TransactionEngine } from '../engine/TransactionEngine.js';
+import { SessionEngine } from '../engine/SessionEngine.js';
+/**
+ * Handler context passed to command handlers
+ */
+export interface IHandlerContext {
+    storage: IStorageAdapter;
+    server: TsmdbServer;
+    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 declare class CommandRouter {
+    private storage;
+    private server;
+    private handlers;
+    private cursors;
+    private cursorIdCounter;
+    private indexEngines;
+    private transactionEngine;
+    private sessionEngine;
+    constructor(storage: IStorageAdapter, server: TsmdbServer);
+    /**
+     * Get or create an IndexEngine for a database.collection
+     */
+    getIndexEngine(dbName: string, collName: string): IndexEngine;
+    /**
+     * Clear index engine cache for a collection (used when collection is dropped)
+     */
+    clearIndexEngineCache(dbName: string, collName?: string): void;
+    /**
+     * Register all command handlers
+     */
+    private registerHandlers;
+    /**
+     * Route a command to its handler
+     */
+    route(parsedCommand: IParsedCommand): Promise<plugins.bson.Document>;
+    /**
+     * Close the command router and cleanup resources
+     */
+    close(): void;
+    /**
+     * Get session engine (for administrative purposes)
+     */
+    getSessionEngine(): SessionEngine;
+    /**
+     * Get transaction engine (for administrative purposes)
+     */
+    getTransactionEngine(): 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/dist_ts/tsmdb/server/CommandRouter.js

@@ -0,0 +1,222 @@
+import * as plugins from '../tsmdb.plugins.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';
+/**
+ * CommandRouter - Routes incoming commands to appropriate handlers
+ */
+export class CommandRouter {
+    storage;
+    server;
+    handlers = new Map();
+    // Cursor state for getMore operations
+    cursors = new Map();
+    cursorIdCounter = BigInt(1);
+    // Index engine cache: db.collection -> IndexEngine
+    indexEngines = new Map();
+    // Transaction engine (shared across all handlers)
+    transactionEngine;
+    // Session engine (shared across all handlers)
+    sessionEngine;
+    constructor(storage, server) {
+        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, collName) {
+        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, collName) {
+        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
+     */
+    registerHandlers() {
+        // 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) {
+        const { commandName, command, database, documentSequences } = parsedCommand;
+        // Extract session ID from lsid using SessionEngine helper
+        let sessionId = SessionEngine.extractSessionId(command.lsid);
+        let txnId;
+        // 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 = {
+            storage: this.storage,
+            server: this.server,
+            database,
+            command,
+            documentSequences,
+            getIndexEngine: (collName) => 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) {
+            // 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() {
+        // 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() {
+        return this.sessionEngine;
+    }
+    /**
+     * Get transaction engine (for administrative purposes)
+     */
+    getTransactionEngine() {
+        return this.transactionEngine;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"CommandRouter.js","sourceRoot":"","sources":["../../../ts/tsmdb/server/CommandRouter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,qBAAqB,CAAC;AAI/C,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,kBAAkB;AAClB,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,4BAA4B,CAAC;AA8B1D;;GAEG;AACH,MAAM,OAAO,aAAa;IAChB,OAAO,CAAkB;IACzB,MAAM,CAAc;IACpB,QAAQ,GAAiC,IAAI,GAAG,EAAE,CAAC;IAE3D,sCAAsC;IAC9B,OAAO,GAA8B,IAAI,GAAG,EAAE,CAAC;IAC/C,eAAe,GAAW,MAAM,CAAC,CAAC,CAAC,CAAC;IAE5C,mDAAmD;IAC3C,YAAY,GAA6B,IAAI,GAAG,EAAE,CAAC;IAE3D,kDAAkD;IAC1C,iBAAiB,CAAoB;IAE7C,8CAA8C;IACtC,aAAa,CAAgB;IAErC,YAAY,OAAwB,EAAE,MAAmB;QACvD,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,iBAAiB,GAAG,IAAI,iBAAiB,CAAC,OAAO,CAAC,CAAC;QACxD,IAAI,CAAC,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QACzC,6EAA6E;QAC7E,IAAI,CAAC,aAAa,CAAC,oBAAoB,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;QAChE,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAED;;OAEG;IACH,cAAc,CAAC,MAAc,EAAE,QAAgB;QAC7C,MAAM,GAAG,GAAG,GAAG,MAAM,IAAI,QAAQ,EAAE,CAAC;QACpC,IAAI,MAAM,GAAG,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,MAAM,GAAG,IAAI,WAAW,CAAC,MAAM,EAAE,QAAQ,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC;YACzD,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QACrC,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED;;OAEG;IACH,qBAAqB,CAAC,MAAc,EAAE,QAAiB;QACrD,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,MAAM,IAAI,QAAQ,EAAE,CAAC,CAAC;QACpD,CAAC;aAAM,CAAC;YACN,qCAAqC;YACrC,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,EAAE,CAAC;gBAC3C,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC;oBACjC,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;gBAChC,CAAC;YACH,CAAC;QACH,CAAC;IACH,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,6CAA6C;QAC7C,MAAM,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;QACxC,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;QAChF,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QAC1C,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QAC1C,MAAM,aAAa,GAAG,IAAI,aAAa,EAAE,CAAC;QAC1C,MAAM,gBAAgB,GAAG,IAAI,gBAAgB,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,eAAe,EAAE,CAAC,CAAC;QAC1F,MAAM,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;QACxC,MAAM,YAAY,GAAG,IAAI,YAAY,EAAE,CAAC;QAExC,qBAAqB;QACrB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;QACzC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAE5C,gBAAgB;QAChB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;QACvC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,aAAa,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,EAAE,aAAa,CAAC,CAAC;QAClD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC;QAE9C,cAAc;QACd,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,gBAAgB,CAAC,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;QAE3C,mBAAmB;QACnB,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QAC/C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QAE/C,4BAA4B;QAC5B,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,eAAe,EAAE,YAAY,CAAC,CAAC;QACjD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC;QACnD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;QACxC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAC7C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;QAC9C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,QAAQ,EAAE,YAAY,CAAC,CAAC;QAC1C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,UAAU,EAAE,YAAY,CAAC,CAAC;QAC5C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAC7C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,cAAc,EAAE,YAAY,CAAC,CAAC;QAChD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,aAAa,EAAE,YAAY,CAAC,CAAC;QAC/C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,mBAAmB,EAAE,YAAY,CAAC,CAAC;QACrD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAC7C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;QACpD,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,EAAE,YAAY,CAAC,CAAC;QAC7C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,SAAS,EAAE,YAAY,CAAC,CAAC;QAC3C,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,kBAAkB,EAAE,YAAY,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,KAAK,CAAC,aAA6B;QACvC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,GAAG,aAAa,CAAC;QAE5E,0DAA0D;QAC1D,IAAI,SAAS,GAAG,aAAa,CAAC,gBAAgB,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;QAC7D,IAAI,KAAyB,CAAC;QAE9B,sDAAsD;QACtD,IAAI,SAAS,EAAE,CAAC;YACd,IAAI,CAAC,aAAa,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC;QACnD,CAAC;QAED,yCAAyC;QACzC,IAAI,OAAO,CAAC,gBAAgB,IAAI,SAAS,EAAE,CAAC;YAC1C,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;YAC3D,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,CAAC;QAC3E,CAAC;aAAM,IAAI,SAAS,IAAI,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC,EAAE,CAAC;YACtE,gCAAgC;YAChC,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,gBAAgB,CAAC,SAAS,CAAC,CAAC;YACvD,qCAAqC;YACrC,IAAI,KAAK,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBACrD,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;gBAC7C,KAAK,GAAG,SAAS,CAAC;YACpB,CAAC;QACH,CAAC;QAED,yBAAyB;QACzB,MAAM,OAAO,GAAoB;YAC/B,OAAO,EAAE,IAAI,CAAC,OAAO;YACrB,MAAM,EAAE,IAAI,CAAC,MAAM;YACnB,QAAQ;YACR,OAAO;YACP,iBAAiB;YACjB,cAAc,EAAE,CAAC,QAAgB,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,QAAQ,EAAE,QAAQ,CAAC;YAC7E,iBAAiB,EAAE,IAAI,CAAC,iBAAiB;YACzC,aAAa,EAAE,IAAI,CAAC,aAAa;YACjC,KAAK;YACL,SAAS;SACV,CAAC;QAEF,eAAe;QACf,MAAM,OAAO,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC;QAE/C,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,kBAAkB;YAClB,OAAO;gBACL,EAAE,EAAE,CAAC;gBACL,MAAM,EAAE,qBAAqB,WAAW,GAAG;gBAC3C,IAAI,EAAE,EAAE;gBACR,QAAQ,EAAE,iBAAiB;aAC5B,CAAC;QACJ,CAAC;QAED,IAAI,CAAC;YACH,OAAO,MAAM,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QACvC,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,2BAA2B;YAC3B,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;gBACf,OAAO;oBACL,EAAE,EAAE,CAAC;oBACL,MAAM,EAAE,KAAK,CAAC,OAAO;oBACrB,IAAI,EAAE,KAAK,CAAC,IAAI;oBAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ,IAAI,cAAc;iBAC3C,CAAC;YACJ,CAAC;YAED,gBAAgB;YAChB,OAAO;gBACL,EAAE,EAAE,CAAC;gBACL,MAAM,EAAE,KAAK,CAAC,OAAO,IAAI,gBAAgB;gBACzC,IAAI,EAAE,CAAC;gBACP,QAAQ,EAAE,eAAe;aAC1B,CAAC;QACJ,CAAC;IACH,CAAC;IAED;;OAEG;IACH,KAAK;QACH,iEAAiE;QACjE,IAAI,CAAC,aAAa,CAAC,KAAK,EAAE,CAAC;QAC3B,gBAAgB;QAChB,IAAI,CAAC,OAAO,CAAC,KAAK,EAAE,CAAC;QACrB,2BAA2B;QAC3B,IAAI,CAAC,YAAY,CAAC,KAAK,EAAE,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,gBAAgB;QACd,OAAO,IAAI,CAAC,aAAa,CAAC;IAC5B,CAAC;IAED;;OAEG;IACH,oBAAoB;QAClB,OAAO,IAAI,CAAC,iBAAiB,CAAC;IAChC,CAAC;CACF"}

package/dist_ts/{congodb/server/CongoServer.d.ts → tsmdb/server/TsmdbServer.d.ts}

@@ -2,7 +2,7 @@ import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
 /**
  * Server configuration options
  */
-export interface ICongoServerOptions {
+export interface ITsmdbServerOptions {
     /** Port to listen on (default: 27017) */
     port?: number;
     /** Host to bind to (default: 127.0.0.1) */
@@ -17,24 +17,24 @@ export interface ICongoServerOptions {
     persistIntervalMs?: number;
 }
 /**
- * CongoServer - MongoDB Wire Protocol compatible server
+ * 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 { CongoServer } from '@push.rocks/smartmongo/congodb';
+ * import { TsmdbServer } from '@push.rocks/smartmongo/tsmdb';
  * import { MongoClient } from 'mongodb';
  *
- * const server = new CongoServer({ port: 27017 });
+ * const server = new TsmdbServer({ port: 27017 });
  * await server.start();
  *
  * const client = new MongoClient('mongodb://127.0.0.1:27017');
  * await client.connect();
  * ```
  */
-export declare class CongoServer {
+export declare class TsmdbServer {
     private options;
     private server;
     private storage;
@@ -43,7 +43,7 @@ export declare class CongoServer {
     private connectionIdCounter;
     private isRunning;
     private startTime;
-    constructor(options?: ICongoServerOptions);
+    constructor(options?: ITsmdbServerOptions);
     /**
      * Get the storage adapter (for testing/debugging)
      */