@push.rocks/smartmongo 2.0.12 → 2.1.0

package/dist_ts/congodb/server/handlers/AggregateHandler.d.ts

@@ -0,0 +1,31 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext, ICursorState } from '../CommandRouter.js';
+/**
+ * AggregateHandler - Handles aggregate command
+ */
+export declare class AggregateHandler implements ICommandHandler {
+    private cursors;
+    private nextCursorId;
+    constructor(cursors: Map<bigint, ICursorState>, nextCursorId: () => bigint);
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+    /**
+     * Preprocess pipeline to handle cross-collection lookups
+     */
+    private preprocessPipeline;
+    /**
+     * Check if pipeline has stages that need special handling
+     */
+    private hasSpecialStages;
+    /**
+     * Execute pipeline with special stage handling
+     */
+    private executeWithSpecialStages;
+    /**
+     * Handle $out stage - write results to a collection
+     */
+    private handleOut;
+    /**
+     * Handle $merge stage - merge results into a collection
+     */
+    private handleMerge;
+}

package/dist_ts/congodb/server/handlers/AggregateHandler.js

@@ -0,0 +1,277 @@
+import * as plugins from '../../congodb.plugins.js';
+import { AggregationEngine } from '../../engine/AggregationEngine.js';
+/**
+ * AggregateHandler - Handles aggregate command
+ */
+export class AggregateHandler {
+    cursors;
+    nextCursorId;
+    constructor(cursors, nextCursorId) {
+        this.cursors = cursors;
+        this.nextCursorId = nextCursorId;
+    }
+    async handle(context) {
+        const { storage, database, command } = context;
+        const collection = command.aggregate;
+        const pipeline = command.pipeline || [];
+        const cursor = command.cursor || {};
+        const batchSize = cursor.batchSize || 101;
+        // Validate
+        if (typeof collection !== 'string' && collection !== 1) {
+            return {
+                ok: 0,
+                errmsg: 'aggregate command requires a collection name or 1',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        if (!Array.isArray(pipeline)) {
+            return {
+                ok: 0,
+                errmsg: 'pipeline must be an array',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        try {
+            // Get source documents
+            let documents = [];
+            if (collection === 1 || collection === '1') {
+                // Database-level aggregation (e.g., $listLocalSessions)
+                documents = [];
+            }
+            else {
+                // Collection-level aggregation
+                const exists = await storage.collectionExists(database, collection);
+                if (exists) {
+                    documents = await storage.findAll(database, collection);
+                }
+            }
+            // Handle $lookup and $graphLookup stages that reference other collections
+            const processedPipeline = await this.preprocessPipeline(storage, database, pipeline, documents);
+            // Run aggregation
+            let results;
+            // Check for special stages that we handle manually
+            if (this.hasSpecialStages(pipeline)) {
+                results = await this.executeWithSpecialStages(storage, database, documents, pipeline);
+            }
+            else {
+                results = AggregationEngine.aggregate(documents, processedPipeline);
+            }
+            // Handle $out and $merge stages
+            const lastStage = pipeline[pipeline.length - 1];
+            if (lastStage && lastStage.$out) {
+                await this.handleOut(storage, database, results, lastStage.$out);
+                return { ok: 1, cursor: { id: plugins.bson.Long.fromNumber(0), ns: `${database}.${collection}`, firstBatch: [] } };
+            }
+            if (lastStage && lastStage.$merge) {
+                await this.handleMerge(storage, database, results, lastStage.$merge);
+                return { ok: 1, cursor: { id: plugins.bson.Long.fromNumber(0), ns: `${database}.${collection}`, firstBatch: [] } };
+            }
+            // Build cursor response
+            const effectiveBatchSize = Math.min(batchSize, results.length);
+            const firstBatch = results.slice(0, effectiveBatchSize);
+            const remaining = results.slice(effectiveBatchSize);
+            let cursorId = BigInt(0);
+            if (remaining.length > 0) {
+                cursorId = this.nextCursorId();
+                this.cursors.set(cursorId, {
+                    id: cursorId,
+                    database,
+                    collection: typeof collection === 'string' ? collection : '$cmd.aggregate',
+                    documents: remaining,
+                    position: 0,
+                    batchSize,
+                    createdAt: new Date(),
+                });
+            }
+            return {
+                ok: 1,
+                cursor: {
+                    id: plugins.bson.Long.fromBigInt(cursorId),
+                    ns: `${database}.${typeof collection === 'string' ? collection : '$cmd.aggregate'}`,
+                    firstBatch,
+                },
+            };
+        }
+        catch (error) {
+            return {
+                ok: 0,
+                errmsg: error.message || 'Aggregation failed',
+                code: 1,
+                codeName: 'InternalError',
+            };
+        }
+    }
+    /**
+     * Preprocess pipeline to handle cross-collection lookups
+     */
+    async preprocessPipeline(storage, database, pipeline, documents) {
+        // For now, return the pipeline as-is
+        // Cross-collection lookups are handled in executeWithSpecialStages
+        return pipeline;
+    }
+    /**
+     * Check if pipeline has stages that need special handling
+     */
+    hasSpecialStages(pipeline) {
+        return pipeline.some(stage => stage.$lookup ||
+            stage.$graphLookup ||
+            stage.$unionWith);
+    }
+    /**
+     * Execute pipeline with special stage handling
+     */
+    async executeWithSpecialStages(storage, database, documents, pipeline) {
+        let results = [...documents];
+        for (const stage of pipeline) {
+            if (stage.$lookup) {
+                const lookupSpec = stage.$lookup;
+                const fromCollection = lookupSpec.from;
+                // Get foreign collection documents
+                const foreignExists = await storage.collectionExists(database, fromCollection);
+                const foreignDocs = foreignExists
+                    ? await storage.findAll(database, fromCollection)
+                    : [];
+                results = AggregationEngine.executeLookup(results, lookupSpec, foreignDocs);
+            }
+            else if (stage.$graphLookup) {
+                const graphLookupSpec = stage.$graphLookup;
+                const fromCollection = graphLookupSpec.from;
+                const foreignExists = await storage.collectionExists(database, fromCollection);
+                const foreignDocs = foreignExists
+                    ? await storage.findAll(database, fromCollection)
+                    : [];
+                results = AggregationEngine.executeGraphLookup(results, graphLookupSpec, foreignDocs);
+            }
+            else if (stage.$unionWith) {
+                let unionSpec = stage.$unionWith;
+                let unionColl;
+                let unionPipeline;
+                if (typeof unionSpec === 'string') {
+                    unionColl = unionSpec;
+                }
+                else {
+                    unionColl = unionSpec.coll;
+                    unionPipeline = unionSpec.pipeline;
+                }
+                const unionExists = await storage.collectionExists(database, unionColl);
+                const unionDocs = unionExists
+                    ? await storage.findAll(database, unionColl)
+                    : [];
+                results = AggregationEngine.executeUnionWith(results, unionDocs, unionPipeline);
+            }
+            else if (stage.$facet) {
+                // Execute each facet pipeline separately
+                const facetResults = {};
+                for (const [facetName, facetPipeline] of Object.entries(stage.$facet)) {
+                    const facetDocs = await this.executeWithSpecialStages(storage, database, results, facetPipeline);
+                    facetResults[facetName] = facetDocs;
+                }
+                results = [facetResults];
+            }
+            else {
+                // Regular stage - pass to mingo
+                results = AggregationEngine.aggregate(results, [stage]);
+            }
+        }
+        return results;
+    }
+    /**
+     * Handle $out stage - write results to a collection
+     */
+    async handleOut(storage, database, results, outSpec) {
+        let targetDb = database;
+        let targetColl;
+        if (typeof outSpec === 'string') {
+            targetColl = outSpec;
+        }
+        else {
+            targetDb = outSpec.db || database;
+            targetColl = outSpec.coll;
+        }
+        // Drop existing collection
+        await storage.dropCollection(targetDb, targetColl);
+        // Create new collection and insert results
+        await storage.createCollection(targetDb, targetColl);
+        for (const doc of results) {
+            if (!doc._id) {
+                doc._id = new plugins.bson.ObjectId();
+            }
+            await storage.insertOne(targetDb, targetColl, doc);
+        }
+    }
+    /**
+     * Handle $merge stage - merge results into a collection
+     */
+    async handleMerge(storage, database, results, mergeSpec) {
+        let targetDb = database;
+        let targetColl;
+        if (typeof mergeSpec === 'string') {
+            targetColl = mergeSpec;
+        }
+        else if (typeof mergeSpec.into === 'string') {
+            targetColl = mergeSpec.into;
+        }
+        else {
+            targetDb = mergeSpec.into.db || database;
+            targetColl = mergeSpec.into.coll;
+        }
+        const on = mergeSpec.on || '_id';
+        const whenMatched = mergeSpec.whenMatched || 'merge';
+        const whenNotMatched = mergeSpec.whenNotMatched || 'insert';
+        // Ensure target collection exists
+        await storage.createCollection(targetDb, targetColl);
+        for (const doc of results) {
+            // Find matching document
+            const existingDocs = await storage.findAll(targetDb, targetColl);
+            const onFields = Array.isArray(on) ? on : [on];
+            let matchingDoc = null;
+            for (const existing of existingDocs) {
+                let matches = true;
+                for (const field of onFields) {
+                    if (JSON.stringify(existing[field]) !== JSON.stringify(doc[field])) {
+                        matches = false;
+                        break;
+                    }
+                }
+                if (matches) {
+                    matchingDoc = existing;
+                    break;
+                }
+            }
+            if (matchingDoc) {
+                // Handle whenMatched
+                if (whenMatched === 'replace') {
+                    await storage.updateById(targetDb, targetColl, matchingDoc._id, doc);
+                }
+                else if (whenMatched === 'keepExisting') {
+                    // Do nothing
+                }
+                else if (whenMatched === 'merge') {
+                    const merged = { ...matchingDoc, ...doc };
+                    await storage.updateById(targetDb, targetColl, matchingDoc._id, merged);
+                }
+                else if (whenMatched === 'fail') {
+                    throw new Error('Document matched but whenMatched is fail');
+                }
+            }
+            else {
+                // Handle whenNotMatched
+                if (whenNotMatched === 'insert') {
+                    if (!doc._id) {
+                        doc._id = new plugins.bson.ObjectId();
+                    }
+                    await storage.insertOne(targetDb, targetColl, doc);
+                }
+                else if (whenNotMatched === 'discard') {
+                    // Do nothing
+                }
+                else if (whenNotMatched === 'fail') {
+                    throw new Error('Document not matched but whenNotMatched is fail');
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"AggregateHandler.js","sourceRoot":"","sources":["../../../../ts/congodb/server/handlers/AggregateHandler.ts"],"names":[],"mappings":"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"}

package/dist_ts/congodb/server/handlers/DeleteHandler.d.ts

@@ -0,0 +1,8 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext } from '../CommandRouter.js';
+/**
+ * DeleteHandler - Handles delete commands
+ */
+export declare class DeleteHandler implements ICommandHandler {
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+}

package/dist_ts/congodb/server/handlers/DeleteHandler.js

@@ -0,0 +1,83 @@
+import * as plugins from '../../congodb.plugins.js';
+import { QueryEngine } from '../../engine/QueryEngine.js';
+/**
+ * DeleteHandler - Handles delete commands
+ */
+export class DeleteHandler {
+    async handle(context) {
+        const { storage, database, command, documentSequences } = context;
+        const collection = command.delete;
+        if (typeof collection !== 'string') {
+            return {
+                ok: 0,
+                errmsg: 'delete command requires a collection name',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        // Get deletes from command or document sequences
+        let deletes = command.deletes || [];
+        // Check for OP_MSG document sequences
+        if (documentSequences && documentSequences.has('deletes')) {
+            deletes = documentSequences.get('deletes');
+        }
+        if (!Array.isArray(deletes) || deletes.length === 0) {
+            return {
+                ok: 0,
+                errmsg: 'delete command requires deletes array',
+                code: 2,
+                codeName: 'BadValue',
+            };
+        }
+        const ordered = command.ordered !== false;
+        const writeErrors = [];
+        let totalDeleted = 0;
+        // Check if collection exists
+        const exists = await storage.collectionExists(database, collection);
+        if (!exists) {
+            // Collection doesn't exist, return success with 0 deleted
+            return { ok: 1, n: 0 };
+        }
+        for (let i = 0; i < deletes.length; i++) {
+            const deleteSpec = deletes[i];
+            const filter = deleteSpec.q || deleteSpec.filter || {};
+            const limit = deleteSpec.limit;
+            // limit: 0 means delete all matching, limit: 1 means delete one
+            const deleteAll = limit === 0;
+            try {
+                // Get all documents
+                const documents = await storage.findAll(database, collection);
+                // Apply filter
+                const matchingDocs = QueryEngine.filter(documents, filter);
+                if (matchingDocs.length === 0) {
+                    continue;
+                }
+                // Determine which documents to delete
+                const docsToDelete = deleteAll ? matchingDocs : matchingDocs.slice(0, 1);
+                // Delete the documents
+                const idsToDelete = docsToDelete.map(doc => doc._id);
+                const deleted = await storage.deleteByIds(database, collection, idsToDelete);
+                totalDeleted += deleted;
+            }
+            catch (error) {
+                writeErrors.push({
+                    index: i,
+                    code: error.code || 1,
+                    errmsg: error.message || 'Delete failed',
+                });
+                if (ordered) {
+                    break;
+                }
+            }
+        }
+        const response = {
+            ok: 1,
+            n: totalDeleted,
+        };
+        if (writeErrors.length > 0) {
+            response.writeErrors = writeErrors;
+        }
+        return response;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/congodb/server/handlers/FindHandler.d.ts

@@ -0,0 +1,31 @@
+import * as plugins from '../../congodb.plugins.js';
+import type { ICommandHandler, IHandlerContext, ICursorState } from '../CommandRouter.js';
+/**
+ * FindHandler - Handles find, getMore, killCursors, count, distinct commands
+ */
+export declare class FindHandler implements ICommandHandler {
+    private cursors;
+    private nextCursorId;
+    constructor(cursors: Map<bigint, ICursorState>, nextCursorId: () => bigint);
+    handle(context: IHandlerContext): Promise<plugins.bson.Document>;
+    /**
+     * Handle find command
+     */
+    private handleFind;
+    /**
+     * Handle getMore command
+     */
+    private handleGetMore;
+    /**
+     * Handle killCursors command
+     */
+    private handleKillCursors;
+    /**
+     * Handle count command
+     */
+    private handleCount;
+    /**
+     * Handle distinct command
+     */
+    private handleDistinct;
+}