@push.rocks/smartmongo 2.2.0 → 4.0.0

package/dist_ts/tsmdb/storage/WAL.d.ts

@@ -0,0 +1,117 @@
+import type { IStoredDocument } from '../types/interfaces.js';
+/**
+ * WAL entry operation types
+ */
+export type TWalOperation = 'insert' | 'update' | 'delete' | 'checkpoint' | 'begin' | 'commit' | 'abort';
+/**
+ * WAL entry structure
+ */
+export interface IWalEntry {
+    /** Log Sequence Number - monotonically increasing */
+    lsn: number;
+    /** Timestamp of the operation */
+    timestamp: number;
+    /** Operation type */
+    operation: TWalOperation;
+    /** Database name */
+    dbName: string;
+    /** Collection name */
+    collName: string;
+    /** Document ID (hex string) */
+    documentId: string;
+    /** Document data (BSON serialized, base64 encoded) */
+    data?: string;
+    /** Previous document data for updates (for rollback) */
+    previousData?: string;
+    /** Transaction ID if part of a transaction */
+    txnId?: string;
+    /** CRC32 checksum of the entry (excluding this field) */
+    checksum: number;
+}
+/**
+ * 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 declare class WAL {
+    private walPath;
+    private currentLsn;
+    private lastCheckpointLsn;
+    private entries;
+    private isInitialized;
+    private fs;
+    private uncommittedTxns;
+    private checkpointInterval;
+    constructor(walPath: string, options?: {
+        checkpointInterval?: number;
+    });
+    /**
+     * Initialize the WAL, loading existing entries and recovering if needed
+     */
+    initialize(): Promise<{
+        recoveredEntries: IWalEntry[];
+    }>;
+    /**
+     * Log an insert operation
+     */
+    logInsert(dbName: string, collName: string, doc: IStoredDocument, txnId?: string): Promise<number>;
+    /**
+     * Log an update operation
+     */
+    logUpdate(dbName: string, collName: string, oldDoc: IStoredDocument, newDoc: IStoredDocument, txnId?: string): Promise<number>;
+    /**
+     * Log a delete operation
+     */
+    logDelete(dbName: string, collName: string, doc: IStoredDocument, txnId?: string): Promise<number>;
+    /**
+     * Log transaction begin
+     */
+    logBeginTransaction(txnId: string): Promise<number>;
+    /**
+     * Log transaction commit
+     */
+    logCommitTransaction(txnId: string): Promise<number>;
+    /**
+     * Log transaction abort
+     */
+    logAbortTransaction(txnId: string): Promise<number>;
+    /**
+     * Get entries to roll back for an aborted transaction
+     */
+    getTransactionEntries(txnId: string): IWalEntry[];
+    /**
+     * Create a checkpoint - marks a consistent point in the log
+     */
+    checkpoint(): Promise<number>;
+    /**
+     * Truncate the WAL file, removing entries before the last checkpoint
+     */
+    private truncate;
+    /**
+     * Get current LSN
+     */
+    getCurrentLsn(): number;
+    /**
+     * Get entries after a specific LSN (for recovery)
+     */
+    getEntriesAfter(lsn: number): IWalEntry[];
+    /**
+     * Close the WAL
+     */
+    close(): Promise<void>;
+    private appendEntry;
+    private serializeDocument;
+    private deserializeDocument;
+    private calculateChecksum;
+    private verifyChecksum;
+    /**
+     * Recover document from WAL entry
+     */
+    recoverDocument(entry: IWalEntry): IStoredDocument | null;
+    /**
+     * Recover previous document state from WAL entry (for rollback)
+     */
+    recoverPreviousDocument(entry: IWalEntry): IStoredDocument | null;
+}

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/tsmdb.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHNtZGIucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3RzL3RzbWRiL3RzbWRiLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFFL0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRXJELGFBQWE7QUFDYixPQUFPLEtBQUssSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUM3QixPQUFPLEtBQUssS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUUvQixPQUFPLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxDQUFDO0FBRXZCLHdDQUF3QztBQUN4QyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sT0FBTyxDQUFDO0FBQzlCLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxPQUFPLENBQUMifQ==

