@push.rocks/smartmongo 2.2.0 → 4.0.0

package/dist_ts/tsmdb/engine/SessionEngine.d.ts

@@ -0,0 +1,117 @@
+import type { TransactionEngine } from './TransactionEngine.js';
+/**
+ * Session state
+ */
+export interface ISession {
+    /** Session ID (UUID) */
+    id: string;
+    /** Timestamp when the session was created */
+    createdAt: number;
+    /** Timestamp of the last activity */
+    lastActivityAt: number;
+    /** Current transaction ID if any */
+    txnId?: string;
+    /** Transaction number for ordering */
+    txnNumber?: number;
+    /** Whether the session is in a transaction */
+    inTransaction: boolean;
+    /** Session metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Session engine options
+ */
+export interface ISessionEngineOptions {
+    /** Session timeout in milliseconds (default: 30 minutes) */
+    sessionTimeoutMs?: number;
+    /** Interval to check for expired sessions in ms (default: 60 seconds) */
+    cleanupIntervalMs?: number;
+}
+/**
+ * Session engine for managing client sessions
+ * - Tracks session lifecycle (create, touch, end)
+ * - Links sessions to transactions
+ * - Auto-aborts transactions on session expiry
+ */
+export declare class SessionEngine {
+    private sessions;
+    private sessionTimeoutMs;
+    private cleanupInterval?;
+    private transactionEngine?;
+    constructor(options?: ISessionEngineOptions);
+    /**
+     * Set the transaction engine to use for auto-abort
+     */
+    setTransactionEngine(engine: TransactionEngine): void;
+    /**
+     * Start a new session
+     */
+    startSession(sessionId?: string, metadata?: Record<string, any>): ISession;
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId: string): ISession | undefined;
+    /**
+     * Touch a session to update last activity time
+     */
+    touchSession(sessionId: string): boolean;
+    /**
+     * End a session explicitly
+     * This will also abort any active transaction
+     */
+    endSession(sessionId: string): Promise<boolean>;
+    /**
+     * Start a transaction in a session
+     */
+    startTransaction(sessionId: string, txnId: string, txnNumber?: number): boolean;
+    /**
+     * End a transaction in a session (commit or abort)
+     */
+    endTransaction(sessionId: string): boolean;
+    /**
+     * Get transaction ID for a session
+     */
+    getTransactionId(sessionId: string): string | undefined;
+    /**
+     * Check if session is in a transaction
+     */
+    isInTransaction(sessionId: string): boolean;
+    /**
+     * Check if a session is expired
+     */
+    isSessionExpired(session: ISession): boolean;
+    /**
+     * Cleanup expired sessions
+     * This is called periodically by the cleanup interval
+     */
+    private cleanupExpiredSessions;
+    /**
+     * Get all active sessions
+     */
+    listSessions(): ISession[];
+    /**
+     * Get session count
+     */
+    getSessionCount(): number;
+    /**
+     * Get sessions with active transactions
+     */
+    getSessionsWithTransactions(): ISession[];
+    /**
+     * Refresh session timeout
+     */
+    refreshSession(sessionId: string): boolean;
+    /**
+     * Close the session engine and cleanup
+     */
+    close(): void;
+    /**
+     * Get or create a session for a given session ID
+     * Useful for handling MongoDB driver session requests
+     */
+    getOrCreateSession(sessionId: string): ISession;
+    /**
+     * Extract session ID from MongoDB lsid (logical session ID)
+     */
+    static extractSessionId(lsid: any): string | undefined;
+}

package/dist_ts/tsmdb/engine/SessionEngine.js

