@ai.ntellect/core 0.6.0 → 0.6.2

package/dist/graph/engine.js

@@ -13,24 +13,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GraphEngine = void 0;
-const dotenv_1 = require("dotenv");
 const events_1 = __importDefault(require("events"));
 const zod_1 = require("zod");
-(0, dotenv_1.configDotenv)();
 /**
- * Represents a directed worflow structure capable of executing nodes in sequence or parallel.
- * The worflow can handle state management, event emissions, and conditional execution paths.
+ * Représente un workflow dirigé capable d’exécuter des noeuds en séquence ou en parallèle.
  *
- * @template T - The type of data stored in the worflow's context
+ * @template T - Le type de données stockées dans le contexte du workflow
  */
 class GraphEngine {
     /**
-     * Creates a new Graph instance.
+     * Crée une nouvelle instance de GraphEngine.
      *
-     * @param {GraphDefinition<T>} [definition] - Initial worflow structure and configuration
-     * @param {Object} [config] - Additional configuration options
-     * @param {boolean} [config.autoDetectCycles] - Whether to check for cycles during initialization
-     * @throws {Error} If cycles are detected when autoDetectCycles is true
+     * @param {GraphDefinition<T>} [definition] - La définition initiale du workflow
+     * @param {GraphOptions<T>} [options] - Options de configuration
      */
     constructor(definition, options) {
         this.name = (definition === null || definition === void 0 ? void 0 : definition.name) || "anonymous";
@@ -41,74 +36,69 @@ class GraphEngine {
         this.persistence = null;
         this.notifier = null;
         this.schema = options === null || options === void 0 ? void 0 : options.schema;
-        this.currentState = { context: {} };
+        this.currentState = {};
         if (definition) {
             this.loadFromDefinition(definition);
         }
         if ((options === null || options === void 0 ? void 0 : options.autoDetectCycles) && this.checkForCycles()) {
-            throw new Error("Cycle detected in the workflow");
+            throw new Error("Cycle détecté dans le workflow");
         }
         if (options === null || options === void 0 ? void 0 : options.initialState) {
             this.setState(options.initialState);
         }
     }
     /**
-     * Adds a value to the global context.
-     * @param {string} key - The key to store the value under
-     * @param {any} value - The value to store
+     * Ajoute un élément au contexte global.
+     * @param {string} key - La clé
+     * @param {any} value - La valeur
      */
     addToContext(key, value) {
         this.globalContext.set(key, value);
     }
     /**
-     * Retrieves a value from the global context.
-     * @param {string} key - The key to retrieve
-     * @returns {any} The stored value, or undefined if not found
+     * Récupère un élément du contexte global.
+     * @param {string} key - La clé
      */
     getContext(key) {
         return this.globalContext.get(key);
     }
     /**
-     * Removes a value from the global context.
-     * @param {string} key - The key to remove
+     * Supprime un élément du contexte global.
+     * @param {string} key - La clé
      */
     removeFromContext(key) {
         this.globalContext.delete(key);
     }
     /**
-     * Sets the persistence layer for the worflow.
-     * @param {Persistence<T>} persistence - The persistence implementation
+     * Définit la couche de persistance.
+     * @param {Persistence<T>} persistence
      */
     setPersistence(persistence) {
         this.persistence = persistence;
     }
     /**
-     * Sets the real-time notifier for the worflow.
-     * @param {RealTimeNotifier} notifier - The notifier implementation
+     * Définit le notifier en temps réel.
+     * @param {RealTimeNotifier} notifier
      */
     setNotifier(notifier) {
         this.notifier = notifier;
     }
     /**
-     * Loads a worflow structure from a definition object.
+     * Charge un workflow à partir d'une définition.
      * @private
-     * @param {GraphDefinition<T>} definition - The worflow definition
+     * @param {GraphDefinition<T>} definition
      */
     loadFromDefinition(definition) {
         Object.entries(definition.nodes).forEach(([_, nodeConfig]) => {
-            this.addNode(nodeConfig, {
-                condition: nodeConfig.condition,
-                relationships: nodeConfig.relationships,
-            });
+            this.addNode(nodeConfig);
         });
     }
     /**
-     * Recursively checks if a node is part of a cycle.
-     * @private
-     * @param {string} nodeName - The name of the node to check
-     * @param {Set<string>} visited - Set of visited nodes
-     * @param {Set<string>} recStack - Set of nodes in the current recursion stack
-     * @returns {boolean} True if a cycle is detected, false otherwise
+     * Vérifie récursivement s’il existe un cycle dans le workflow.
+     * @param {string} nodeName
+     * @param {Set<string>} visited
+     * @param {Set<string>} recStack
+     * @returns {boolean}
      */
     isCyclic(nodeName, visited, recStack) {
         if (!visited.has(nodeName)) {
@@ -132,8 +122,8 @@ class GraphEngine {
         return false;
     }
     /**
-     * Checks if the worflow contains any cycles.
-     * @returns {boolean} True if cycles are detected, false otherwise
+     * Vérifie si le workflow contient des cycles.
+     * @returns {boolean}
      */
     checkForCycles() {
         const visited = new Set();
@@ -146,18 +136,18 @@ class GraphEngine {
         return false;
     }
     /**
-     * Adds a new node to the worflow.
-     * @param {Node<T>} node - The node to add
-     * @param {Object} options - Node configuration options
-     * @param {Function} [options.condition] - Condition function for node execution
-     * @param {string[]} [options.relations] - Array of relations node names
-     * @param {string[]} [options.events] - Array of event names to listen for
+     * Ajoute un nouveau nœud au workflow.
+     * @param {Node<T>} node
      */
-    addNode(node, { condition, relationships, events, }) {
-        node.relationships = relationships;
-        node.condition = condition;
-        if (events) {
-            events.forEach((event) => {
+    addNode(node) {
+        if (node.relationships) {
+            node.relationships.forEach((relationship) => {
+                var _a, _b;
+                (_b = (_a = this.nodes.get(relationship.name)) === null || _a === void 0 ? void 0 : _a.relationships) === null || _b === void 0 ? void 0 : _b.push(relationship);
+            });
+        }
+        if (node.events) {
+            node.events.forEach((event) => {
                 this.eventEmitter.on(event, (data) => __awaiter(this, void 0, void 0, function* () {
                     const state = data.state || {};
                     yield this.execute(state, node.name);
@@ -167,18 +157,18 @@ class GraphEngine {
         this.nodes.set(node.name, node);
     }
     /**
-     * Emits an event to the worflow's event emitter.
-     * @param {string} eventName - Name of the event to emit
-     * @param {any} data - Data to pass with the event
+     * Émet un événement sur l'event emitter du workflow.
+     * @param {string} eventName
+     * @param {any} data
      */
     emit(eventName, data) {
         this.eventEmitter.emit(eventName, data);
     }
     /**
-     * Adds a subworflow as a node in the current worflow.
-     * @param {Graph<T>} subGraph - The subworflow to add
-     * @param {string} entryNode - The entry node name in the subworflow
-     * @param {string} name - The name for the subworflow node
+     * Ajoute un sous-graph (GraphEngine) comme un nœud dans le workflow courant.
+     * @param {GraphEngine<T>} subGraph
+     * @param {string} entryNode - Le nom du nœud de démarrage dans le sous-graph
+     * @param {string} name - Le nom symbolique à donner au sous-graph
      */
     addSubGraph(subGraph, entryNode, name) {
         const subGraphNode = {
@@ -191,22 +181,23 @@ class GraphEngine {
         this.nodes.set(name, subGraphNode);
     }
     /**
-     * Executes the worflow starting from a specific node.
-     * @param {SharedState<T>} state - The initial state
-     * @param {string} startNode - The name of the starting node
-     * @param {Function} [onStream] - Callback for streaming state updates
-     * @param {Function} [onError] - Callback for handling errors
+     * Exécute le workflow à partir d’un nœud donné.
+     * @param {SharedState<T>} state
+     * @param {string} startNode
+     * @param {(state: SharedState<T>) => void} [onStream] - Callback sur l’évolution de l’état
+     * @param {(error: Error, nodeName: string, state: SharedState<T>) => void} [onError] - Callback sur erreur
      */
     execute(state, startNode, onStream, onError) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a, _b;
             try {
+                // Valide l'état initial via le schéma global (si défini)
                 if (this.schema) {
                     try {
-                        this.schema.parse(state.context);
+                        this.schema.parse(state);
                     }
                     catch (error) {
-                        const validationError = new Error(`Initial state validation failed: ${error instanceof Error ? error.message : error}`);
+                        const validationError = new Error(`Échec de la validation de l'état initial: ${error instanceof Error ? error.message : error}`);
                         if (onError)
                             onError(validationError, startNode, state);
                         throw validationError;
@@ -217,13 +208,16 @@ class GraphEngine {
                 while (currentNodeName) {
                     this.executedNodes.add(currentNodeName);
                     const currentNode = this.nodes.get(currentNodeName);
-                    if (!currentNode)
-                        throw new Error(`Node ${currentNodeName} not found.`);
+                    if (!currentNode) {
+                        throw new Error(`Nœud ${currentNodeName} introuvable.`);
+                    }
+                    // Vérification de condition (si présente)
                     if (currentNode.condition &&
                         !currentNode.condition(this.currentState)) {
                         break;
                     }
                     try {
+                        // Notifier : début d'exécution du nœud
                         if (this.notifier) {
                             this.notifier.notify("nodeExecutionStarted", {
                                 workflow: this.name,
@@ -235,11 +229,13 @@ class GraphEngine {
                         if (newState) {
                             this.setState(newState);
                             if (onStream)
-                                onStream(this.currentState);
+                                onStream(this);
                         }
+                        // Sauvegarde via la persistence (optionnel)
                         if (this.persistence) {
                             yield this.persistence.saveState(this.name, this.currentState, currentNodeName);
                         }
+                        // Notifier : fin d'exécution du nœud
                         if (this.notifier) {
                             yield this.notifier.notify("nodeExecutionCompleted", {
                                 workflow: this.name,
@@ -249,8 +245,9 @@ class GraphEngine {
                         }
                     }
                     catch (error) {
-                        if (onError)
+                        if (onError) {
                             onError(error, currentNodeName, this.currentState);
+                        }
                         if (this.notifier) {
                             this.notifier.notify("nodeExecutionFailed", {
                                 workflow: this.name,
@@ -261,12 +258,16 @@ class GraphEngine {
                         }
                         break;
                     }
+                    // Gestion des relations (branchements)
                     const relationsNodes = currentNode.relationships || [];
                     if (relationsNodes.length > 1) {
+                        // Exécution parallèle des branches
                         yield Promise.all(relationsNodes.map((relation) => this.execute(this.currentState, relation.name, onStream, onError)));
+                        // Après exécution en parallèle, on arrête la boucle
                         break;
                     }
                     else {
+                        // Cas normal : un seul chemin
                         currentNodeName = ((_b = relationsNodes[0]) === null || _b === void 0 ? void 0 : _b.name) || "";
                     }
                 }
@@ -281,12 +282,10 @@ class GraphEngine {
         });
     }
     /**
-     * Executes multiple nodes in parallel with a concurrency limit.
-     * @param {SharedState<T>} state - The shared state
-     * @param {string[]} nodeNames - Array of node names to execute
-     * @param {number} [concurrencyLimit=5] - Maximum number of concurrent executions
-     * @param {Function} [onStream] - Callback for streaming state updates
-     * @param {Function} [onError] - Callback for handling errors
+     * Exécute plusieurs nœuds en parallèle au sein du même workflow, avec une limite de concurrence.
+     * @param {SharedState<T>} state
+     * @param {string[]} nodeNames
+     * @param {number} [concurrencyLimit=5]
      */
     executeParallel(state_1, nodeNames_1) {
         return __awaiter(this, arguments, void 0, function* (state, nodeNames, concurrencyLimit = 5, onStream, onError) {
@@ -303,8 +302,8 @@ class GraphEngine {
         });
     }
     /**
-     * Updates the worflow structure with a new definition.
-     * @param {GraphDefinition<T>} definition - The new worflow definition
+     * Met à jour le workflow avec une nouvelle définition (mise à jour des nœuds existants ou ajout de nouveaux).
+     * @param {GraphDefinition<T>} definition
      */
     updateGraph(definition) {
         Object.entries(definition.nodes).forEach(([_, nodeConfig]) => {
@@ -313,78 +312,69 @@ class GraphEngine {
                 existingNode.relationships =
                     nodeConfig.relationships || existingNode.relationships;
                 existingNode.condition = nodeConfig.condition || existingNode.condition;
+                existingNode.events = nodeConfig.events || existingNode.events;
             }
             else {
-                this.addNode(nodeConfig, {
-                    condition: nodeConfig.condition,
-                    relationships: nodeConfig.relationships,
-                });
+                this.addNode(nodeConfig);
             }
         });
     }
     /**
-     * Replace the worflow with a new definition.
-     * @param {GraphDefinition<T>} definition - The new worflow definition
+     * Remplace complètement le workflow par une nouvelle définition.
+     * @param {GraphDefinition<T>} definition
      */
     replaceGraph(definition) {
         this.nodes.clear();
         this.loadFromDefinition(definition);
     }
     /**
-     * Generates a visual representation of the worflow using Mermaid diagram syntax.
-     * The diagram shows all nodes and their connections, with special highlighting for:
-     * - Entry nodes (green)
-     * - Event nodes (yellow)
-     * - Conditional nodes (orange)
-     *
-     * @param {string} [title] - Optional title for the diagram
-     * @returns {string} Mermaid diagram syntax representing the worflow
+     * Génère un diagramme Mermaid pour visualiser le workflow.
+     * @param {string} [title]
+     * @returns {string}
      */
     generateMermaidDiagram(title) {
         const lines = ["flowchart TD"];
         if (title) {
             lines.push(`  subgraph ${title}`);
         }
-        // Add nodes with styling
+        // Ajout des nœuds
         this.nodes.forEach((node, nodeName) => {
             const hasEvents = node.events && node.events.length > 0;
             const hasCondition = !!node.condition;
-            // Style nodes based on their properties
+            // Style selon les propriétés
             let style = "";
             if (hasEvents) {
-                style = "style " + nodeName + " fill:#FFD700,stroke:#DAA520"; // Yellow for event nodes
+                style = "style " + nodeName + " fill:#FFD700,stroke:#DAA520"; // Jaune pour event
             }
             else if (hasCondition) {
-                style = "style " + nodeName + " fill:#FFA500,stroke:#FF8C00"; // Orange for conditional nodes
+                style = "style " + nodeName + " fill:#FFA500,stroke:#FF8C00"; // Orange pour condition
             }
-            // Add node definition
             lines.push(`  ${nodeName}[${nodeName}]`);
             if (style) {
                 lines.push(`  ${style}`);
             }
         });
-        // Add connections
+        // Ajout des connexions
         this.nodes.forEach((node, nodeName) => {
             if (node.relationships) {
                 node.relationships.forEach((relationsNode) => {
                     let connectionStyle = "";
                     if (node.condition) {
-                        connectionStyle = "---|condition|"; // Add label for conditional connections
+                        connectionStyle = "---|condition|";
                     }
                     else {
-                        connectionStyle = "-->"; // Normal connection
+                        connectionStyle = "-->";
                     }
                     lines.push(`  ${nodeName} ${connectionStyle} ${relationsNode}`);
                 });
             }
-            // Add event connections if any
+            // Gestion des events
             if (node.events && node.events.length > 0) {
                 node.events.forEach((event) => {
                     const eventNodeId = `${event}_event`;
                     lines.push(`  ${eventNodeId}((${event})):::event`);
                     lines.push(`  ${eventNodeId} -.->|trigger| ${nodeName}`);
                 });
-                // Add style class for event nodes
                 lines.push("  classDef event fill:#FFD700,stroke:#DAA520");
             }
         });
@@ -394,23 +384,26 @@ class GraphEngine {
         return lines.join("\n");
     }
     /**
-     * Renders the worflow visualization using Mermaid syntax.
-     * This method can be used to visualize the worflow structure in supported environments.
-     *
-     * @param {string} [title] - Optional title for the visualization
+     * Affiche le diagramme Mermaid dans la console.
+     * @param {string} [title]
      */
     visualize(title) {
         const diagram = this.generateMermaidDiagram(title);
-        console.log("To visualize this worflow, use a Mermaid-compatible renderer with this syntax:");
+        console.log("Pour visualiser ce workflow, utilisez un rendu compatible Mermaid avec la syntaxe suivante :");
         console.log("\n```mermaid");
         console.log(diagram);
         console.log("```\n");
     }
-    exportGraphToJson(worflow) {
+    /**
+     * Exporte la définition du workflow au format JSON (pour debug ou documentation).
+     * @param {GraphDefinition<T>} workflow
+     * @returns {string} JSON string
+     */
+    exportGraphToJson(workflow) {
         const result = {
-            worflowName: worflow.name,
-            entryNode: worflow.entryNode,
-            nodes: Object.entries(worflow.nodes).reduce((acc, [key, node]) => {
+            workflowName: workflow.name,
+            entryNode: workflow.entryNode,
+            nodes: Object.entries(workflow.nodes).reduce((acc, [key, node]) => {
                 acc[key] = {
                     name: node.name,
                     description: node.description || "No description provided",
@@ -424,15 +417,14 @@ class GraphEngine {
         return JSON.stringify(result, null, 2);
     }
     /**
-     * Generates a visual representation of the workflow schema.
-     * Displays the structure of the data expected for each node.
-     *
-     * @returns {string} A formatted string describing the workflow schema
+     * Génère une représentation textuelle (console) du schéma du workflow.
+     * @returns {string}
      */
     visualizeSchema() {
         const output = [];
         output.push(`📋 Graph: ${this.name}`);
         output.push("=".repeat(50));
+        // Schéma global
         if (this.schema) {
             output.push("🔷 Global Schema:");
             output.push("-".repeat(30));
@@ -446,20 +438,25 @@ class GraphEngine {
             }
             output.push("");
         }
+        // Détails des nœuds
         output.push("🔷 Nodes:");
         output.push("-".repeat(30));
         this.nodes.forEach((node, nodeName) => {
             output.push(`\n📍 Node: ${nodeName}`);
             output.push(`Description: ${node.description || "No description provided"}`);
             if (node.relationships && node.relationships.length > 0) {
-                output.push(`Next nodes: ${node.relationships.join(", ")}`);
+                const rels = node.relationships.map((r) => r.name).join(", ");
+                output.push(`Next nodes: ${rels}`);
             }
             output.push("");
         });
         return output.join("\n");
     }
     /**
-     * Recursively describes a Zod type.
+     * Décrit récursivement un type Zod pour l'affichage.
+     * @param {z.ZodType} type
+     * @param {number} indent
+     * @returns {string}
      */
     describeZodType(type, indent = 0) {
         const padding = "  ".repeat(indent);
@@ -505,29 +502,29 @@ class GraphEngine {
         return type.constructor.name.replace("Zod", "") || "unknown";
     }
     /**
-     * Updates the state of a node.
-     * @param {SharedState<T>} state - The current state
-     * @param {Partial<T>} updates - The updates to apply
-     * @returns {SharedState<T>} The updated state
+     * Met à jour le contexte du workflow pour un nœud, en renvoyant un nouvel état.
+     * @param {SharedState<T>} state
+     * @param {Partial<T>} updates
+     * @returns {SharedState<T>}
      */
     updateNodeState(state, updates) {
-        return Object.assign(Object.assign({}, state), { context: Object.assign(Object.assign({}, (state.context || {})), updates) });
+        return Object.assign(Object.assign({}, state), updates);
     }
     /**
-     * Retrieves the current state of the workflow.
-     * @returns {SharedState<T>} The current state
+     * Récupère l'état courant du workflow.
+     * @returns {SharedState<T>}
      */
     getState() {
         return this.currentState;
     }
     /**
-     * Sets the state of the workflow.
-     * @param {Partial<SharedState<T>>} state - The new state
+     * Définit le nouvel état courant du workflow et met à jour le contexte global.
+     * @param {Partial<SharedState<T>>} state
      */
     setState(state) {
         this.currentState = this.mergeStates(this.currentState, state);
-        if (state.context) {
-            Object.entries(state.context).forEach(([key, value]) => {
+        if (state) {
+            Object.entries(state).forEach(([key, value]) => {
                 this.globalContext.set(key, value);
             });
         }
@@ -535,29 +532,95 @@ class GraphEngine {
         if (currentNode) {
             const node = this.nodes.get(currentNode);
             if (node) {
-                node.state = Object.assign(Object.assign({}, (node.state || {})), (state.context || {}));
+                node.state = Object.assign(Object.assign({}, (node.state || {})), (state || {}));
             }
         }
     }
     /**
-     * Merges two states.
-     * @param {SharedState<T>} currentState - The current state
-     * @param {Partial<SharedState<T>>} newState - The new state
-     * @returns {SharedState<T>} The merged state
+     * Fusionne deux états.
+     * @param {SharedState<T>} currentState
+     * @param {Partial<SharedState<T>>} newState
+     * @returns {SharedState<T>}
      */
     mergeStates(currentState, newState) {
-        return Object.assign(Object.assign({}, currentState), { context: Object.assign(Object.assign({}, (currentState.context || {})), (newState.context || {})) });
+        return Object.assign(Object.assign({}, currentState), (newState || {}));
     }
     /**
-     * Updates the state of the workflow.
-     * @param {Partial<SharedState<T>>} updates - The updates to apply
-     * @returns {SharedState<T>} The updated state
+     * Met à jour l'état courant et le renvoie.
+     * @param {Partial<T>} updates
+     * @returns {SharedState<T>}
      */
     updateState(updates) {
         const currentState = this.getState();
-        const newState = Object.assign(Object.assign({}, currentState), { context: Object.assign(Object.assign({}, currentState.context), (updates.context || {})) });
+        const newState = Object.assign(Object.assign({}, currentState), updates);
         this.setState(newState);
         return newState;
     }
+    /* =============================================
+       =   MÉTHODES STATIQUES POUR PLUSIEURS GRAPHES  =
+       ============================================= */
+    /**
+     * Exécute plusieurs GraphEngine en **séquence** (l'un après l'autre).
+     * @param graphs Liste des graphes à exécuter
+     * @param startNodes Noms des nœuds de départ correspondants
+     * @param initialStates États initiaux correspondants
+     * @param onStream Callback d'avancement
+     * @param onError Callback d'erreur
+     * @returns Tableau des états finaux de chaque graphe
+     */
+    static executeGraphsInSequence(graphs, startNodes, initialStates, onStream, onError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const finalStates = [];
+            for (let i = 0; i < graphs.length; i++) {
+                const graph = graphs[i];
+                const startNode = startNodes[i];
+                const initialState = initialStates[i];
+                const result = yield graph.execute(initialState, startNode, onStream, onError);
+                finalStates.push(result);
+            }
+            return finalStates;
+        });
+    }
+    /**
+     * Exécute plusieurs GraphEngine en **parallèle** (sans limite de concurrence).
+     * @param graphs Liste des graphes
+     * @param startNodes Noms des nœuds de départ
+     * @param initialStates États initiaux
+     * @param onStream Callback d'avancement
+     * @param onError Callback d'erreur
+     * @returns Tableau des états finaux de chaque graphe
+     */
+    static executeGraphsInParallel(graphs, startNodes, initialStates, onStream, onError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const promises = graphs.map((graph, index) => graph.execute(initialStates[index], startNodes[index], onStream, onError));
+            return Promise.all(promises);
+        });
+    }
+    /**
+     * Exécute plusieurs GraphEngine en parallèle **avec une limite de concurrence**.
+     * @param graphs Liste des graphes
+     * @param startNodes Noms des nœuds de départ
+     * @param initialStates États initiaux
+     * @param concurrencyLimit Limite de concurrence
+     * @param onStream Callback d'avancement
+     * @param onError Callback d'erreur
+     * @returns Tableau des états finaux de chaque graphe
+     */
+    static executeGraphsWithConcurrencyLimit(graphs, startNodes, initialStates, concurrencyLimit, onStream, onError) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = [];
+            for (let i = 0; i < graphs.length; i += concurrencyLimit) {
+                const chunkGraphs = graphs.slice(i, i + concurrencyLimit);
+                const chunkStartNodes = startNodes.slice(i, i + concurrencyLimit);
+                const chunkInitialStates = initialStates.slice(i, i + concurrencyLimit);
+                const chunkPromises = chunkGraphs.map((graph, index) => {
+                    return graph.execute(chunkInitialStates[index], chunkStartNodes[index], onStream, onError);
+                });
+                const chunkResults = yield Promise.all(chunkPromises);
+                results.push(...chunkResults);
+            }
+            return results;
+        });
+    }
 }
 exports.GraphEngine = GraphEngine;