@push.rocks/smartmongo 2.2.0 → 4.0.0

package/dist_ts/tsmdb/engine/QueryEngine.js

@@ -0,0 +1,271 @@
+import * as plugins from '../tsmdb.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/tsmdb/engine/QueryEngine.ts"],"names":[],"mappings":"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"}

package/dist_ts/tsmdb/engine/QueryPlanner.d.ts

@@ -0,0 +1,64 @@
+import type { Document } from '../types/interfaces.js';
+import { IndexEngine } from './IndexEngine.js';
+/**
+ * Query execution plan types
+ */
+export type TQueryPlanType = 'IXSCAN' | 'COLLSCAN' | 'FETCH' | 'IXSCAN_RANGE';
+/**
+ * Represents a query execution plan
+ */
+export interface IQueryPlan {
+    /** The type of scan used */
+    type: TQueryPlanType;
+    /** Index name if using an index */
+    indexName?: string;
+    /** Index key specification */
+    indexKey?: Record<string, 1 | -1 | string>;
+    /** Whether the query can be fully satisfied by the index */
+    indexCovering: boolean;
+    /** Estimated selectivity (0-1, lower is more selective) */
+    selectivity: number;
+    /** Whether range operators are used */
+    usesRange: boolean;
+    /** Fields used from the index */
+    indexFieldsUsed: string[];
+    /** Filter conditions that must be applied post-index lookup */
+    residualFilter?: Document;
+    /** Explanation for debugging */
+    explanation: string;
+}
+/**
+ * QueryPlanner - Analyzes queries and selects optimal execution plans
+ */
+export declare class QueryPlanner {
+    private indexEngine;
+    constructor(indexEngine: IndexEngine);
+    /**
+     * Generate an execution plan for a query filter
+     */
+    plan(filter: Document): Promise<IQueryPlan>;
+    /**
+     * Analyze filter to extract operator information per field
+     */
+    private analyzeFilter;
+    /**
+     * Score an index for the given filter
+     */
+    private scoreIndex;
+    /**
+     * Calculate overall score for a plan (higher is better)
+     */
+    private calculateScore;
+    /**
+     * Explain a query - returns detailed plan information
+     */
+    explain(filter: Document): Promise<{
+        queryPlanner: {
+            plannerVersion: number;
+            namespace: string;
+            indexFilterSet: boolean;
+            winningPlan: IQueryPlan;
+            rejectedPlans: IQueryPlan[];
+        };
+    }>;
+}

package/dist_ts/tsmdb/engine/QueryPlanner.js

