@nicia-ai/typegraph 0.18.0 → 0.19.0

package/dist/index.cjs

@@ -3526,9 +3526,6 @@ function defineSubgraphProject(_graph) {
 }
 async function executeSubgraph(params) {
   const { options } = params;
-  if (options.edges.length === 0) {
-    return { nodes: [], edges: [] };
-  }
   const maxDepth = Math.min(
     options.maxDepth ?? DEFAULT_SUBGRAPH_MAX_DEPTH,
     MAX_EXPLICIT_RECURSIVE_DEPTH
@@ -3565,15 +3562,29 @@ async function executeSubgraph(params) {
     fetchSubgraphNodes(ctx, reachableCte, includedIdsCte, nodeProjectionPlan),
     fetchSubgraphEdges(ctx, reachableCte, includedIdsCte, edgeProjectionPlan)
   ]);
-  const nodes = nodeRows.map(
-    (row) => mapSubgraphNodeRow(row, nodeProjectionPlan)
-  );
-  const edges = edgeRows.map(
-    (row) => mapSubgraphEdgeRow(row, edgeProjectionPlan)
-  );
+  const nodesMap = /* @__PURE__ */ new Map();
+  for (const row of nodeRows) {
+    const node = mapSubgraphNodeRow(row, nodeProjectionPlan);
+    nodesMap.set(node.id, node);
+  }
+  const adjacency = /* @__PURE__ */ new Map();
+  const reverseAdjacency = /* @__PURE__ */ new Map();
+  for (const row of edgeRows) {
+    const edge = mapSubgraphEdgeRow(row, edgeProjectionPlan);
+    insertAdjacencyEntry(adjacency, edge.fromId, edge.kind, edge);
+    insertAdjacencyEntry(
+      reverseAdjacency,
+      edge.toId,
+      edge.kind,
+      edge
+    );
+  }
+  const root = nodesMap.get(ctx.rootId);
   return {
-    nodes,
-    edges
+    root,
+    nodes: nodesMap,
+    adjacency,
+    reverseAdjacency
   };
 }
 var introspectorCache = /* @__PURE__ */ new WeakMap();
@@ -3813,6 +3824,19 @@ function buildProjectedPropertyColumns(alias, plan, dialect) {
   }
   return columns;
 }
+function insertAdjacencyEntry(index, nodeId, edgeKind, edge) {
+  let kindMap = index.get(nodeId);
+  if (kindMap === void 0) {
+    kindMap = /* @__PURE__ */ new Map();
+    index.set(nodeId, kindMap);
+  }
+  const edges = kindMap.get(edgeKind);
+  if (edges === void 0) {
+    kindMap.set(edgeKind, [edge]);
+  } else {
+    edges.push(edge);
+  }
+}
 function applyProjectedFields(target, row, kindPlan) {
   for (const fieldPlan of kindPlan.propertyFields) {
     target[fieldPlan.field] = decodeSelectedValue(
@@ -11924,22 +11948,26 @@ var Store = class {
    * Extracts a typed subgraph by traversing from a root node.
    *
    * Performs a BFS traversal from `rootId` following the specified edge kinds,
-   * then returns all reachable nodes and the edges connecting them.
+   * returning an indexed result with adjacency maps for immediate traversal.
    *
    * @example
    * ```typescript
-   * const result = await store.subgraph(run.id, {
+   * const sg = await store.subgraph(run.id, {
    *   edges: ["has_task", "runs_agent", "uses_skill"],
    *   maxDepth: 4,
-   *   includeKinds: ["Run", "Task", "Agent", "Skill"],
    * });
    *
-   * for (const node of result.nodes) {
-   *   switch (node.kind) {
-   *     case "Task": console.log(node.name); break;
-   *     case "Agent": console.log(node.model); break;
-   *   }
-   * }
+   * // Root node (the traversal starting point)
+   * console.log(sg.root?.kind);
+   *
+   * // Lookup by ID
+   * const task = sg.nodes.get(taskId);
+   *
+   * // Forward adjacency: edges of a kind from a node
+   * const taskEdges = sg.adjacency.get(run.id)?.get("has_task") ?? [];
+   *
+   * // Reverse adjacency: edges of a kind pointing to a node
+   * const parentEdges = sg.reverseAdjacency.get(taskId)?.get("has_task") ?? [];
    * ```
    */
   async subgraph(rootId, options) {