@push.rocks/smartmongo 2.0.12 → 2.1.0

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

@@ -0,0 +1,47 @@
+import type { Document, IStoredDocument } from '../types/interfaces.js';
+/**
+ * Update engine for MongoDB-compatible update operations
+ */
+export declare class UpdateEngine {
+    /**
+     * Apply an update specification to a document
+     * Returns the updated document or null if no update was applied
+     */
+    static applyUpdate(document: IStoredDocument, update: Document, arrayFilters?: Document[]): IStoredDocument;
+    /**
+     * Apply $setOnInsert for upsert operations
+     */
+    static applySetOnInsert(document: IStoredDocument, setOnInsert: Document): IStoredDocument;
+    /**
+     * Deep clone a document
+     */
+    private static deepClone;
+    /**
+     * Set a nested value
+     */
+    private static setNestedValue;
+    /**
+     * Get a nested value
+     */
+    private static getNestedValue;
+    /**
+     * Delete a nested value
+     */
+    private static deleteNestedValue;
+    private static applySet;
+    private static applyUnset;
+    private static applyInc;
+    private static applyMul;
+    private static applyMin;
+    private static applyMax;
+    private static applyRename;
+    private static applyCurrentDate;
+    private static applyPush;
+    private static applyPop;
+    private static applyPull;
+    private static applyPullAll;
+    private static applyAddToSet;
+    private static applyBit;
+    private static compareValues;
+    private static valuesEqual;
+}

package/dist_ts/congodb/engine/UpdateEngine.js

