@push.rocks/smartdb 1.0.1

package/dist_ts/ts_smartdb/errors/SmartdbErrors.js

@@ -0,0 +1,155 @@
+/**
+ * Base error class for all SmartDB errors
+ * Mirrors MongoDB driver error hierarchy
+ */
+export class SmartdbError extends Error {
+    code;
+    codeName;
+    constructor(message, code, codeName) {
+        super(message);
+        this.name = 'SmartdbError';
+        this.code = code;
+        this.codeName = codeName;
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+}
+/**
+ * Error thrown during connection issues
+ */
+export class SmartdbConnectionError extends SmartdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'SmartdbConnectionError';
+    }
+}
+/**
+ * Error thrown when an operation times out
+ */
+export class SmartdbTimeoutError extends SmartdbError {
+    constructor(message) {
+        super(message, 50, 'MaxTimeMSExpired');
+        this.name = 'SmartdbTimeoutError';
+    }
+}
+/**
+ * Error thrown during write operations
+ */
+export class SmartdbWriteError extends SmartdbError {
+    writeErrors;
+    result;
+    constructor(message, code, writeErrors) {
+        super(message, code);
+        this.name = 'SmartdbWriteError';
+        this.writeErrors = writeErrors;
+    }
+}
+/**
+ * Error thrown for duplicate key violations
+ */
+export class SmartdbDuplicateKeyError extends SmartdbWriteError {
+    keyPattern;
+    keyValue;
+    constructor(message, keyPattern, keyValue) {
+        super(message, 11000);
+        this.name = 'SmartdbDuplicateKeyError';
+        this.codeName = 'DuplicateKey';
+        this.keyPattern = keyPattern;
+        this.keyValue = keyValue;
+    }
+}
+/**
+ * Error thrown for bulk write failures
+ */
+export class SmartdbBulkWriteError extends SmartdbError {
+    writeErrors;
+    result;
+    constructor(message, writeErrors, result) {
+        super(message, 65);
+        this.name = 'SmartdbBulkWriteError';
+        this.writeErrors = writeErrors;
+        this.result = result;
+    }
+}
+/**
+ * Error thrown during transaction operations
+ */
+export class SmartdbTransactionError extends SmartdbError {
+    constructor(message, code) {
+        super(message, code);
+        this.name = 'SmartdbTransactionError';
+    }
+}
+/**
+ * Error thrown when a transaction is aborted due to conflict
+ */
+export class SmartdbWriteConflictError extends SmartdbTransactionError {
+    constructor(message = 'Write conflict during transaction') {
+        super(message, 112);
+        this.name = 'SmartdbWriteConflictError';
+        this.codeName = 'WriteConflict';
+    }
+}
+/**
+ * Error thrown for invalid arguments
+ */
+export class SmartdbArgumentError extends SmartdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'SmartdbArgumentError';
+    }
+}
+/**
+ * Error thrown when an operation is not supported
+ */
+export class SmartdbNotSupportedError extends SmartdbError {
+    constructor(message) {
+        super(message, 115);
+        this.name = 'SmartdbNotSupportedError';
+        this.codeName = 'CommandNotSupported';
+    }
+}
+/**
+ * Error thrown when cursor is exhausted or closed
+ */
+export class SmartdbCursorError extends SmartdbError {
+    constructor(message) {
+        super(message);
+        this.name = 'SmartdbCursorError';
+    }
+}
+/**
+ * Error thrown when a namespace (database.collection) is invalid
+ */
+export class SmartdbNamespaceError extends SmartdbError {
+    constructor(message) {
+        super(message, 73);
+        this.name = 'SmartdbNamespaceError';
+        this.codeName = 'InvalidNamespace';
+    }
+}
+/**
+ * Error thrown when an index operation fails
+ */
+export class SmartdbIndexError extends SmartdbError {
+    constructor(message, code) {
+        super(message, code || 86);
+        this.name = 'SmartdbIndexError';
+    }
+}
+/**
+ * Convert any error to a SmartdbError
+ */
+export function toSmartdbError(error) {
+    if (error instanceof SmartdbError) {
+        return error;
+    }
+    const smartdbError = new SmartdbError(error.message || String(error));
+    if (error.code) {
+        smartdbError.code = error.code;
+    }
+    if (error.codeName) {
+        smartdbError.codeName = error.codeName;
+    }
+    return smartdbError;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/ts_smartdb/index.d.ts

@@ -0,0 +1,26 @@
+import * as plugins from './plugins.js';
+export { plugins };
+export { ObjectId, Binary, Timestamp, Long, Decimal128, UUID } from 'bson';
+export * from './types/interfaces.js';
+export * from './errors/SmartdbErrors.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 { 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 { SmartdbServer } from './server/SmartdbServer.js';
+export type { ISmartdbServerOptions } from './server/SmartdbServer.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/ts_smartdb/index.js

@@ -0,0 +1,31 @@
+// SmartDB - MongoDB Wire Protocol compatible in-memory database server
+// Use the official MongoDB driver to connect to SmartdbServer
+// Re-export plugins for external use
+import * as plugins from './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/SmartdbErrors.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 SmartDB)
+export { SmartdbServer } from './server/SmartdbServer.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi90cy90c19zbWFydGRiL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHVFQUF1RTtBQUN2RSw4REFBOEQ7QUFFOUQscUNBQXFDO0FBQ3JDLE9BQU8sS0FBSyxPQUFPLE1BQU0sY0FBYyxDQUFDO0FBQ3hDLE9BQU8sRUFBRSxPQUFPLEVBQUUsQ0FBQztBQUVuQixvQ0FBb0M7QUFDcEMsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLEVBQUUsU0FBUyxFQUFFLElBQUksRUFBRSxVQUFVLEVBQUUsSUFBSSxFQUFFLE1BQU0sTUFBTSxDQUFDO0FBRTNFLG1CQUFtQjtBQUNuQixjQUFjLHVCQUF1QixDQUFDO0FBRXRDLGdCQUFnQjtBQUNoQixjQUFjLDJCQUEyQixDQUFDO0FBSTFDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDO0FBQ3pFLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGlDQUFpQyxDQUFDO0FBQ3JFLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUMzQyxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFHdkMsaUJBQWlCO0FBQ2pCLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSx5QkFBeUIsQ0FBQztBQUN0RCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDeEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sK0JBQStCLENBQUM7QUFDbEUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLHlCQUF5QixDQUFDO0FBQ3RELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ2xFLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQztBQUV4RCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sMkJBQTJCLENBQUM7QUFHMUQseURBQXlEO0FBQ3pELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUcxRCxzREFBc0Q7QUFDdEQsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDBCQUEwQixDQUFDO0FBQ3hELE9BQU8sRUFBRSxhQUFhLEVBQUUsTUFBTSwyQkFBMkIsQ0FBQztBQUcxRCxtQkFBbUI7QUFDbkIsY0FBYyxxQkFBcUIsQ0FBQyJ9

package/dist_ts/ts_smartdb/plugins.d.ts

@@ -0,0 +1,10 @@
+import * as smartfs from '@push.rocks/smartfs';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+export { smartfs, smartpath, smartpromise, smartrx };
+import * as bson from 'bson';
+import * as mingo from 'mingo';
+export { bson, mingo };
+export { Query } from 'mingo';
+export { Aggregator } from 'mingo';

package/dist_ts/ts_smartdb/plugins.js

@@ -0,0 +1,14 @@
+// @push.rocks scope
+import * as smartfs from '@push.rocks/smartfs';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+export { smartfs, smartpath, smartpromise, smartrx };
+// thirdparty
+import * as bson from 'bson';
+import * as mingo from 'mingo';
+export { bson, mingo };
+// Re-export commonly used mingo classes
+export { Query } from 'mingo';
+export { Aggregator } from 'mingo';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3RzX3NtYXJ0ZGIvcGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxvQkFBb0I7QUFDcEIsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssU0FBUyxNQUFNLHVCQUF1QixDQUFDO0FBQ25ELE9BQU8sS0FBSyxZQUFZLE1BQU0sMEJBQTBCLENBQUM7QUFDekQsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUUvQyxPQUFPLEVBQUUsT0FBTyxFQUFFLFNBQVMsRUFBRSxZQUFZLEVBQUUsT0FBTyxFQUFFLENBQUM7QUFFckQsYUFBYTtBQUNiLE9BQU8sS0FBSyxJQUFJLE1BQU0sTUFBTSxDQUFDO0FBQzdCLE9BQU8sS0FBSyxLQUFLLE1BQU0sT0FBTyxDQUFDO0FBRS9CLE9BQU8sRUFBRSxJQUFJLEVBQUUsS0FBSyxFQUFFLENBQUM7QUFFdkIsd0NBQXdDO0FBQ3hDLE9BQU8sRUFBRSxLQUFLLEVBQUUsTUFBTSxPQUFPLENBQUM7QUFDOUIsT0FBTyxFQUFFLFVBQVUsRUFBRSxNQUFNLE9BQU8sQ0FBQyJ9

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

@@ -0,0 +1,87 @@
+import * as plugins from '../plugins.js';
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+import type { IParsedCommand } from './WireProtocol.js';
+import type { SmartdbServer } from './SmartdbServer.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: SmartdbServer;
+    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: SmartdbServer);
+    /**
+     * 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/ts_smartdb/server/CommandRouter.js

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