@@ -0,0 +1,308 @@
+import * as plugins from '../tsmdb.plugins.js';
+import { IndexEngine } from './IndexEngine.js';
+/**
+ * QueryPlanner - Analyzes queries and selects optimal execution plans
+ */
+export class QueryPlanner {
+    indexEngine;
+    constructor(indexEngine) {
+        this.indexEngine = indexEngine;
+    }
+    /**
+     * Generate an execution plan for a query filter
+     */
+    async plan(filter) {
+        await this.indexEngine['initialize']();
+        // Empty filter = full collection scan
+        if (!filter || Object.keys(filter).length === 0) {
+            return {
+                type: 'COLLSCAN',
+                indexCovering: false,
+                selectivity: 1.0,
+                usesRange: false,
+                indexFieldsUsed: [],
+                explanation: 'No filter specified, full collection scan required',
+            };
+        }
+        // Analyze the filter
+        const operatorInfo = this.analyzeFilter(filter);
+        // Get available indexes
+        const indexes = await this.indexEngine.listIndexes();
+        // Score each index
+        let bestPlan = null;
+        let bestScore = -1;
+        for (const index of indexes) {
+            const plan = this.scoreIndex(index, operatorInfo, filter);
+            if (plan.selectivity < 1.0) {
+                const score = this.calculateScore(plan);
+                if (score > bestScore) {
+                    bestScore = score;
+                    bestPlan = plan;
+                }
+            }
+        }
+        // If no suitable index found, fall back to collection scan
+        if (!bestPlan || bestScore <= 0) {
+            return {
+                type: 'COLLSCAN',
+                indexCovering: false,
+                selectivity: 1.0,
+                usesRange: false,
+                indexFieldsUsed: [],
+                explanation: 'No suitable index found for this query',
+            };
+        }
+        return bestPlan;
+    }
+    /**
+     * Analyze filter to extract operator information per field
+     */
+    analyzeFilter(filter, prefix = '') {
+        const result = new Map();
+        for (const [key, value] of Object.entries(filter)) {
+            // Skip logical operators at the top level
+            if (key.startsWith('$')) {
+                if (key === '$and' && Array.isArray(value)) {
+                    // Merge $and conditions
+                    for (const subFilter of value) {
+                        const subInfo = this.analyzeFilter(subFilter, prefix);
+                        for (const [field, info] of subInfo) {
+                            if (result.has(field)) {
+                                // Merge operators
+                                const existing = result.get(field);
+                                existing.operators.push(...info.operators);
+                                existing.equality = existing.equality || info.equality;
+                                existing.range = existing.range || info.range;
+                                existing.in = existing.in || info.in;
+                                Object.assign(existing.values, info.values);
+                            }
+                            else {
+                                result.set(field, info);
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            const fullKey = prefix ? `${prefix}.${key}` : key;
+            const info = {
+                field: fullKey,
+                operators: [],
+                equality: false,
+                range: false,
+                in: false,
+                exists: false,
+                regex: false,
+                values: {},
+            };
+            if (typeof value !== 'object' || value === null || value instanceof plugins.bson.ObjectId || value instanceof Date) {
+                // Direct equality
+                info.equality = true;
+                info.operators.push('$eq');
+                info.values['$eq'] = value;
+            }
+            else if (Array.isArray(value)) {
+                // Array equality (rare, but possible)
+                info.equality = true;
+                info.operators.push('$eq');
+                info.values['$eq'] = value;
+            }
+            else {
+                // Operator object
+                for (const [op, opValue] of Object.entries(value)) {
+                    if (op.startsWith('$')) {
+                        info.operators.push(op);
+                        info.values[op] = opValue;
+                        switch (op) {
+                            case '$eq':
+                                info.equality = true;
+                                break;
+                            case '$ne':
+                            case '$not':
+                                // These can use indexes but with low selectivity
+                                break;
+                            case '$in':
+                                info.in = true;
+                                break;
+                            case '$nin':
+                                // Can't efficiently use indexes
+                                break;
+                            case '$gt':
+                            case '$gte':
+                            case '$lt':
+                            case '$lte':
+                                info.range = true;
+                                break;
+                            case '$exists':
+                                info.exists = true;
+                                break;
+                            case '$regex':
+                                info.regex = true;
+                                break;
+                        }
+                    }
+                    else {
+                        // Nested object - recurse
+                        const nestedInfo = this.analyzeFilter({ [op]: opValue }, fullKey);
+                        for (const [nestedField, nestedFieldInfo] of nestedInfo) {
+                            result.set(nestedField, nestedFieldInfo);
+                        }
+                    }
+                }
+            }
+            if (info.operators.length > 0) {
+                result.set(fullKey, info);
+            }
+        }
+        return result;
+    }
+    /**
+     * Score an index for the given filter
+     */
+    scoreIndex(index, operatorInfo, filter) {
+        const indexFields = Object.keys(index.key);
+        const usedFields = [];
+        let usesRange = false;
+        let canUseIndex = true;
+        let selectivity = 1.0;
+        let residualFilter;
+        // Check each index field in order
+        for (const field of indexFields) {
+            const info = operatorInfo.get(field);
+            if (!info) {
+                // Index field not in filter - stop here
+                break;
+            }
+            usedFields.push(field);
+            // Calculate selectivity based on operator
+            if (info.equality) {
+                // Equality has high selectivity
+                selectivity *= 0.01; // Assume 1% match
+            }
+            else if (info.in) {
+                // $in selectivity depends on array size
+                const inValues = info.values['$in'];
+                if (Array.isArray(inValues)) {
+                    selectivity *= Math.min(0.5, inValues.length * 0.01);
+                }
+                else {
+                    selectivity *= 0.1;
+                }
+            }
+            else if (info.range) {
+                // Range queries have moderate selectivity
+                selectivity *= 0.25;
+                usesRange = true;
+                // After range, can't use more index fields efficiently
+                break;
+            }
+            else if (info.exists) {
+                // $exists can use sparse indexes
+                selectivity *= 0.5;
+            }
+            else {
+                // Other operators may not be indexable
+                canUseIndex = false;
+                break;
+            }
+        }
+        if (!canUseIndex || usedFields.length === 0) {
+            return {
+                type: 'COLLSCAN',
+                indexCovering: false,
+                selectivity: 1.0,
+                usesRange: false,
+                indexFieldsUsed: [],
+                explanation: `Index ${index.name} cannot be used for this query`,
+            };
+        }
+        // Build residual filter for conditions not covered by index
+        const coveredFields = new Set(usedFields);
+        const residualConditions = {};
+        for (const [field, info] of operatorInfo) {
+            if (!coveredFields.has(field)) {
+                // This field isn't covered by the index
+                if (info.equality) {
+                    residualConditions[field] = info.values['$eq'];
+                }
+                else {
+                    residualConditions[field] = info.values;
+                }
+            }
+        }
+        if (Object.keys(residualConditions).length > 0) {
+            residualFilter = residualConditions;
+        }
+        // Unique indexes have better selectivity for equality
+        if (index.unique && usedFields.length === indexFields.length) {
+            selectivity = Math.min(selectivity, 0.001); // At most 1 document
+        }
+        return {
+            type: usesRange ? 'IXSCAN_RANGE' : 'IXSCAN',
+            indexName: index.name,
+            indexKey: index.key,
+            indexCovering: Object.keys(residualConditions).length === 0,
+            selectivity,
+            usesRange,
+            indexFieldsUsed: usedFields,
+            residualFilter,
+            explanation: `Using index ${index.name} on fields [${usedFields.join(', ')}]`,
+        };
+    }
+    /**
+     * Calculate overall score for a plan (higher is better)
+     */
+    calculateScore(plan) {
+        let score = 0;
+        // Lower selectivity is better (fewer documents to fetch)
+        score += (1 - plan.selectivity) * 100;
+        // Index covering queries are best
+        if (plan.indexCovering) {
+            score += 50;
+        }
+        // More index fields used is better
+        score += plan.indexFieldsUsed.length * 10;
+        // Equality scans are better than range scans
+        if (!plan.usesRange) {
+            score += 20;
+        }
+        return score;
+    }
+    /**
+     * Explain a query - returns detailed plan information
+     */
+    async explain(filter) {
+        await this.indexEngine['initialize']();
+        // Analyze the filter
+        const operatorInfo = this.analyzeFilter(filter);
+        // Get available indexes
+        const indexes = await this.indexEngine.listIndexes();
+        // Score all indexes
+        const plans = [];
+        for (const index of indexes) {
+            const plan = this.scoreIndex(index, operatorInfo, filter);
+            plans.push(plan);
+        }
+        // Add collection scan as fallback
+        plans.push({
+            type: 'COLLSCAN',
+            indexCovering: false,
+            selectivity: 1.0,
+            usesRange: false,
+            indexFieldsUsed: [],
+            explanation: 'Full collection scan',
+        });
+        // Sort by score (best first)
+        plans.sort((a, b) => this.calculateScore(b) - this.calculateScore(a));
+        return {
+            queryPlanner: {
+                plannerVersion: 1,
+                namespace: `${this.indexEngine['dbName']}.${this.indexEngine['collName']}`,
+                indexFilterSet: false,
+                winningPlan: plans[0],
+                rejectedPlans: plans.slice(1),
+            },
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"QueryPlanner.js","sourceRoot":"","sources":["../../../ts/tsmdb/engine/QueryPlanner.ts"],"names":[],"mappings":"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"}