@push.rocks/smartmongo 2.0.14 → 2.2.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartmongo',
-    version: '2.0.14',
+    version: '2.2.0',
     description: 'A module for creating and managing a local MongoDB instance for testing purposes.'
 };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLG1GQUFtRjtDQUNqRyxDQUFBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLG1GQUFtRjtDQUNqRyxDQUFBIn0=

package/dist_ts/congodb/congodb.plugins.d.ts

@@ -0,0 +1,10 @@
+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 };
+import * as bson from 'bson';
+import * as mingo from 'mingo';
+export { bson, mingo };
+export { Query } from 'mingo';
+export { Aggregator } from 'mingo';

package/dist_ts/congodb/congodb.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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uZ29kYi5wbHVnaW5zLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vdHMvY29uZ29kYi9jb25nb2RiLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsb0JBQW9CO0FBQ3BCLE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFDL0MsT0FBTyxLQUFLLFNBQVMsTUFBTSx1QkFBdUIsQ0FBQztBQUNuRCxPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxPQUFPLE1BQU0scUJBQXFCLENBQUM7QUFFL0MsT0FBTyxFQUFFLE9BQU8sRUFBRSxTQUFTLEVBQUUsWUFBWSxFQUFFLE9BQU8sRUFBRSxDQUFDO0FBRXJELGFBQWE7QUFDYixPQUFPLEtBQUssSUFBSSxNQUFNLE1BQU0sQ0FBQztBQUM3QixPQUFPLEtBQUssS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUUvQixPQUFPLEVBQUUsSUFBSSxFQUFFLEtBQUssRUFBRSxDQUFDO0FBRXZCLHdDQUF3QztBQUN4QyxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sT0FBTyxDQUFDO0FBQzlCLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxPQUFPLENBQUMifQ==

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

@@ -0,0 +1,66 @@
+import type { Document, IStoredDocument, IAggregateOptions } from '../types/interfaces.js';
+/**
+ * Aggregation engine using mingo for MongoDB-compatible aggregation pipeline execution
+ */
+export declare class AggregationEngine {
+    /**
+     * Execute an aggregation pipeline on a collection of documents
+     */
+    static aggregate(documents: IStoredDocument[], pipeline: Document[], options?: IAggregateOptions): Document[];
+    /**
+     * Execute aggregation and return an iterator for lazy evaluation
+     */
+    static aggregateIterator(documents: IStoredDocument[], pipeline: Document[], options?: IAggregateOptions): Generator<Document>;
+    /**
+     * Execute a $lookup stage manually (for cross-collection lookups)
+     * This is used when the lookup references another collection in the same database
+     */
+    static executeLookup(documents: IStoredDocument[], lookupSpec: {
+        from: string;
+        localField: string;
+        foreignField: string;
+        as: string;
+    }, foreignCollection: IStoredDocument[]): Document[];
+    /**
+     * Execute a $graphLookup stage manually
+     */
+    static executeGraphLookup(documents: IStoredDocument[], graphLookupSpec: {
+        from: string;
+        startWith: string | Document;
+        connectFromField: string;
+        connectToField: string;
+        as: string;
+        maxDepth?: number;
+        depthField?: string;
+        restrictSearchWithMatch?: Document;
+    }, foreignCollection: IStoredDocument[]): Document[];
+    /**
+     * Execute a $facet stage manually
+     */
+    static executeFacet(documents: IStoredDocument[], facetSpec: Record<string, Document[]>): Document;
+    /**
+     * Execute a $unionWith stage
+     */
+    static executeUnionWith(documents: IStoredDocument[], otherDocuments: IStoredDocument[], pipeline?: Document[]): Document[];
+    /**
+     * Execute a $merge stage (output to another collection)
+     * Returns the documents that would be inserted/updated
+     */
+    static prepareMerge(documents: Document[], mergeSpec: {
+        into: string;
+        on?: string | string[];
+        whenMatched?: 'replace' | 'keepExisting' | 'merge' | 'fail' | Document[];
+        whenNotMatched?: 'insert' | 'discard' | 'fail';
+    }): {
+        toInsert: Document[];
+        toUpdate: Array<{
+            filter: Document;
+            update: Document;
+        }>;
+        onField: string | string[];
+        whenMatched: string | Document[];
+        whenNotMatched: string;
+    };
+    private static getNestedValue;
+    private static valuesMatch;
+}

