@push.rocks/smartmongo 2.0.12 → 2.1.0

package/dist_ts/congodb/engine/QueryEngine.js

@@ -0,0 +1,271 @@
+import * as plugins from '../congodb.plugins.js';
+// Import mingo Query class
+import { Query } from 'mingo';
+/**
+ * Query engine using mingo for MongoDB-compatible query matching
+ */
+export class QueryEngine {
+    /**
+     * Filter documents by a MongoDB query filter
+     */
+    static filter(documents, filter) {
+        if (!filter || Object.keys(filter).length === 0) {
+            return documents;
+        }
+        const query = new Query(filter);
+        return documents.filter(doc => query.test(doc));
+    }
+    /**
+     * Test if a single document matches a filter
+     */
+    static matches(document, filter) {
+        if (!filter || Object.keys(filter).length === 0) {
+            return true;
+        }
+        const query = new Query(filter);
+        return query.test(document);
+    }
+    /**
+     * Find a single document matching the filter
+     */
+    static findOne(documents, filter) {
+        if (!filter || Object.keys(filter).length === 0) {
+            return documents[0] || null;
+        }
+        const query = new Query(filter);
+        for (const doc of documents) {
+            if (query.test(doc)) {
+                return doc;
+            }
+        }
+        return null;
+    }
+    /**
+     * Sort documents by a sort specification
+     */
+    static sort(documents, sort) {
+        if (!sort) {
+            return documents;
+        }
+        // Normalize sort specification to array of [field, direction] pairs
+        const sortFields = [];
+        if (Array.isArray(sort)) {
+            for (const [field, direction] of sort) {
+                sortFields.push([field, this.normalizeDirection(direction)]);
+            }
+        }
+        else {
+            for (const [field, direction] of Object.entries(sort)) {
+                sortFields.push([field, this.normalizeDirection(direction)]);
+            }
+        }
+        return [...documents].sort((a, b) => {
+            for (const [field, direction] of sortFields) {
+                const aVal = this.getNestedValue(a, field);
+                const bVal = this.getNestedValue(b, field);
+                const comparison = this.compareValues(aVal, bVal);
+                if (comparison !== 0) {
+                    return comparison * direction;
+                }
+            }
+            return 0;
+        });
+    }
+    /**
+     * Apply projection to documents
+     */
+    static project(documents, projection) {
+        if (!projection || Object.keys(projection).length === 0) {
+            return documents;
+        }
+        // Determine if this is inclusion or exclusion projection
+        const keys = Object.keys(projection);
+        const hasInclusion = keys.some(k => k !== '_id' && projection[k] === 1);
+        const hasExclusion = keys.some(k => k !== '_id' && projection[k] === 0);
+        // Can't mix inclusion and exclusion (except for _id)
+        if (hasInclusion && hasExclusion) {
+            throw new Error('Cannot mix inclusion and exclusion in projection');
+        }
+        return documents.map(doc => {
+            if (hasInclusion) {
+                // Inclusion projection
+                const result = {};
+                // Handle _id
+                if (projection._id !== 0 && projection._id !== false) {
+                    result._id = doc._id;
+                }
+                for (const key of keys) {
+                    if (key === '_id')
+                        continue;
+                    if (projection[key] === 1 || projection[key] === true) {
+                        const value = this.getNestedValue(doc, key);
+                        if (value !== undefined) {
+                            this.setNestedValue(result, key, value);
+                        }
+                    }
+                }
+                return result;
+            }
+            else {
+                // Exclusion projection - start with copy and remove fields
+                const result = { ...doc };
+                for (const key of keys) {
+                    if (projection[key] === 0 || projection[key] === false) {
+                        this.deleteNestedValue(result, key);
+                    }
+                }
+                return result;
+            }
+        });
+    }
+    /**
+     * Get distinct values for a field
+     */
+    static distinct(documents, field, filter) {
+        let docs = documents;
+        if (filter && Object.keys(filter).length > 0) {
+            docs = this.filter(documents, filter);
+        }
+        const values = new Set();
+        for (const doc of docs) {
+            const value = this.getNestedValue(doc, field);
+            if (value !== undefined) {
+                if (Array.isArray(value)) {
+                    // For arrays, add each element
+                    for (const v of value) {
+                        values.add(this.toComparable(v));
+                    }
+                }
+                else {
+                    values.add(this.toComparable(value));
+                }
+            }
+        }
+        return Array.from(values);
+    }
+    /**
+     * Normalize sort direction to 1 or -1
+     */
+    static normalizeDirection(direction) {
+        if (typeof direction === 'number') {
+            return direction > 0 ? 1 : -1;
+        }
+        if (direction === 'asc' || direction === 'ascending') {
+            return 1;
+        }
+        return -1;
+    }
+    /**
+     * Get a nested value from an object using dot notation
+     */
+    static getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            if (Array.isArray(current)) {
+                // Handle array access
+                const index = parseInt(part, 10);
+                if (!isNaN(index)) {
+                    current = current[index];
+                }
+                else {
+                    // Get the field from all array elements
+                    return current.map(item => this.getNestedValue(item, part)).flat();
+                }
+            }
+            else {
+                current = current[part];
+            }
+        }
+        return current;
+    }
+    /**
+     * Set a nested value in an object using dot notation
+     */
+    static setNestedValue(obj, path, value) {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!(part in current)) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        current[parts[parts.length - 1]] = value;
+    }
+    /**
+     * Delete a nested value from an object using dot notation
+     */
+    static deleteNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (let i = 0; i < parts.length - 1; i++) {
+            const part = parts[i];
+            if (!(part in current)) {
+                return;
+            }
+            current = current[part];
+        }
+        delete current[parts[parts.length - 1]];
+    }
+    /**
+     * Compare two values for sorting
+     */
+    static compareValues(a, b) {
+        // Handle undefined/null
+        if (a === undefined && b === undefined)
+            return 0;
+        if (a === undefined)
+            return -1;
+        if (b === undefined)
+            return 1;
+        if (a === null && b === null)
+            return 0;
+        if (a === null)
+            return -1;
+        if (b === null)
+            return 1;
+        // Handle ObjectId
+        if (a instanceof plugins.bson.ObjectId && b instanceof plugins.bson.ObjectId) {
+            return a.toHexString().localeCompare(b.toHexString());
+        }
+        // Handle dates
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() - b.getTime();
+        }
+        // Handle numbers
+        if (typeof a === 'number' && typeof b === 'number') {
+            return a - b;
+        }
+        // Handle strings
+        if (typeof a === 'string' && typeof b === 'string') {
+            return a.localeCompare(b);
+        }
+        // Handle booleans
+        if (typeof a === 'boolean' && typeof b === 'boolean') {
+            return (a ? 1 : 0) - (b ? 1 : 0);
+        }
+        // Fall back to string comparison
+        return String(a).localeCompare(String(b));
+    }
+    /**
+     * Convert a value to a comparable form (for distinct)
+     */
+    static toComparable(value) {
+        if (value instanceof plugins.bson.ObjectId) {
+            return value.toHexString();
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (typeof value === 'object' && value !== null) {
+            return JSON.stringify(value);
+        }
+        return value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QueryEngine.js","sourceRoot":"","sources":["../../../ts/congodb/engine/QueryEngine.ts"],"names":[],"mappings":"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"}

package/dist_ts/congodb/engine/TransactionEngine.d.ts

@@ -0,0 +1,85 @@
+import * as plugins from '../congodb.plugins.js';
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+import type { IStoredDocument, ITransactionOptions } from '../types/interfaces.js';
+/**
+ * Transaction state
+ */
+export interface ITransactionState {
+    id: string;
+    sessionId: string;
+    startTime: plugins.bson.Timestamp;
+    status: 'active' | 'committed' | 'aborted';
+    readSet: Map<string, Set<string>>;
+    writeSet: Map<string, Map<string, {
+        op: 'insert' | 'update' | 'delete';
+        doc?: IStoredDocument;
+        originalDoc?: IStoredDocument;
+    }>>;
+    snapshots: Map<string, IStoredDocument[]>;
+}
+/**
+ * Transaction engine for ACID transaction support
+ */
+export declare class TransactionEngine {
+    private storage;
+    private transactions;
+    private txnCounter;
+    constructor(storage: IStorageAdapter);
+    /**
+     * Start a new transaction
+     */
+    startTransaction(sessionId: string, options?: ITransactionOptions): string;
+    /**
+     * Get a transaction by ID
+     */
+    getTransaction(txnId: string): ITransactionState | undefined;
+    /**
+     * Check if a transaction is active
+     */
+    isActive(txnId: string): boolean;
+    /**
+     * Get or create a snapshot for a namespace
+     */
+    getSnapshot(txnId: string, dbName: string, collName: string): Promise<IStoredDocument[]>;
+    /**
+     * Record a read operation
+     */
+    recordRead(txnId: string, dbName: string, collName: string, docIds: string[]): void;
+    /**
+     * Record a write operation (insert)
+     */
+    recordInsert(txnId: string, dbName: string, collName: string, doc: IStoredDocument): void;
+    /**
+     * Record a write operation (update)
+     */
+    recordUpdate(txnId: string, dbName: string, collName: string, originalDoc: IStoredDocument, updatedDoc: IStoredDocument): void;
+    /**
+     * Record a write operation (delete)
+     */
+    recordDelete(txnId: string, dbName: string, collName: string, doc: IStoredDocument): void;
+    /**
+     * Commit a transaction
+     */
+    commitTransaction(txnId: string): Promise<void>;
+    /**
+     * Abort a transaction
+     */
+    abortTransaction(txnId: string): Promise<void>;
+    /**
+     * End a transaction (cleanup)
+     */
+    endTransaction(txnId: string): void;
+    /**
+     * Get all pending writes for a namespace
+     */
+    getPendingWrites(txnId: string, dbName: string, collName: string): Map<string, {
+        op: 'insert' | 'update' | 'delete';
+        doc?: IStoredDocument;
+    }> | undefined;
+    /**
+     * Execute a callback within a transaction, with automatic retry on conflict
+     */
+    withTransaction<T>(sessionId: string, callback: (txnId: string) => Promise<T>, options?: ITransactionOptions & {
+        maxRetries?: number;
+    }): Promise<T>;
+}

package/dist_ts/congodb/engine/TransactionEngine.js

@@ -0,0 +1,287 @@
+import * as plugins from '../congodb.plugins.js';
+import { CongoTransactionError, CongoWriteConflictError } from '../errors/CongoErrors.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 CongoTransactionError('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 CongoTransactionError('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 CongoTransactionError('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 CongoTransactionError('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 CongoTransactionError('Transaction not found');
+        }
+        if (txn.status !== 'active') {
+            throw new CongoTransactionError(`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 CongoWriteConflictError();
+            }
+        }
+        // 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 CongoTransactionError('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 CongoWriteConflictError && attempt < maxRetries - 1) {
+                    // Retry on write conflict
+                    lastError = error;
+                    continue;
+                }
+                throw error;
+            }
+        }
+        throw lastError || new CongoTransactionError('Transaction failed after max retries');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"TransactionEngine.js","sourceRoot":"","sources":["../../../ts/congodb/engine/TransactionEngine.ts"],"names":[],"mappings":"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"}