@@ -0,0 +1,232 @@
+import * as plugins from '../tsmdb.plugins.js';
+/**
+ * Session engine for managing client sessions
+ * - Tracks session lifecycle (create, touch, end)
+ * - Links sessions to transactions
+ * - Auto-aborts transactions on session expiry
+ */
+export class SessionEngine {
+    sessions = new Map();
+    sessionTimeoutMs;
+    cleanupInterval;
+    transactionEngine;
+    constructor(options) {
+        this.sessionTimeoutMs = options?.sessionTimeoutMs ?? 30 * 60 * 1000; // 30 minutes default
+        const cleanupIntervalMs = options?.cleanupIntervalMs ?? 60 * 1000; // 1 minute default
+        // Start cleanup interval
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupExpiredSessions();
+        }, cleanupIntervalMs);
+    }
+    /**
+     * Set the transaction engine to use for auto-abort
+     */
+    setTransactionEngine(engine) {
+        this.transactionEngine = engine;
+    }
+    /**
+     * Start a new session
+     */
+    startSession(sessionId, metadata) {
+        const id = sessionId ?? new plugins.bson.UUID().toHexString();
+        const now = Date.now();
+        const session = {
+            id,
+            createdAt: now,
+            lastActivityAt: now,
+            inTransaction: false,
+            metadata,
+        };
+        this.sessions.set(id, session);
+        return session;
+    }
+    /**
+     * Get a session by ID
+     */
+    getSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (session && this.isSessionExpired(session)) {
+            // Session expired, clean it up
+            this.endSession(sessionId);
+            return undefined;
+        }
+        return session;
+    }
+    /**
+     * Touch a session to update last activity time
+     */
+    touchSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        if (this.isSessionExpired(session)) {
+            this.endSession(sessionId);
+            return false;
+        }
+        session.lastActivityAt = Date.now();
+        return true;
+    }
+    /**
+     * End a session explicitly
+     * This will also abort any active transaction
+     */
+    async endSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        // If session has an active transaction, abort it
+        if (session.inTransaction && session.txnId && this.transactionEngine) {
+            try {
+                await this.transactionEngine.abortTransaction(session.txnId);
+            }
+            catch (e) {
+                // Ignore abort errors during cleanup
+            }
+        }
+        this.sessions.delete(sessionId);
+        return true;
+    }
+    /**
+     * Start a transaction in a session
+     */
+    startTransaction(sessionId, txnId, txnNumber) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        if (this.isSessionExpired(session)) {
+            this.endSession(sessionId);
+            return false;
+        }
+        session.txnId = txnId;
+        session.txnNumber = txnNumber;
+        session.inTransaction = true;
+        session.lastActivityAt = Date.now();
+        return true;
+    }
+    /**
+     * End a transaction in a session (commit or abort)
+     */
+    endTransaction(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session)
+            return false;
+        session.txnId = undefined;
+        session.txnNumber = undefined;
+        session.inTransaction = false;
+        session.lastActivityAt = Date.now();
+        return true;
+    }
+    /**
+     * Get transaction ID for a session
+     */
+    getTransactionId(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.txnId;
+    }
+    /**
+     * Check if session is in a transaction
+     */
+    isInTransaction(sessionId) {
+        const session = this.sessions.get(sessionId);
+        return session?.inTransaction ?? false;
+    }
+    /**
+     * Check if a session is expired
+     */
+    isSessionExpired(session) {
+        return Date.now() - session.lastActivityAt > this.sessionTimeoutMs;
+    }
+    /**
+     * Cleanup expired sessions
+     * This is called periodically by the cleanup interval
+     */
+    async cleanupExpiredSessions() {
+        const expiredSessions = [];
+        for (const [id, session] of this.sessions) {
+            if (this.isSessionExpired(session)) {
+                expiredSessions.push(id);
+            }
+        }
+        // End all expired sessions (this will also abort their transactions)
+        for (const sessionId of expiredSessions) {
+            await this.endSession(sessionId);
+        }
+    }
+    /**
+     * Get all active sessions
+     */
+    listSessions() {
+        const activeSessions = [];
+        for (const session of this.sessions.values()) {
+            if (!this.isSessionExpired(session)) {
+                activeSessions.push(session);
+            }
+        }
+        return activeSessions;
+    }
+    /**
+     * Get session count
+     */
+    getSessionCount() {
+        return this.sessions.size;
+    }
+    /**
+     * Get sessions with active transactions
+     */
+    getSessionsWithTransactions() {
+        return this.listSessions().filter(s => s.inTransaction);
+    }
+    /**
+     * Refresh session timeout
+     */
+    refreshSession(sessionId) {
+        return this.touchSession(sessionId);
+    }
+    /**
+     * Close the session engine and cleanup
+     */
+    close() {
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = undefined;
+        }
+        // Clear all sessions
+        this.sessions.clear();
+    }
+    /**
+     * Get or create a session for a given session ID
+     * Useful for handling MongoDB driver session requests
+     */
+    getOrCreateSession(sessionId) {
+        let session = this.getSession(sessionId);
+        if (!session) {
+            session = this.startSession(sessionId);
+        }
+        else {
+            this.touchSession(sessionId);
+        }
+        return session;
+    }
+    /**
+     * Extract session ID from MongoDB lsid (logical session ID)
+     */
+    static extractSessionId(lsid) {
+        if (!lsid)
+            return undefined;
+        // MongoDB session ID format: { id: UUID }
+        if (lsid.id) {
+            if (lsid.id instanceof plugins.bson.UUID) {
+                return lsid.id.toHexString();
+            }
+            if (typeof lsid.id === 'string') {
+                return lsid.id;
+            }
+            if (lsid.id.$binary?.base64) {
+                // Binary UUID format
+                return Buffer.from(lsid.id.$binary.base64, 'base64').toString('hex');
+            }
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/{congodb → tsmdb}/engine/TransactionEngine.d.ts

@@ -1,4 +1,4 @@
-import * as plugins from '../congodb.plugins.js';
+import * as plugins from '../tsmdb.plugins.js';
 import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
 import type { IStoredDocument, ITransactionOptions } from '../types/interfaces.js';
 /**

package/dist_ts/tsmdb/engine/TransactionEngine.js

@@ -0,0 +1,287 @@
+import * as plugins from '../tsmdb.plugins.js';
+import { TsmdbTransactionError, TsmdbWriteConflictError } from '../errors/TsmdbErrors.js';
+/**
+ * Transaction engine for ACID transaction support
+ */
+export class TransactionEngine {
+    storage;
+    transactions = new Map();
+    txnCounter = 0;
+    constructor(storage) {
+        this.storage = storage;
+    }
+    /**
+     * Start a new transaction
+     */
+    startTransaction(sessionId, options) {
+        this.txnCounter++;
+        const txnId = `txn_${sessionId}_${this.txnCounter}`;
+        const transaction = {
+            id: txnId,
+            sessionId,
+            startTime: new plugins.bson.Timestamp({ t: Math.floor(Date.now() / 1000), i: this.txnCounter }),
+            status: 'active',
+            readSet: new Map(),
+            writeSet: new Map(),
+            snapshots: new Map(),
+        };
+        this.transactions.set(txnId, transaction);
+        return txnId;
+    }
+    /**
+     * Get a transaction by ID
+     */
+    getTransaction(txnId) {
+        return this.transactions.get(txnId);
+    }
+    /**
+     * Check if a transaction is active
+     */
+    isActive(txnId) {
+        const txn = this.transactions.get(txnId);
+        return txn?.status === 'active';
+    }
+    /**
+     * Get or create a snapshot for a namespace
+     */
+    async getSnapshot(txnId, dbName, collName) {
+        const txn = this.transactions.get(txnId);
+        if (!txn || txn.status !== 'active') {
+            throw new TsmdbTransactionError('Transaction is not active');
+        }
+        const ns = `${dbName}.${collName}`;
+        if (!txn.snapshots.has(ns)) {
+            const snapshot = await this.storage.createSnapshot(dbName, collName);
+            txn.snapshots.set(ns, snapshot);
+        }
+        // Apply transaction writes to snapshot
+        const snapshot = txn.snapshots.get(ns);
+        const writes = txn.writeSet.get(ns);
+        if (!writes) {
+            return snapshot;
+        }
+        // Create a modified view of the snapshot
+        const result = [];
+        const deletedIds = new Set();
+        const modifiedDocs = new Map();
+        for (const [idStr, write] of writes) {
+            if (write.op === 'delete') {
+                deletedIds.add(idStr);
+            }
+            else if (write.op === 'update' || write.op === 'insert') {
+                if (write.doc) {
+                    modifiedDocs.set(idStr, write.doc);
+                }
+            }
+        }
+        // Add existing documents (not deleted, possibly modified)
+        for (const doc of snapshot) {
+            const idStr = doc._id.toHexString();
+            if (deletedIds.has(idStr)) {
+                continue;
+            }
+            if (modifiedDocs.has(idStr)) {
+                result.push(modifiedDocs.get(idStr));
+                modifiedDocs.delete(idStr);
+            }
+            else {
+                result.push(doc);
+            }
+        }
+        // Add new documents (inserts)
+        for (const doc of modifiedDocs.values()) {
+            result.push(doc);
+        }
+        return result;
+    }
+    /**
+     * Record a read operation
+     */
+    recordRead(txnId, dbName, collName, docIds) {
+        const txn = this.transactions.get(txnId);
+        if (!txn || txn.status !== 'active')
+            return;
+        const ns = `${dbName}.${collName}`;
+        if (!txn.readSet.has(ns)) {
+            txn.readSet.set(ns, new Set());
+        }
+        const readSet = txn.readSet.get(ns);
+        for (const id of docIds) {
+            readSet.add(id);
+        }
+    }
+    /**
+     * Record a write operation (insert)
+     */
+    recordInsert(txnId, dbName, collName, doc) {
+        const txn = this.transactions.get(txnId);
+        if (!txn || txn.status !== 'active') {
+            throw new TsmdbTransactionError('Transaction is not active');
+        }
+        const ns = `${dbName}.${collName}`;
+        if (!txn.writeSet.has(ns)) {
+            txn.writeSet.set(ns, new Map());
+        }
+        txn.writeSet.get(ns).set(doc._id.toHexString(), {
+            op: 'insert',
+            doc,
+        });
+    }
+    /**
+     * Record a write operation (update)
+     */
+    recordUpdate(txnId, dbName, collName, originalDoc, updatedDoc) {
+        const txn = this.transactions.get(txnId);
+        if (!txn || txn.status !== 'active') {
+            throw new TsmdbTransactionError('Transaction is not active');
+        }
+        const ns = `${dbName}.${collName}`;
+        if (!txn.writeSet.has(ns)) {
+            txn.writeSet.set(ns, new Map());
+        }
+        const idStr = originalDoc._id.toHexString();
+        const existing = txn.writeSet.get(ns).get(idStr);
+        // If we already have a write for this document, update it
+        if (existing) {
+            existing.doc = updatedDoc;
+        }
+        else {
+            txn.writeSet.get(ns).set(idStr, {
+                op: 'update',
+                doc: updatedDoc,
+                originalDoc,
+            });
+        }
+    }
+    /**
+     * Record a write operation (delete)
+     */
+    recordDelete(txnId, dbName, collName, doc) {
+        const txn = this.transactions.get(txnId);
+        if (!txn || txn.status !== 'active') {
+            throw new TsmdbTransactionError('Transaction is not active');
+        }
+        const ns = `${dbName}.${collName}`;
+        if (!txn.writeSet.has(ns)) {
+            txn.writeSet.set(ns, new Map());
+        }
+        const idStr = doc._id.toHexString();
+        const existing = txn.writeSet.get(ns).get(idStr);
+        if (existing && existing.op === 'insert') {
+            // If we inserted and then deleted, just remove the write
+            txn.writeSet.get(ns).delete(idStr);
+        }
+        else {
+            txn.writeSet.get(ns).set(idStr, {
+                op: 'delete',
+                originalDoc: doc,
+            });
+        }
+    }
+    /**
+     * Commit a transaction
+     */
+    async commitTransaction(txnId) {
+        const txn = this.transactions.get(txnId);
+        if (!txn) {
+            throw new TsmdbTransactionError('Transaction not found');
+        }
+        if (txn.status !== 'active') {
+            throw new TsmdbTransactionError(`Cannot commit transaction in state: ${txn.status}`);
+        }
+        // Check for write conflicts
+        for (const [ns, writes] of txn.writeSet) {
+            const [dbName, collName] = ns.split('.');
+            const ids = Array.from(writes.keys()).map(id => new plugins.bson.ObjectId(id));
+            const hasConflicts = await this.storage.hasConflicts(dbName, collName, ids, txn.startTime);
+            if (hasConflicts) {
+                txn.status = 'aborted';
+                throw new TsmdbWriteConflictError();
+            }
+        }
+        // Apply all writes
+        for (const [ns, writes] of txn.writeSet) {
+            const [dbName, collName] = ns.split('.');
+            for (const [idStr, write] of writes) {
+                switch (write.op) {
+                    case 'insert':
+                        if (write.doc) {
+                            await this.storage.insertOne(dbName, collName, write.doc);
+                        }
+                        break;
+                    case 'update':
+                        if (write.doc) {
+                            await this.storage.updateById(dbName, collName, new plugins.bson.ObjectId(idStr), write.doc);
+                        }
+                        break;
+                    case 'delete':
+                        await this.storage.deleteById(dbName, collName, new plugins.bson.ObjectId(idStr));
+                        break;
+                }
+            }
+        }
+        txn.status = 'committed';
+    }
+    /**
+     * Abort a transaction
+     */
+    async abortTransaction(txnId) {
+        const txn = this.transactions.get(txnId);
+        if (!txn) {
+            throw new TsmdbTransactionError('Transaction not found');
+        }
+        if (txn.status !== 'active') {
+            // Already committed or aborted, just return
+            return;
+        }
+        // Simply discard all buffered writes
+        txn.writeSet.clear();
+        txn.readSet.clear();
+        txn.snapshots.clear();
+        txn.status = 'aborted';
+    }
+    /**
+     * End a transaction (cleanup)
+     */
+    endTransaction(txnId) {
+        this.transactions.delete(txnId);
+    }
+    /**
+     * Get all pending writes for a namespace
+     */
+    getPendingWrites(txnId, dbName, collName) {
+        const txn = this.transactions.get(txnId);
+        if (!txn)
+            return undefined;
+        const ns = `${dbName}.${collName}`;
+        return txn.writeSet.get(ns);
+    }
+    /**
+     * Execute a callback within a transaction, with automatic retry on conflict
+     */
+    async withTransaction(sessionId, callback, options) {
+        const maxRetries = options?.maxRetries ?? 3;
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
+            const txnId = this.startTransaction(sessionId, options);
+            try {
+                const result = await callback(txnId);
+                await this.commitTransaction(txnId);
+                this.endTransaction(txnId);
+                return result;
+            }
+            catch (error) {
+                await this.abortTransaction(txnId);
+                this.endTransaction(txnId);
+                if (error instanceof TsmdbWriteConflictError && attempt < maxRetries - 1) {
+                    // Retry on write conflict
+                    lastError = error;
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw lastError || new TsmdbTransactionError('Transaction failed after max retries');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransactionEngine.js","sourceRoot":"","sources":["../../../ts/tsmdb/engine/TransactionEngine.ts"],"names":[],"mappings":"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"}