package/dist_ts/{congodb → tsmdb}/types/interfaces.d.ts

@@ -1,9 +1,9 @@
-import type * as plugins from '../congodb.plugins.js';
+import type * as plugins from '../tsmdb.plugins.js';
 export type Document = Record<string, any>;
 export interface WithId<TSchema> {
     _id: plugins.bson.ObjectId;
 }
-export interface ICongoClientOptions {
+export interface ITsmdbClientOptions {
     /** Storage adapter type: 'memory' or 'file' */
     storageType?: 'memory' | 'file';
     /** Path for file-based storage */
@@ -14,7 +14,7 @@ export interface ICongoClientOptions {
     persistPath?: string;
 }
 export interface IParsedConnectionString {
-    protocol: 'congo';
+    protocol: 'tsmdb';
     storageType: 'memory' | 'file';
     options: {
         persist?: string;

package/dist_ts/{congodb → tsmdb}/types/interfaces.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL2NvbmdvZGIvdHlwZXMvaW50ZXJmYWNlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3RzL3RzbWRiL3R5cGVzL2ludGVyZmFjZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiJ9

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": "2.2.0",
+  "version": "4.0.0",
   "private": false,
   "description": "A module for creating and managing a local MongoDB instance for testing purposes.",
   "main": "dist_ts/index.js",

package/readme.hints.md

@@ -9,21 +9,21 @@
 - **Why:** Deno wraps CommonJS exports in a `default` property, so default imports are required
 - Fixed in version 2.0.13 (changed from `import * as mongoPlugin`)
 
-## CongoDB - MongoDB Wire Protocol Server
+## TsmDB - MongoDB Wire Protocol Server
 
 ### Architecture
-CongoDB implements the MongoDB binary wire protocol (OP_MSG, OP_QUERY) allowing official MongoDB drivers to connect directly.
+TsmDB implements the MongoDB binary wire protocol (OP_MSG, OP_QUERY) allowing official MongoDB drivers to connect directly.
 
 ```
-Official MongoClient  →  TCP (wire protocol)  →  CongoServer  →  Engines  →  Storage
+Official MongoClient  →  TCP (wire protocol)  →  TsmdbServer  →  Engines  →  Storage
      (mongodb npm)           OP_MSG/BSON            (port)
 ```
 
 ### Module Structure
 ```
-ts/congodb/
+ts/tsmdb/
 ├── server/                   # Wire protocol server
-│   ├── CongoServer.ts        # TCP server, connection handling
+│   ├── TsmdbServer.ts        # TCP server, connection handling
 │   ├── WireProtocol.ts       # OP_MSG/OP_QUERY parsing & encoding
 │   ├── CommandRouter.ts      # Route commands to handlers
 │   └── handlers/             # Command implementations
@@ -53,11 +53,11 @@ ts/congodb/
 
 ### Usage Example
 ```typescript
-import { CongoServer } from '@push.rocks/smartmongo/congodb';
+import { TsmdbServer } from '@push.rocks/smartmongo/tsmdb';
 import { MongoClient } from 'mongodb';
 
 // Start server
-const server = new CongoServer({ port: 27117 });
+const server = new TsmdbServer({ port: 27117 });
 await server.start();
 
 // Connect with official MongoDB driver
@@ -82,8 +82,3 @@ await server.stop();
 - **Aggregation**: aggregate, count, distinct
 - **Indexes**: createIndexes, dropIndexes, listIndexes
 - **Admin**: ping, listDatabases, listCollections, drop, dropDatabase, create, serverStatus, buildInfo
-
-### Notes
-- The old CongoClient/CongoDb/CongoCollection classes have been removed
-- Use the official `mongodb` npm package's MongoClient instead
-- Server supports MongoDB wire protocol versions 0-21 (MongoDB 3.6 through 7.0 compatible)