@push.rocks/smartmongo 3.0.0 → 4.1.1

package/dist_ts/tsmdb/storage/WAL.js

@@ -0,0 +1,286 @@
+import * as plugins from '../tsmdb.plugins.js';
+/**
+ * Write-Ahead Log (WAL) for durability and crash recovery
+ *
+ * The WAL ensures durability by writing operations to a log file before
+ * they are applied to the main storage. On crash recovery, uncommitted
+ * operations can be replayed to restore the database to a consistent state.
+ */
+export class WAL {
+    walPath;
+    currentLsn = 0;
+    lastCheckpointLsn = 0;
+    entries = [];
+    isInitialized = false;
+    fs = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
+    // In-memory uncommitted entries per transaction
+    uncommittedTxns = new Map();
+    // Checkpoint interval (number of entries between checkpoints)
+    checkpointInterval = 1000;
+    constructor(walPath, options) {
+        this.walPath = walPath;
+        if (options?.checkpointInterval) {
+            this.checkpointInterval = options.checkpointInterval;
+        }
+    }
+    /**
+     * Initialize the WAL, loading existing entries and recovering if needed
+     */
+    async initialize() {
+        if (this.isInitialized) {
+            return { recoveredEntries: [] };
+        }
+        // Ensure WAL directory exists
+        const walDir = this.walPath.substring(0, this.walPath.lastIndexOf('/'));
+        if (walDir) {
+            await this.fs.directory(walDir).recursive().create();
+        }
+        // Try to load existing WAL
+        const exists = await this.fs.file(this.walPath).exists();
+        if (exists) {
+            const content = await this.fs.file(this.walPath).encoding('utf8').read();
+            const lines = content.split('\n').filter(line => line.trim());
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    // Verify checksum
+                    if (this.verifyChecksum(entry)) {
+                        this.entries.push(entry);
+                        if (entry.lsn > this.currentLsn) {
+                            this.currentLsn = entry.lsn;
+                        }
+                        if (entry.operation === 'checkpoint') {
+                            this.lastCheckpointLsn = entry.lsn;
+                        }
+                    }
+                }
+                catch {
+                    // Skip corrupted entries
+                    console.warn('Skipping corrupted WAL entry');
+                }
+            }
+        }
+        this.isInitialized = true;
+        // Return entries after last checkpoint that need recovery
+        const recoveredEntries = this.entries.filter(e => e.lsn > this.lastCheckpointLsn &&
+            (e.operation === 'insert' || e.operation === 'update' || e.operation === 'delete'));
+        return { recoveredEntries };
+    }
+    /**
+     * Log an insert operation
+     */
+    async logInsert(dbName, collName, doc, txnId) {
+        return this.appendEntry({
+            operation: 'insert',
+            dbName,
+            collName,
+            documentId: doc._id.toHexString(),
+            data: this.serializeDocument(doc),
+            txnId,
+        });
+    }
+    /**
+     * Log an update operation
+     */
+    async logUpdate(dbName, collName, oldDoc, newDoc, txnId) {
+        return this.appendEntry({
+            operation: 'update',
+            dbName,
+            collName,
+            documentId: oldDoc._id.toHexString(),
+            data: this.serializeDocument(newDoc),
+            previousData: this.serializeDocument(oldDoc),
+            txnId,
+        });
+    }
+    /**
+     * Log a delete operation
+     */
+    async logDelete(dbName, collName, doc, txnId) {
+        return this.appendEntry({
+            operation: 'delete',
+            dbName,
+            collName,
+            documentId: doc._id.toHexString(),
+            previousData: this.serializeDocument(doc),
+            txnId,
+        });
+    }
+    /**
+     * Log transaction begin
+     */
+    async logBeginTransaction(txnId) {
+        this.uncommittedTxns.set(txnId, []);
+        return this.appendEntry({
+            operation: 'begin',
+            dbName: '',
+            collName: '',
+            documentId: '',
+            txnId,
+        });
+    }
+    /**
+     * Log transaction commit
+     */
+    async logCommitTransaction(txnId) {
+        this.uncommittedTxns.delete(txnId);
+        return this.appendEntry({
+            operation: 'commit',
+            dbName: '',
+            collName: '',
+            documentId: '',
+            txnId,
+        });
+    }
+    /**
+     * Log transaction abort
+     */
+    async logAbortTransaction(txnId) {
+        this.uncommittedTxns.delete(txnId);
+        return this.appendEntry({
+            operation: 'abort',
+            dbName: '',
+            collName: '',
+            documentId: '',
+            txnId,
+        });
+    }
+    /**
+     * Get entries to roll back for an aborted transaction
+     */
+    getTransactionEntries(txnId) {
+        return this.entries.filter(e => e.txnId === txnId);
+    }
+    /**
+     * Create a checkpoint - marks a consistent point in the log
+     */
+    async checkpoint() {
+        const lsn = await this.appendEntry({
+            operation: 'checkpoint',
+            dbName: '',
+            collName: '',
+            documentId: '',
+        });
+        this.lastCheckpointLsn = lsn;
+        // Truncate old entries (keep only entries after checkpoint)
+        await this.truncate();
+        return lsn;
+    }
+    /**
+     * Truncate the WAL file, removing entries before the last checkpoint
+     */
+    async truncate() {
+        // Keep entries after last checkpoint
+        const newEntries = this.entries.filter(e => e.lsn >= this.lastCheckpointLsn);
+        this.entries = newEntries;
+        // Rewrite the WAL file
+        const lines = this.entries.map(e => JSON.stringify(e)).join('\n');
+        await this.fs.file(this.walPath).encoding('utf8').write(lines);
+    }
+    /**
+     * Get current LSN
+     */
+    getCurrentLsn() {
+        return this.currentLsn;
+    }
+    /**
+     * Get entries after a specific LSN (for recovery)
+     */
+    getEntriesAfter(lsn) {
+        return this.entries.filter(e => e.lsn > lsn);
+    }
+    /**
+     * Close the WAL
+     */
+    async close() {
+        if (this.isInitialized) {
+            // Final checkpoint before close
+            await this.checkpoint();
+        }
+        this.isInitialized = false;
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    async appendEntry(partial) {
+        await this.initialize();
+        this.currentLsn++;
+        const entry = {
+            ...partial,
+            lsn: this.currentLsn,
+            timestamp: Date.now(),
+            checksum: 0, // Will be calculated
+        };
+        // Calculate checksum
+        entry.checksum = this.calculateChecksum(entry);
+        // Track in transaction if applicable
+        if (partial.txnId && this.uncommittedTxns.has(partial.txnId)) {
+            this.uncommittedTxns.get(partial.txnId).push(entry);
+        }
+        // Add to in-memory log
+        this.entries.push(entry);
+        // Append to file (append mode for durability)
+        await this.fs.file(this.walPath).encoding('utf8').append(JSON.stringify(entry) + '\n');
+        // Check if we need a checkpoint
+        if (this.entries.length - this.lastCheckpointLsn >= this.checkpointInterval) {
+            await this.checkpoint();
+        }
+        return entry.lsn;
+    }
+    serializeDocument(doc) {
+        // Serialize document to BSON and encode as base64
+        const bsonData = plugins.bson.serialize(doc);
+        return Buffer.from(bsonData).toString('base64');
+    }
+    deserializeDocument(data) {
+        // Decode base64 and deserialize from BSON
+        const buffer = Buffer.from(data, 'base64');
+        return plugins.bson.deserialize(buffer);
+    }
+    calculateChecksum(entry) {
+        // Simple CRC32-like checksum
+        const str = JSON.stringify({
+            lsn: entry.lsn,
+            timestamp: entry.timestamp,
+            operation: entry.operation,
+            dbName: entry.dbName,
+            collName: entry.collName,
+            documentId: entry.documentId,
+            data: entry.data,
+            previousData: entry.previousData,
+            txnId: entry.txnId,
+        });
+        let crc = 0xFFFFFFFF;
+        for (let i = 0; i < str.length; i++) {
+            crc ^= str.charCodeAt(i);
+            for (let j = 0; j < 8; j++) {
+                crc = (crc >>> 1) ^ (crc & 1 ? 0xEDB88320 : 0);
+            }
+        }
+        return (~crc) >>> 0;
+    }
+    verifyChecksum(entry) {
+        const savedChecksum = entry.checksum;
+        entry.checksum = 0;
+        const calculatedChecksum = this.calculateChecksum(entry);
+        entry.checksum = savedChecksum;
+        return calculatedChecksum === savedChecksum;
+    }
+    /**
+     * Recover document from WAL entry
+     */
+    recoverDocument(entry) {
+        if (!entry.data)
+            return null;
+        return this.deserializeDocument(entry.data);
+    }
+    /**
+     * Recover previous document state from WAL entry (for rollback)
+     */
+    recoverPreviousDocument(entry) {
+        if (!entry.previousData)
+            return null;
+        return this.deserializeDocument(entry.previousData);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"WAL.js","sourceRoot":"","sources":["../../../ts/tsmdb/storage/WAL.ts"],"names":[],"mappings":"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"}

package/dist_ts/tsmdb/utils/checksum.d.ts

@@ -0,0 +1,30 @@
+/**
+ * CRC32 checksum utilities for data integrity
+ */
+/**
+ * Calculate CRC32 checksum for a string
+ */
+export declare function calculateCRC32(data: string): number;
+/**
+ * Calculate CRC32 checksum for a Buffer
+ */
+export declare function calculateCRC32Buffer(data: Buffer): number;
+/**
+ * Calculate checksum for a document (serialized as JSON)
+ */
+export declare function calculateDocumentChecksum(doc: Record<string, any>): number;
+/**
+ * Add checksum to a document
+ */
+export declare function addChecksum<T extends Record<string, any>>(doc: T): T & {
+    _checksum: number;
+};
+/**
+ * Verify checksum of a document
+ * Returns true if checksum is valid or if document has no checksum
+ */
+export declare function verifyChecksum(doc: Record<string, any>): boolean;
+/**
+ * Remove checksum from a document
+ */
+export declare function removeChecksum<T extends Record<string, any>>(doc: T): Omit<T, '_checksum'>;

package/dist_ts/tsmdb/utils/checksum.js

@@ -0,0 +1,77 @@
+/**
+ * CRC32 checksum utilities for data integrity
+ */
+// CRC32 lookup table
+const CRC32_TABLE = [];
+// Initialize the CRC32 table
+function initCRC32Table() {
+    if (CRC32_TABLE.length > 0)
+        return;
+    for (let i = 0; i < 256; i++) {
+        let crc = i;
+        for (let j = 0; j < 8; j++) {
+            crc = (crc & 1) ? (0xEDB88320 ^ (crc >>> 1)) : (crc >>> 1);
+        }
+        CRC32_TABLE[i] = crc >>> 0;
+    }
+}
+/**
+ * Calculate CRC32 checksum for a string
+ */
+export function calculateCRC32(data) {
+    initCRC32Table();
+    let crc = 0xFFFFFFFF;
+    for (let i = 0; i < data.length; i++) {
+        const byte = data.charCodeAt(i) & 0xFF;
+        crc = CRC32_TABLE[(crc ^ byte) & 0xFF] ^ (crc >>> 8);
+    }
+    return (~crc) >>> 0;
+}
+/**
+ * Calculate CRC32 checksum for a Buffer
+ */
+export function calculateCRC32Buffer(data) {
+    initCRC32Table();
+    let crc = 0xFFFFFFFF;
+    for (let i = 0; i < data.length; i++) {
+        crc = CRC32_TABLE[(crc ^ data[i]) & 0xFF] ^ (crc >>> 8);
+    }
+    return (~crc) >>> 0;
+}
+/**
+ * Calculate checksum for a document (serialized as JSON)
+ */
+export function calculateDocumentChecksum(doc) {
+    // Exclude _checksum field from calculation
+    const { _checksum, ...docWithoutChecksum } = doc;
+    const json = JSON.stringify(docWithoutChecksum);
+    return calculateCRC32(json);
+}
+/**
+ * Add checksum to a document
+ */
+export function addChecksum(doc) {
+    const checksum = calculateDocumentChecksum(doc);
+    return { ...doc, _checksum: checksum };
+}
+/**
+ * Verify checksum of a document
+ * Returns true if checksum is valid or if document has no checksum
+ */
+export function verifyChecksum(doc) {
+    if (!('_checksum' in doc)) {
+        // No checksum to verify
+        return true;
+    }
+    const storedChecksum = doc._checksum;
+    const calculatedChecksum = calculateDocumentChecksum(doc);
+    return storedChecksum === calculatedChecksum;
+}
+/**
+ * Remove checksum from a document
+ */
+export function removeChecksum(doc) {
+    const { _checksum, ...docWithoutChecksum } = doc;
+    return docWithoutChecksum;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/tsmdb/utils/index.d.ts

@@ -0,0 +1 @@
+export * from './checksum.js';

package/dist_ts/tsmdb/utils/index.js

@@ -0,0 +1,2 @@
+export * from './checksum.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi90cy90c21kYi91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyJ9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartmongo",
-  "version": "3.0.0",
+  "version": "4.1.1",
   "private": false,
   "description": "A module for creating and managing a local MongoDB instance for testing purposes.",
   "main": "dist_ts/index.js",
@@ -9,7 +9,7 @@
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "(tstest test/)",
+    "test": "(tstest test/. --verbose --logfile --timeout 60)",
     "build": "(tsbuild --web)",
     "buildDocs": "tsdoc"
   },

package/readme.md

@@ -134,8 +134,8 @@ await server.start();
 console.log(server.getConnectionUri()); // mongodb://127.0.0.1:27017
 
 // Server properties
-console.log(server.running);           // true
-console.log(server.getUptime());       // seconds
+console.log(server.running);              // true
+console.log(server.getUptime());          // seconds
 console.log(server.getConnectionCount()); // active connections
 
 await server.stop();
@@ -279,7 +279,7 @@ console.log(result.deletedCount);   // 1
 
 ### Storage Adapters
 
-TsmDB supports pluggable storage:
+TsmDB supports pluggable storage with data integrity features:
 
 ```typescript
 // In-memory (default) - fast, data lost on stop
@@ -292,13 +292,118 @@ const server = new tsmdb.TsmdbServer({
   persistIntervalMs: 30000  // Save every 30 seconds
 });
 
-// File-based - persistent storage
-const server = new tsmdb.TsmdbServer({
-  storage: 'file',
-  storagePath: './data/tsmdb'
+// File-based - persistent storage with optional checksums
+import { FileStorageAdapter } from '@push.rocks/smartmongo/tsmdb';
+
+const adapter = new FileStorageAdapter('./data/tsmdb', {
+  enableChecksums: true,   // CRC32 checksums for data integrity
+  strictChecksums: false   // Log warnings vs throw on mismatch
 });
 ```
 
+## ⚡ Performance & Reliability Features
+
+TsmDB includes enterprise-grade features for robustness:
+
+### 🔍 Index-Accelerated Queries
+
+Indexes are automatically used to accelerate queries. Instead of scanning all documents, TsmDB uses:
+
+- **Hash indexes** for equality queries (`$eq`, `$in`)
+- **B-tree indexes** for range queries (`$gt`, `$gte`, `$lt`, `$lte`)
+
+```typescript
+// Create an index
+await collection.createIndex({ email: 1 });
+await collection.createIndex({ age: 1 });
+
+// These queries will use the index (fast!)
+await collection.findOne({ email: 'alice@example.com' }); // Uses hash lookup
+await collection.find({ age: { $gte: 18, $lt: 65 } });    // Uses B-tree range scan
+```
+
+### 📊 Query Planner
+
+TsmDB includes a query planner that analyzes queries and selects optimal execution strategies:
+
+```typescript
+import { tsmdb } from '@push.rocks/smartmongo';
+
+// For debugging, you can access the query planner
+const planner = new tsmdb.QueryPlanner(indexEngine);
+const plan = planner.createPlan(filter);
+
+console.log(plan);
+// {
+//   type: 'IXSCAN',           // or 'IXSCAN_RANGE', 'COLLSCAN'
+//   indexName: 'email_1',
+//   estimatedCost: 1,
+//   selectivity: 0.001
+// }
+```
+
+### 📝 Write-Ahead Logging (WAL)
+
+For durability, TsmDB supports write-ahead logging:
+
+```typescript
+import { tsmdb } from '@push.rocks/smartmongo';
+
+const wal = new tsmdb.WAL('./data/wal.log');
+await wal.initialize();
+
+// WAL entries include:
+// - LSN (Log Sequence Number)
+// - Timestamp
+// - Operation type (insert, update, delete, checkpoint)
+// - Document data (BSON serialized)
+// - CRC32 checksum
+
+// Recovery support
+const entries = await wal.getEntriesAfter(lastCheckpointLsn);
+```
+
+### 🔐 Session Management
+
+TsmDB tracks client sessions with automatic timeout and transaction linking:
+
+```typescript
+// Sessions are automatically managed when using the MongoDB driver
+const session = client.startSession();
+
+try {
+  session.startTransaction();
+  await collection.insertOne({ name: 'Alice' }, { session });
+  await collection.updateOne({ name: 'Bob' }, { $inc: { balance: 100 } }, { session });
+  await session.commitTransaction();
+} catch (error) {
+  await session.abortTransaction();
+} finally {
+  session.endSession();
+}
+
+// Session features:
+// - Automatic session timeout (30 minutes default)
+// - Transaction auto-abort on session expiry
+// - Session activity tracking
+```
+
+### ✅ Data Integrity Checksums
+
+File-based storage supports CRC32 checksums to detect corruption:
+
+```typescript
+import { FileStorageAdapter } from '@push.rocks/smartmongo/tsmdb';
+
+const adapter = new FileStorageAdapter('./data', {
+  enableChecksums: true,
+  strictChecksums: true  // Throw error on corruption (vs warning)
+});
+
+// Documents are checksummed on write, verified on read
+// Checksums are automatically stripped before returning to client
+```
+
 ### 📋 Supported Wire Protocol Commands
 
 | Category | Commands |
@@ -307,7 +412,9 @@ const server = new tsmdb.TsmdbServer({
 | **CRUD** | `find`, `insert`, `update`, `delete`, `findAndModify`, `getMore`, `killCursors` |
 | **Aggregation** | `aggregate`, `count`, `distinct` |
 | **Indexes** | `createIndexes`, `dropIndexes`, `listIndexes` |
-| **Admin** | `ping`, `listDatabases`, `listCollections`, `drop`, `dropDatabase`, `create`, `serverStatus`, `buildInfo` |
+| **Transactions** | `startTransaction`, `commitTransaction`, `abortTransaction` |
+| **Sessions** | `startSession`, `endSessions` |
+| **Admin** | `ping`, `listDatabases`, `listCollections`, `drop`, `dropDatabase`, `create`, `serverStatus`, `buildInfo`, `dbStats`, `collStats` |
 
 TsmDB supports MongoDB wire protocol versions 0-21, compatible with MongoDB 3.6 through 7.0 drivers.
 
@@ -317,7 +424,7 @@ TsmDB supports MongoDB wire protocol versions 0-21, compatible with MongoDB 3.6
 
 ```typescript
 import { tsmdb } from '@push.rocks/smartmongo';
-import { MongoClient } from 'mongodb';
+import { MongoClient, Db } from 'mongodb';
 
 let server: tsmdb.TsmdbServer;
 let client: MongoClient;
@@ -421,21 +528,37 @@ export default tap.start();
                           ▼
 ┌─────────────────────────────────────────────────────────────┐
 │                       Engines                               │
-│  ┌───────────┐ ┌────────────┐ ┌────────────┐ ┌───────────┐ │
-│  │  Query    │ │   Update   │ │Aggregation │ │   Index   │ │
-│  │  Engine   │ │   Engine   │ │  Engine    │ │  Engine   │ │
-│  └───────────┘ └────────────┘ └────────────┘ └───────────┘ │
+│  ┌─────────┐ ┌────────┐ ┌───────────┐ ┌───────┐ ┌───────┐ │
+│  │ Query   │ │ Update │ │Aggregation│ │ Index │ │Session│ │
+│  │ Planner │ │ Engine │ │  Engine   │ │Engine │ │Engine │ │
+│  └─────────┘ └────────┘ └───────────┘ └───────┘ └───────┘ │
+│                   ┌──────────────────────┐                  │
+│                   │ Transaction Engine   │                  │
+│                   └──────────────────────┘                  │
 └─────────────────────────┬───────────────────────────────────┘
                           │
                           ▼
 ┌─────────────────────────────────────────────────────────────┐
-│                   Storage Adapters                          │
-│       ┌──────────────────┐  ┌──────────────────┐           │
-│       │  MemoryStorage   │  │   FileStorage    │           │
-│       └──────────────────┘  └──────────────────┘           │
+│                   Storage Layer                              │
+│  ┌──────────────────┐  ┌──────────────────┐  ┌──────────┐  │
+│  │  MemoryStorage   │  │   FileStorage    │  │   WAL    │  │
+│  │                  │  │  (+ Checksums)   │  │          │  │
+│  └──────────────────┘  └──────────────────┘  └──────────┘  │
 └─────────────────────────────────────────────────────────────┘
 ```
 
+### Key Components
+
+| Component | Description |
+|-----------|-------------|
+| **WireProtocol** | Parses MongoDB OP_MSG binary protocol |
+| **CommandRouter** | Routes commands to appropriate handlers |
+| **QueryPlanner** | Analyzes queries and selects execution strategy |
+| **IndexEngine** | Manages B-tree and hash indexes |
+| **SessionEngine** | Tracks client sessions and timeouts |
+| **TransactionEngine** | Handles ACID transaction semantics |
+| **WAL** | Write-ahead logging for durability |
+
 ## License and Legal Information
 
 This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [LICENSE](./LICENSE) file.

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@push.rocks/smartmongo',
-  version: '3.0.0',
+  version: '4.1.1',
   description: 'A module for creating and managing a local MongoDB instance for testing purposes.'
 }