package/dist_ts/congodb/engine/AggregationEngine.js

@@ -0,0 +1,189 @@
+import * as plugins from '../congodb.plugins.js';
+// Import mingo Aggregator
+import { Aggregator } from 'mingo';
+/**
+ * Aggregation engine using mingo for MongoDB-compatible aggregation pipeline execution
+ */
+export class AggregationEngine {
+    /**
+     * Execute an aggregation pipeline on a collection of documents
+     */
+    static aggregate(documents, pipeline, options) {
+        if (!pipeline || pipeline.length === 0) {
+            return documents;
+        }
+        // Create mingo aggregator with the pipeline
+        const aggregator = new Aggregator(pipeline, {
+            collation: options?.collation,
+        });
+        // Run the aggregation
+        const result = aggregator.run(documents);
+        return Array.isArray(result) ? result : [];
+    }
+    /**
+     * Execute aggregation and return an iterator for lazy evaluation
+     */
+    static *aggregateIterator(documents, pipeline, options) {
+        const aggregator = new Aggregator(pipeline, {
+            collation: options?.collation,
+        });
+        // Get the cursor from mingo
+        const cursor = aggregator.stream(documents);
+        for (const doc of cursor) {
+            yield doc;
+        }
+    }
+    /**
+     * Execute a $lookup stage manually (for cross-collection lookups)
+     * This is used when the lookup references another collection in the same database
+     */
+    static executeLookup(documents, lookupSpec, foreignCollection) {
+        const { localField, foreignField, as } = lookupSpec;
+        return documents.map(doc => {
+            const localValue = this.getNestedValue(doc, localField);
+            const matches = foreignCollection.filter(foreignDoc => {
+                const foreignValue = this.getNestedValue(foreignDoc, foreignField);
+                return this.valuesMatch(localValue, foreignValue);
+            });
+            return {
+                ...doc,
+                [as]: matches,
+            };
+        });
+    }
+    /**
+     * Execute a $graphLookup stage manually
+     */
+    static executeGraphLookup(documents, graphLookupSpec, foreignCollection) {
+        const { startWith, connectFromField, connectToField, as, maxDepth = 10, depthField, restrictSearchWithMatch, } = graphLookupSpec;
+        return documents.map(doc => {
+            const startValue = typeof startWith === 'string' && startWith.startsWith('$')
+                ? this.getNestedValue(doc, startWith.slice(1))
+                : startWith;
+            const results = [];
+            const visited = new Set();
+            const queue = [];
+            // Initialize with start value(s)
+            const startValues = Array.isArray(startValue) ? startValue : [startValue];
+            for (const val of startValues) {
+                queue.push({ value: val, depth: 0 });
+            }
+            while (queue.length > 0) {
+                const { value, depth } = queue.shift();
+                if (depth > maxDepth)
+                    continue;
+                const valueKey = JSON.stringify(value);
+                if (visited.has(valueKey))
+                    continue;
+                visited.add(valueKey);
+                // Find matching documents
+                for (const foreignDoc of foreignCollection) {
+                    const foreignValue = this.getNestedValue(foreignDoc, connectToField);
+                    if (this.valuesMatch(value, foreignValue)) {
+                        // Check restrictSearchWithMatch
+                        if (restrictSearchWithMatch) {
+                            const matchQuery = new plugins.mingo.Query(restrictSearchWithMatch);
+                            if (!matchQuery.test(foreignDoc))
+                                continue;
+                        }
+                        const resultDoc = depthField
+                            ? { ...foreignDoc, [depthField]: depth }
+                            : { ...foreignDoc };
+                        // Avoid duplicates in results
+                        const docKey = foreignDoc._id.toHexString();
+                        if (!results.some(r => r._id?.toHexString?.() === docKey)) {
+                            results.push(resultDoc);
+                            // Add connected values to queue
+                            const nextValue = this.getNestedValue(foreignDoc, connectFromField);
+                            if (nextValue !== undefined) {
+                                const nextValues = Array.isArray(nextValue) ? nextValue : [nextValue];
+                                for (const nv of nextValues) {
+                                    queue.push({ value: nv, depth: depth + 1 });
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return {
+                ...doc,
+                [as]: results,
+            };
+        });
+    }
+    /**
+     * Execute a $facet stage manually
+     */
+    static executeFacet(documents, facetSpec) {
+        const result = {};
+        for (const [facetName, pipeline] of Object.entries(facetSpec)) {
+            result[facetName] = this.aggregate(documents, pipeline);
+        }
+        return result;
+    }
+    /**
+     * Execute a $unionWith stage
+     */
+    static executeUnionWith(documents, otherDocuments, pipeline) {
+        let unionDocs = otherDocuments;
+        if (pipeline && pipeline.length > 0) {
+            unionDocs = this.aggregate(otherDocuments, pipeline);
+        }
+        return [...documents, ...unionDocs];
+    }
+    /**
+     * Execute a $merge stage (output to another collection)
+     * Returns the documents that would be inserted/updated
+     */
+    static prepareMerge(documents, mergeSpec) {
+        const onField = mergeSpec.on || '_id';
+        const whenMatched = mergeSpec.whenMatched || 'merge';
+        const whenNotMatched = mergeSpec.whenNotMatched || 'insert';
+        return {
+            toInsert: [],
+            toUpdate: [],
+            onField,
+            whenMatched,
+            whenNotMatched,
+        };
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    static getNestedValue(obj, path) {
+        const parts = path.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === null || current === undefined) {
+                return undefined;
+            }
+            current = current[part];
+        }
+        return current;
+    }
+    static valuesMatch(a, b) {
+        if (a === b)
+            return true;
+        // Handle ObjectId comparison
+        if (a instanceof plugins.bson.ObjectId && b instanceof plugins.bson.ObjectId) {
+            return a.equals(b);
+        }
+        // Handle array contains check
+        if (Array.isArray(a)) {
+            return a.some(item => this.valuesMatch(item, b));
+        }
+        if (Array.isArray(b)) {
+            return b.some(item => this.valuesMatch(a, item));
+        }
+        // Handle Date comparison
+        if (a instanceof Date && b instanceof Date) {
+            return a.getTime() === b.getTime();
+        }
+        // Handle object comparison
+        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":"AggregationEngine.js","sourceRoot":"","sources":["../../../ts/congodb/engine/AggregationEngine.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,77 @@
+import type { IStorageAdapter } from '../storage/IStorageAdapter.js';
+import type { Document, IStoredDocument, IIndexInfo, ICreateIndexOptions } from '../types/interfaces.js';
+/**
+ * Index data structure for fast lookups
+ */
+interface IIndexData {
+    name: string;
+    key: Record<string, 1 | -1 | string>;
+    unique: boolean;
+    sparse: boolean;
+    expireAfterSeconds?: number;
+    entries: Map<string, Set<string>>;
+}
+/**
+ * Index engine for managing indexes and query optimization
+ */
+export declare class IndexEngine {
+    private dbName;
+    private collName;
+    private storage;
+    private indexes;
+    private initialized;
+    constructor(dbName: string, collName: string, storage: IStorageAdapter);
+    /**
+     * Initialize indexes from storage
+     */
+    initialize(): Promise<void>;
+    /**
+     * Create a new index
+     */
+    createIndex(key: Record<string, 1 | -1 | 'text' | '2dsphere'>, options?: ICreateIndexOptions): Promise<string>;
+    /**
+     * Drop an index
+     */
+    dropIndex(name: string): Promise<void>;
+    /**
+     * Drop all indexes except _id
+     */
+    dropAllIndexes(): Promise<void>;
+    /**
+     * List all indexes
+     */
+    listIndexes(): Promise<IIndexInfo[]>;
+    /**
+     * Check if an index exists
+     */
+    indexExists(name: string): Promise<boolean>;
+    /**
+     * Update index entries after document insert
+     */
+    onInsert(doc: IStoredDocument): Promise<void>;
+    /**
+     * Update index entries after document update
+     */
+    onUpdate(oldDoc: IStoredDocument, newDoc: IStoredDocument): Promise<void>;
+    /**
+     * Update index entries after document delete
+     */
+    onDelete(doc: IStoredDocument): Promise<void>;
+    /**
+     * Find the best index for a query
+     */
+    selectIndex(filter: Document): {
+        name: string;
+        data: IIndexData;
+    } | null;
+    /**
+     * Use index to find candidate document IDs
+     */
+    findCandidateIds(filter: Document): Promise<Set<string> | null>;
+    private generateIndexName;
+    private extractKeyValue;
+    private buildKeyValue;
+    private getFilterFields;
+    private getFilterValue;
+}
+export {};