@@ -0,0 +1,461 @@
+import * as plugins from '../congodb.plugins.js';
+import { QueryEngine } from './QueryEngine.js';
+/**
+ * Update engine for MongoDB-compatible update operations
+ */
+export class UpdateEngine {
+    /**
+     * Apply an update specification to a document
+     * Returns the updated document or null if no update was applied
+     */
+    static applyUpdate(document, update, arrayFilters) {
+        // Check if this is an aggregation pipeline update
+        if (Array.isArray(update)) {
+            // Aggregation pipeline updates are not yet supported
+            throw new Error('Aggregation pipeline updates are not yet supported');
+        }
+        // Check if this is a replacement (no $ operators at top level)
+        const hasOperators = Object.keys(update).some(k => k.startsWith('$'));
+        if (!hasOperators) {
+            // This is a replacement - preserve _id
+            return {
+                _id: document._id,
+                ...update,
+            };
+        }
+        // Apply update operators
+        const result = this.deepClone(document);
+        for (const [operator, operand] of Object.entries(update)) {
+            switch (operator) {
+                case '$set':
+                    this.applySet(result, operand);
+                    break;
+                case '$unset':
+                    this.applyUnset(result, operand);
+                    break;
+                case '$inc':
+                    this.applyInc(result, operand);
+                    break;
+                case '$mul':
+                    this.applyMul(result, operand);
+                    break;
+                case '$min':
+                    this.applyMin(result, operand);
+                    break;
+                case '$max':
+                    this.applyMax(result, operand);
+                    break;
+                case '$rename':
+                    this.applyRename(result, operand);
+                    break;
+                case '$currentDate':
+                    this.applyCurrentDate(result, operand);
+                    break;
+                case '$setOnInsert':
+                    // Only applied during upsert insert, handled elsewhere
+                    break;
+                case '$push':
+                    this.applyPush(result, operand, arrayFilters);
+                    break;
+                case '$pop':
+                    this.applyPop(result, operand);
+                    break;
+                case '$pull':
+                    this.applyPull(result, operand, arrayFilters);
+                    break;
+                case '$pullAll':
+                    this.applyPullAll(result, operand);
+                    break;
+                case '$addToSet':
+                    this.applyAddToSet(result, operand);
+                    break;
+                case '$bit':
+                    this.applyBit(result, operand);
+                    break;
+                default:
+                    throw new Error(`Unknown update operator: ${operator}`);
+            }
+        }
+        return result;
+    }
+    /**
+     * Apply $setOnInsert for upsert operations
+     */
+    static applySetOnInsert(document, setOnInsert) {
+        const result = this.deepClone(document);
+        this.applySet(result, setOnInsert);
+        return result;
+    }
+    /**
+     * Deep clone a document
+     */
+    static deepClone(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        if (obj instanceof plugins.bson.ObjectId) {
+            return new plugins.bson.ObjectId(obj.toHexString());
+        }
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        if (obj instanceof plugins.bson.Timestamp) {
+            return new plugins.bson.Timestamp({ t: obj.high, i: obj.low });
+        }
+        if (Array.isArray(obj)) {
+            return obj.map(item => this.deepClone(item));
+        }
+        const cloned = {};
+        for (const key of Object.keys(obj)) {
+            cloned[key] = this.deepClone(obj[key]);
+        }
+        return cloned;
+    }
+    /**
+     * Set a nested value
+     */
+    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];
+            // Handle array index notation
+            const arrayMatch = part.match(/^(\w+)\[(\d+)\]$/);
+            if (arrayMatch) {
+                const [, fieldName, indexStr] = arrayMatch;
+                const index = parseInt(indexStr, 10);
+                if (!(fieldName in current)) {
+                    current[fieldName] = [];
+                }
+                if (!current[fieldName][index]) {
+                    current[fieldName][index] = {};
+                }
+                current = current[fieldName][index];
+                continue;
+            }
+            // Handle numeric index (array positional)
+            const numIndex = parseInt(part, 10);
+            if (!isNaN(numIndex) && Array.isArray(current)) {
+                if (!current[numIndex]) {
+                    current[numIndex] = {};
+                }
+                current = current[numIndex];
+                continue;
+            }
+            if (!(part in current) || current[part] === null) {
+                current[part] = {};
+            }
+            current = current[part];
+        }
+        const lastPart = parts[parts.length - 1];
+        const numIndex = parseInt(lastPart, 10);
+        if (!isNaN(numIndex) && Array.isArray(current)) {
+            current[numIndex] = value;
+        }
+        else {
+            current[lastPart] = value;
+        }
+    }
+    /**
+     * Get a nested value
+     */
+    static getNestedValue(obj, path) {
+        return QueryEngine.getNestedValue(obj, path);
+    }
+    /**
+     * Delete a nested value
+     */
+    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]];
+    }
+    // ============================================================================
+    // Field Update Operators
+    // ============================================================================
+    static applySet(doc, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            this.setNestedValue(doc, path, this.deepClone(value));
+        }
+    }
+    static applyUnset(doc, fields) {
+        for (const path of Object.keys(fields)) {
+            this.deleteNestedValue(doc, path);
+        }
+    }
+    static applyInc(doc, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            const current = this.getNestedValue(doc, path) || 0;
+            if (typeof current !== 'number') {
+                throw new Error(`Cannot apply $inc to non-numeric field: ${path}`);
+            }
+            this.setNestedValue(doc, path, current + value);
+        }
+    }
+    static applyMul(doc, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            const current = this.getNestedValue(doc, path) || 0;
+            if (typeof current !== 'number') {
+                throw new Error(`Cannot apply $mul to non-numeric field: ${path}`);
+            }
+            this.setNestedValue(doc, path, current * value);
+        }
+    }
+    static applyMin(doc, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            const current = this.getNestedValue(doc, path);
+            if (current === undefined || this.compareValues(value, current) < 0) {
+                this.setNestedValue(doc, path, this.deepClone(value));
+            }
+        }
+    }
+    static applyMax(doc, fields) {
+        for (const [path, value] of Object.entries(fields)) {
+            const current = this.getNestedValue(doc, path);
+            if (current === undefined || this.compareValues(value, current) > 0) {
+                this.setNestedValue(doc, path, this.deepClone(value));
+            }
+        }
+    }
+    static applyRename(doc, fields) {
+        for (const [oldPath, newPath] of Object.entries(fields)) {
+            const value = this.getNestedValue(doc, oldPath);
+            if (value !== undefined) {
+                this.deleteNestedValue(doc, oldPath);
+                this.setNestedValue(doc, newPath, value);
+            }
+        }
+    }
+    static applyCurrentDate(doc, fields) {
+        for (const [path, spec] of Object.entries(fields)) {
+            if (spec === true) {
+                this.setNestedValue(doc, path, new Date());
+            }
+            else if (typeof spec === 'object' && spec.$type === 'date') {
+                this.setNestedValue(doc, path, new Date());
+            }
+            else if (typeof spec === 'object' && spec.$type === 'timestamp') {
+                this.setNestedValue(doc, path, new plugins.bson.Timestamp({ t: Math.floor(Date.now() / 1000), i: 0 }));
+            }
+        }
+    }
+    // ============================================================================
+    // Array Update Operators
+    // ============================================================================
+    static applyPush(doc, fields, arrayFilters) {
+        for (const [path, spec] of Object.entries(fields)) {
+            let arr = this.getNestedValue(doc, path);
+            if (arr === undefined) {
+                arr = [];
+                this.setNestedValue(doc, path, arr);
+            }
+            if (!Array.isArray(arr)) {
+                throw new Error(`Cannot apply $push to non-array field: ${path}`);
+            }
+            if (spec && typeof spec === 'object' && '$each' in spec) {
+                // $push with modifiers
+                let elements = spec.$each.map(e => this.deepClone(e));
+                const position = spec.$position;
+                const slice = spec.$slice;
+                const sortSpec = spec.$sort;
+                if (position !== undefined) {
+                    arr.splice(position, 0, ...elements);
+                }
+                else {
+                    arr.push(...elements);
+                }
+                if (sortSpec !== undefined) {
+                    if (typeof sortSpec === 'number') {
+                        arr.sort((a, b) => (a - b) * sortSpec);
+                    }
+                    else {
+                        // Sort by field(s)
+                        const entries = Object.entries(sortSpec);
+                        arr.sort((a, b) => {
+                            for (const [field, dir] of entries) {
+                                const av = this.getNestedValue(a, field);
+                                const bv = this.getNestedValue(b, field);
+                                const cmp = this.compareValues(av, bv) * dir;
+                                if (cmp !== 0)
+                                    return cmp;
+                            }
+                            return 0;
+                        });
+                    }
+                }
+                if (slice !== undefined) {
+                    if (slice >= 0) {
+                        arr.splice(slice);
+                    }
+                    else {
+                        arr.splice(0, arr.length + slice);
+                    }
+                }
+            }
+            else {
+                // Simple push
+                arr.push(this.deepClone(spec));
+            }
+        }
+    }
+    static applyPop(doc, fields) {
+        for (const [path, direction] of Object.entries(fields)) {
+            const arr = this.getNestedValue(doc, path);
+            if (!Array.isArray(arr)) {
+                throw new Error(`Cannot apply $pop to non-array field: ${path}`);
+            }
+            if (direction === 1) {
+                arr.pop();
+            }
+            else {
+                arr.shift();
+            }
+        }
+    }
+    static applyPull(doc, fields, arrayFilters) {
+        for (const [path, condition] of Object.entries(fields)) {
+            const arr = this.getNestedValue(doc, path);
+            if (!Array.isArray(arr)) {
+                continue; // Skip if not an array
+            }
+            if (typeof condition === 'object' && condition !== null && !Array.isArray(condition)) {
+                // Condition is a query filter
+                const hasOperators = Object.keys(condition).some(k => k.startsWith('$'));
+                if (hasOperators) {
+                    // Filter using query operators
+                    const remaining = arr.filter(item => !QueryEngine.matches(item, condition));
+                    arr.length = 0;
+                    arr.push(...remaining);
+                }
+                else {
+                    // Match documents with all specified fields
+                    const remaining = arr.filter(item => {
+                        if (typeof item !== 'object' || item === null) {
+                            return true;
+                        }
+                        return !Object.entries(condition).every(([k, v]) => {
+                            const itemVal = this.getNestedValue(item, k);
+                            return this.valuesEqual(itemVal, v);
+                        });
+                    });
+                    arr.length = 0;
+                    arr.push(...remaining);
+                }
+            }
+            else {
+                // Direct value match
+                const remaining = arr.filter(item => !this.valuesEqual(item, condition));
+                arr.length = 0;
+                arr.push(...remaining);
+            }
+        }
+    }
+    static applyPullAll(doc, fields) {
+        for (const [path, values] of Object.entries(fields)) {
+            const arr = this.getNestedValue(doc, path);
+            if (!Array.isArray(arr)) {
+                continue;
+            }
+            if (!Array.isArray(values)) {
+                throw new Error(`$pullAll requires an array argument`);
+            }
+            const valueSet = new Set(values.map(v => JSON.stringify(v)));
+            const remaining = arr.filter(item => !valueSet.has(JSON.stringify(item)));
+            arr.length = 0;
+            arr.push(...remaining);
+        }
+    }
+    static applyAddToSet(doc, fields) {
+        for (const [path, spec] of Object.entries(fields)) {
+            let arr = this.getNestedValue(doc, path);
+            if (arr === undefined) {
+                arr = [];
+                this.setNestedValue(doc, path, arr);
+            }
+            if (!Array.isArray(arr)) {
+                throw new Error(`Cannot apply $addToSet to non-array field: ${path}`);
+            }
+            const existingSet = new Set(arr.map(v => JSON.stringify(v)));
+            if (spec && typeof spec === 'object' && '$each' in spec) {
+                for (const item of spec.$each) {
+                    const key = JSON.stringify(item);
+                    if (!existingSet.has(key)) {
+                        arr.push(this.deepClone(item));
+                        existingSet.add(key);
+                    }
+                }
+            }
+            else {
+                const key = JSON.stringify(spec);
+                if (!existingSet.has(key)) {
+                    arr.push(this.deepClone(spec));
+                }
+            }
+        }
+    }
+    static applyBit(doc, fields) {
+        for (const [path, operations] of Object.entries(fields)) {
+            let current = this.getNestedValue(doc, path) || 0;
+            if (typeof current !== 'number') {
+                throw new Error(`Cannot apply $bit to non-numeric field: ${path}`);
+            }
+            for (const [op, value] of Object.entries(operations)) {
+                switch (op) {
+                    case 'and':
+                        current = current & value;
+                        break;
+                    case 'or':
+                        current = current | value;
+                        break;
+                    case 'xor':
+                        current = current ^ value;
+                        break;
+                }
+            }
+            this.setNestedValue(doc, path, current);
+        }
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    static compareValues(a, b) {
+        if (a === b)
+            return 0;
+        if (a === null || a === undefined)
+            return -1;
+        if (b === null || b === undefined)
+            return 1;
+        if (typeof a === 'number' && typeof b === 'number') {
+            return a - b;
+        }
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() - b.getTime();
+        }
+        if (typeof a === 'string' && typeof b === 'string') {
+            return a.localeCompare(b);
+        }
+        return String(a).localeCompare(String(b));
+    }
+    static valuesEqual(a, b) {
+        if (a === b)
+            return true;
+        if (a instanceof plugins.bson.ObjectId && b instanceof plugins.bson.ObjectId) {
+            return a.equals(b);
+        }
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        if (typeof a === 'object' && typeof b === 'object' && a !== null && b !== null) {
+            return JSON.stringify(a) === JSON.stringify(b);
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"UpdateEngine.js","sourceRoot":"","sources":["../../../ts/congodb/engine/UpdateEngine.ts"],"names":[],"mappings":"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"}

package/dist_ts/congodb/errors/CongoErrors.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Base error class for all CongoDB errors
+ * Mirrors MongoDB driver error hierarchy
+ */
+export declare class CongoError extends Error {
+    code?: number;
+    codeName?: string;
+    constructor(message: string, code?: number, codeName?: string);
+}
+/**
+ * Error thrown during connection issues
+ */
+export declare class CongoConnectionError extends CongoError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an operation times out
+ */
+export declare class CongoTimeoutError extends CongoError {
+    constructor(message: string);
+}
+/**
+ * Error thrown during write operations
+ */
+export declare class CongoWriteError extends CongoError {
+    writeErrors?: IWriteError[];
+    result?: any;
+    constructor(message: string, code?: number, writeErrors?: IWriteError[]);
+}
+/**
+ * Error thrown for duplicate key violations
+ */
+export declare class CongoDuplicateKeyError extends CongoWriteError {
+    keyPattern?: Record<string, 1>;
+    keyValue?: Record<string, any>;
+    constructor(message: string, keyPattern?: Record<string, 1>, keyValue?: Record<string, any>);
+}
+/**
+ * Error thrown for bulk write failures
+ */
+export declare class CongoBulkWriteError extends CongoError {
+    writeErrors: IWriteError[];
+    result: any;
+    constructor(message: string, writeErrors: IWriteError[], result: any);
+}
+/**
+ * Error thrown during transaction operations
+ */
+export declare class CongoTransactionError extends CongoError {
+    constructor(message: string, code?: number);
+}
+/**
+ * Error thrown when a transaction is aborted due to conflict
+ */
+export declare class CongoWriteConflictError extends CongoTransactionError {
+    constructor(message?: string);
+}
+/**
+ * Error thrown for invalid arguments
+ */
+export declare class CongoArgumentError extends CongoError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an operation is not supported
+ */
+export declare class CongoNotSupportedError extends CongoError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when cursor is exhausted or closed
+ */
+export declare class CongoCursorError extends CongoError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when a namespace (database.collection) is invalid
+ */
+export declare class CongoNamespaceError extends CongoError {
+    constructor(message: string);
+}
+/**
+ * Error thrown when an index operation fails
+ */
+export declare class CongoIndexError extends CongoError {
+    constructor(message: string, code?: number);
+}
+/**
+ * Write error detail for bulk operations
+ */
+export interface IWriteError {
+    index: number;
+    code: number;
+    errmsg: string;
+    op: any;
+}
+/**
+ * Convert any error to a CongoError
+ */
+export declare function toCongoError(error: any): CongoError;