@nicia-ai/typegraph 0.37.0 → 0.37.1

package/dist/{chunk-552KNYQJ.js → chunk-GA4TT3DH.js}

@@ -10736,6 +10736,13 @@ function buildCompileTimeReferentIndex(graph, runtimeEdgeNames) {
 // src/store/algorithms/context.ts
 var DEFAULT_ALGORITHM_MAX_HOPS = 10;
 var DEFAULT_NEIGHBOR_DEPTH = 1;
+function pickTemporalOptions(options) {
+  return {
+    ...options.temporalMode === void 0 ? {} : { temporalMode: options.temporalMode },
+    ...options.asOf === void 0 ? {} : { asOf: options.asOf },
+    ...options.recordedAsOf === void 0 ? {} : { recordedAsOf: options.recordedAsOf }
+  };
+}
 function resolveTemporalOptions(ctx, options) {
   const { valid } = resolveReadCoordinate(
     options.temporalMode ?? ctx.defaultTemporalMode,
@@ -10850,6 +10857,11 @@ function compileDirectionFilter(ctx, direction, nodeId, nodesTable) {
     }
   }
 }
+function frontierIndexIdentifier(context) {
+  return sql.identifier(
+    `typegraph_iterative_${context.runId.replaceAll("-", "_")}_frontier`
+  );
+}
 var DEFAULT_MAX_BIND_PARAMETERS = 999;
 var RESERVED_TEMPORAL_BIND_PARAMETERS_PER_BRANCH = 12;
 var RESERVED_WEIGHT_BIND_PARAMETERS_PER_BRANCH = 4;
@@ -11041,147 +11053,90 @@ function nodeIdentityKeyFromRow(id, kind) {
   return nodeIdentityKey({ id, kind });
 }
 function compareNodeIdentity(left, right) {
-  return compareStrings(left.id, right.id) || compareStrings(left.kind, right.kind);
+  return compareCodePoints(left.id, right.id) || compareCodePoints(left.kind, right.kind);
 }
-function compileExpansionQuery(operation, workingSet, direction, edgeKinds) {
-  const workingValues = sql.join(
-    workingSet.map((node) => sql`(${node.id}, ${node.kind})`),
-    sql`, `
-  );
-  const workingCte = sql`WITH working_set(node_id, node_kind) AS (VALUES ${workingValues})`;
+var OUTGOING_DIRECTION_FIELDS = {
+  joinField: "from_id",
+  joinKindField: "from_kind",
+  targetField: "to_id",
+  targetKindField: "to_kind"
+};
+var INCOMING_DIRECTION_FIELDS = {
+  joinField: "to_id",
+  joinKindField: "to_kind",
+  targetField: "from_id",
+  targetKindField: "from_kind"
+};
+function fieldsForDirection(direction) {
   switch (direction) {
     case "out": {
-      return sql`${workingCte} ${compileDirectionalExpansion(operation, sql`working_set`, sql`TRUE`, edgeKinds, "from_id", "from_kind", "to_id", "to_kind")}`;
+      return [OUTGOING_DIRECTION_FIELDS];
     }
     case "in": {
-      return sql`${workingCte} ${compileDirectionalExpansion(operation, sql`working_set`, sql`TRUE`, edgeKinds, "to_id", "to_kind", "from_id", "from_kind")}`;
+      return [INCOMING_DIRECTION_FIELDS];
     }
     case "both": {
-      const outgoing = compileDirectionalExpansion(
-        operation,
-        sql`working_set`,
-        sql`TRUE`,
-        edgeKinds,
-        "from_id",
-        "from_kind",
-        "to_id",
-        "to_kind"
-      );
-      const incoming = compileDirectionalExpansion(
-        operation,
-        sql`working_set`,
-        sql`TRUE`,
-        edgeKinds,
-        "to_id",
-        "to_kind",
-        "from_id",
-        "from_kind"
-      );
-      return sql`${workingCte} ${outgoing} UNION ALL ${incoming}`;
+      return [OUTGOING_DIRECTION_FIELDS, INCOMING_DIRECTION_FIELDS];
     }
   }
 }
+function compileDirectionUnion(direction, compileDirection) {
+  return sql.join(
+    fieldsForDirection(direction).map((fields) => compileDirection(fields)),
+    sql` UNION ALL `
+  );
+}
+function compileExpansionQuery(operation, workingSet, direction, edgeKinds) {
+  const workingValues = sql.join(
+    workingSet.map((node) => sql`(${node.id}, ${node.kind})`),
+    sql`, `
+  );
+  const workingCte = sql`WITH working_set(node_id, node_kind) AS (VALUES ${workingValues})`;
+  const expansion = compileDirectionUnion(
+    direction,
+    (fields) => compileDirectionalExpansion(
+      operation,
+      sql`working_set`,
+      sql`TRUE`,
+      edgeKinds,
+      fields.joinField,
+      fields.joinKindField,
+      fields.targetField,
+      fields.targetKindField
+    )
+  );
+  return sql`${workingCte} ${expansion}`;
+}
 function compileWorkingTableExpansion(operation, workingTable, sourceFilter, direction, edgeKinds) {
-  switch (direction) {
-    case "out": {
-      return compileDirectionalExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "from_id",
-        "from_kind",
-        "to_id",
-        "to_kind"
-      );
-    }
-    case "in": {
-      return compileDirectionalExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "to_id",
-        "to_kind",
-        "from_id",
-        "from_kind"
-      );
-    }
-    case "both": {
-      const outgoing = compileDirectionalExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "from_id",
-        "from_kind",
-        "to_id",
-        "to_kind"
-      );
-      const incoming = compileDirectionalExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "to_id",
-        "to_kind",
-        "from_id",
-        "from_kind"
-      );
-      return sql`${outgoing} UNION ALL ${incoming}`;
-    }
-  }
+  return compileDirectionUnion(
+    direction,
+    (fields) => compileDirectionalExpansion(
+      operation,
+      workingTable,
+      sourceFilter,
+      edgeKinds,
+      fields.joinField,
+      fields.joinKindField,
+      fields.targetField,
+      fields.targetKindField
+    )
+  );
 }
-function compileWorkingTableEdgeExpansion(operation, workingTable, sourceFilter, direction, edgeKinds) {
-  switch (direction) {
-    case "out": {
-      return compileDirectionalEdgeExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "from_id",
-        "from_kind",
-        "to_id",
-        "to_kind"
-      );
-    }
-    case "in": {
-      return compileDirectionalEdgeExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "to_id",
-        "to_kind",
-        "from_id",
-        "from_kind"
-      );
-    }
-    case "both": {
-      const outgoing = compileDirectionalEdgeExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "from_id",
-        "from_kind",
-        "to_id",
-        "to_kind"
-      );
-      const incoming = compileDirectionalEdgeExpansion(
-        operation,
-        workingTable,
-        sourceFilter,
-        edgeKinds,
-        "to_id",
-        "to_kind",
-        "from_id",
-        "from_kind"
-      );
-      return sql`${outgoing} UNION ALL ${incoming}`;
-    }
-  }
+function compileWorkingTableEdgeExpansion(operation, workingTable, sourceFilter, direction, edgeKinds, sourceProjection) {
+  return compileDirectionUnion(
+    direction,
+    (fields) => compileDirectionalEdgeExpansion(
+      operation,
+      workingTable,
+      sourceFilter,
+      edgeKinds,
+      fields.joinField,
+      fields.joinKindField,
+      fields.targetField,
+      fields.targetKindField,
+      sourceProjection
+    )
+  );
 }
 function compileDirectionalExpansion(operation, workingRelation, sourceFilter, edgeKinds, joinField, joinKindField, targetField, targetKindField) {
   const edgeExpansion = compileDirectionalEdgeExpansion(
@@ -11197,10 +11152,11 @@ function compileDirectionalExpansion(operation, workingRelation, sourceFilter, e
   const weightColumn = operation.weightExpression === void 0 ? sql`` : sql`, expanded.weight`;
   return sql`SELECT expanded.source_id, expanded.source_kind, n.id AS target_id, n.kind AS target_kind${weightColumn} FROM (${edgeExpansion}) expanded JOIN ${operation.schema.nodesTable} n ON n.graph_id = ${operation.ctx.graphId} AND n.id = expanded.target_id AND n.kind = expanded.target_kind WHERE ${operation.nodeTemporalFilter}`;
 }
-function compileDirectionalEdgeExpansion(operation, workingRelation, sourceFilter, edgeKinds, joinField, joinKindField, targetField, targetKindField) {
+function compileDirectionalEdgeExpansion(operation, workingRelation, sourceFilter, edgeKinds, joinField, joinKindField, targetField, targetKindField, sourceProjection) {
   const edgeKindFilter = compileKindFilter(sql.raw("e.kind"), edgeKinds);
   const weightColumn = operation.weightExpression === void 0 ? sql`` : sql`, ${operation.weightExpression} AS weight`;
-  return sql`SELECT w.node_id AS source_id, w.node_kind AS source_kind, e.${sql.raw(targetField)} AS target_id, e.${sql.raw(targetKindField)} AS target_kind${weightColumn} FROM ${workingRelation} w JOIN ${operation.schema.edgesTable} e ON e.${sql.raw(joinField)} = w.node_id AND e.${sql.raw(joinKindField)} = w.node_kind AND e.graph_id = ${operation.ctx.graphId} WHERE ${sourceFilter} AND ${edgeKindFilter} AND ${operation.edgeTemporalFilter}`;
+  const sourceColumns = sourceProjection === void 0 ? sql`` : sql`, ${sourceProjection}`;
+  return sql`SELECT w.node_id AS source_id, w.node_kind AS source_kind${sourceColumns}, e.${sql.raw(targetField)} AS target_id, e.${sql.raw(targetKindField)} AS target_kind${weightColumn} FROM ${workingRelation} w JOIN ${operation.schema.edgesTable} e ON e.${sql.raw(joinField)} = w.node_id AND e.${sql.raw(joinKindField)} = w.node_kind AND e.graph_id = ${operation.ctx.graphId} WHERE ${sourceFilter} AND ${edgeKindFilter} AND ${operation.edgeTemporalFilter}`;
 }
 function chunkValues(values, chunkSize) {
   const chunks = [];
@@ -11283,7 +11239,7 @@ function compileWeightExpression(dialect, weightProperty, defaultWeight) {
   return defaultWeight === void 0 ? extracted : sql`COALESCE(${extracted}, ${defaultWeight})`;
 }
 function supportsTemporaryIteration(ctx) {
-  return ctx.backend.capabilities.transactions && ctx.backend.capabilities.returning !== false && ctx.backend.executeTemporaryStatement !== void 0;
+  return ctx.backend.capabilities.transactions && ctx.backend.capabilities.graphAnalytics?.supported !== false && ctx.backend.capabilities.returning !== false && ctx.backend.executeTemporaryStatement !== void 0;
 }
 function requireTemporaryStatements(backend) {
   if (backend.executeTemporaryStatement === void 0) {
@@ -11467,6 +11423,11 @@ async function expandWorkingTableRound(context, side, currentDepth, nextDepth, d
   const oppositeSide = side === "forward" ? "reverse" : "forward";
   let insertedCount = 0;
   let meeting;
+  const { dialect } = context.operation.ctx;
+  const targetKind = dialect.binaryText(sql`expanded.target_kind`);
+  const targetId = dialect.binaryText(sql`expanded.target_id`);
+  const sourceId = dialect.binaryText(sql`expanded.source_id`);
+  const sourceKind = dialect.binaryText(sql`expanded.source_kind`);
   for (const edgeKinds of context.operation.edgeKindChunks) {
     const sourceFilter = sql`
       w.graph_id = ${context.graphId}
@@ -11502,8 +11463,8 @@ async function expandWorkingTableRound(context, side, currentDepth, nextDepth, d
         FROM (
           SELECT expanded.*,
             ROW_NUMBER() OVER (
-              PARTITION BY expanded.target_kind, expanded.target_id
-              ORDER BY expanded.source_id, expanded.source_kind
+              PARTITION BY ${targetKind}, ${targetId}
+              ORDER BY ${sourceId}, ${sourceKind}
             ) AS candidate_rank
           FROM (${expansion}) expanded
         ) ranked
@@ -11606,7 +11567,6 @@ async function readWorkingRows(context, side) {
       WHERE graph_id = ${context.graphId}
         AND run_id = ${context.runId}
         AND ${sideFilter}
-      ORDER BY side, depth, node_id, node_kind
     `)
   );
 }
@@ -11738,8 +11698,12 @@ function findMeetingNodeKey(candidates, activeVisited, oppositeVisited) {
     const active = activeVisited.get(key);
     const opposite = oppositeVisited.get(key);
     if (active === void 0 || opposite === void 0) continue;
-    const meeting = { key, depth: active.depth + opposite.depth };
-    if (best === void 0 || meeting.depth < best.depth || meeting.depth === best.depth && compareStrings(meeting.key, best.key) < 0) {
+    const meeting = {
+      key,
+      node: { id: candidate.id, kind: candidate.kind },
+      depth: active.depth + opposite.depth
+    };
+    if (best === void 0 || meeting.depth < best.depth || meeting.depth === best.depth && compareNodeIdentity(meeting.node, best.node) < 0) {
       best = meeting;
     }
   }
@@ -11831,13 +11795,7 @@ async function executeNeighbors(ctx, sourceId, options) {
     maxHops: depth,
     direction: options.direction ?? "out",
     cyclePolicy: options.cyclePolicy ?? "prevent",
-    ...options.temporalMode !== void 0 && {
-      temporalMode: options.temporalMode
-    },
-    ...options.asOf !== void 0 && { asOf: options.asOf },
-    ...options.recordedAsOf !== void 0 && {
-      recordedAsOf: options.recordedAsOf
-    },
+    ...pickTemporalOptions(options),
     ...options.workingMemory !== void 0 && {
       workingMemory: options.workingMemory
     },
@@ -11870,9 +11828,7 @@ async function executeWeaklyConnectedComponents(ctx, options) {
   const traversalOptions = {
     edges: options.edges,
     direction: "both",
-    ...options.temporalMode === void 0 ? {} : { temporalMode: options.temporalMode },
-    ...options.asOf === void 0 ? {} : { asOf: options.asOf },
-    ...options.recordedAsOf === void 0 ? {} : { recordedAsOf: options.recordedAsOf },
+    ...pickTemporalOptions(options),
     ...options.workingMemory === void 0 ? {} : { workingMemory: options.workingMemory }
   };
   return runIterativeGraphOperation(ctx, traversalOptions, {
@@ -11913,6 +11869,7 @@ function createWorkingTable2(context) {
       label_kind TEXT NOT NULL,
       next_label_id TEXT NOT NULL,
       next_label_kind TEXT NOT NULL,
+      improved_round INTEGER NOT NULL,
       PRIMARY KEY (graph_id, run_id, node_kind, node_id)
     )
   `;
@@ -11923,14 +11880,18 @@ async function initializeWorkingTable(context, nodeKinds) {
   await context.executeTemporary(sql`
     INSERT INTO ${workingTable}
       (graph_id, run_id, node_id, node_kind, label_id, label_kind,
-       next_label_id, next_label_kind)
+       next_label_id, next_label_kind, improved_round)
     SELECT
-      ${graphId}, ${runId}, n.id, n.kind, n.id, n.kind, n.id, n.kind
+      ${graphId}, ${runId}, n.id, n.kind, n.id, n.kind, n.id, n.kind, 0
     FROM ${operation.schema.nodesTable} n
     WHERE n.graph_id = ${graphId}
       AND ${nodeKindFilter}
       AND ${operation.nodeTemporalFilter}
   `);
+  await context.executeTemporary(sql`
+    CREATE INDEX ${frontierIndexIdentifier(context)}
+    ON ${workingTable} (graph_id, run_id, improved_round)
+  `);
   const rows = await context.backend.execute(
     asCompiledRowsSql(sql`
       SELECT COUNT(*) AS count
@@ -11941,32 +11902,29 @@ async function initializeWorkingTable(context, nodeKinds) {
   const workingTableSize = Number(rows[0]?.count ?? 0);
   return { changedCount: workingTableSize, workingTableSize };
 }
-async function runLabelPropagationRound(context, state) {
-  await resetNextLabels(context);
+async function runLabelPropagationRound(context, state, iteration) {
   for (const edgeKinds of context.operation.edgeKindChunks) {
-    await propagateChunkLabels(context, edgeKinds);
+    await propagateChunkLabels(context, edgeKinds, iteration);
   }
-  const changedRows = await applyNextLabels(context);
+  const changedRows = await applyNextLabels(context, iteration);
   return {
     changedCount: changedRows.length,
     workingTableSize: state.workingTableSize
   };
 }
-async function resetNextLabels(context) {
-  await context.executeTemporary(sql`
-    UPDATE ${context.workingTable}
-    SET next_label_id = label_id, next_label_kind = label_kind
-    WHERE graph_id = ${context.graphId} AND run_id = ${context.runId}
-  `);
-}
-async function propagateChunkLabels(context, edgeKinds) {
+async function propagateChunkLabels(context, edgeKinds, iteration) {
   const { operation, workingTable, graphId, runId } = context;
   const expansion = compileWorkingTableEdgeExpansion(
     operation,
     workingTable,
-    sql`w.graph_id = ${graphId} AND w.run_id = ${runId}`,
+    sql`
+      w.graph_id = ${graphId}
+      AND w.run_id = ${runId}
+      AND w.improved_round = ${iteration - 1}
+    `,
     "both",
-    edgeKinds
+    edgeKinds,
+    sql`w.label_id AS source_label_id, w.label_kind AS source_label_kind`
   );
   const candidateId = operation.ctx.dialect.binaryText(sql`ranked.label_id`);
   const candidateKind = operation.ctx.dialect.binaryText(
@@ -11985,14 +11943,9 @@ async function propagateChunkLabels(context, edgeKinds) {
       SELECT
         expanded.target_id,
         expanded.target_kind,
-        source.label_id,
-        source.label_kind
+        expanded.source_label_id AS label_id,
+        expanded.source_label_kind AS label_kind
       FROM (${expansion}) expanded
-      JOIN ${workingTable} source
-        ON source.graph_id = ${graphId}
-        AND source.run_id = ${runId}
-        AND source.node_id = expanded.source_id
-        AND source.node_kind = expanded.source_kind
       JOIN ${workingTable} scoped_target
         ON scoped_target.graph_id = ${graphId}
         AND scoped_target.run_id = ${runId}
@@ -12028,11 +11981,13 @@ async function propagateChunkLabels(context, edgeKinds) {
       )
   `);
 }
-function applyNextLabels(context) {
+function applyNextLabels(context, iteration) {
   return context.backend.execute(
     asCompiledRowsSql(sql`
       UPDATE ${context.workingTable}
-      SET label_id = next_label_id, label_kind = next_label_kind
+      SET label_id = next_label_id,
+          label_kind = next_label_kind,
+          improved_round = ${iteration}
       WHERE graph_id = ${context.graphId}
         AND run_id = ${context.runId}
         AND (
@@ -12069,10 +12024,7 @@ async function extractMemberships(context) {
     componentId: row.component_id,
     componentKind: row.component_kind,
     size: Number(row.component_size)
-  })).toSorted(compareMemberships);
-}
-function compareMemberships(left, right) {
-  return compareCodePoints(left.componentId, right.componentId) || compareCodePoints(left.componentKind, right.componentKind) || compareCodePoints(left.id, right.id) || compareCodePoints(left.kind, right.kind);
+  }));
 }
 var DEFAULT_WEIGHTED_SHORTEST_PATH_MAX_ITERATIONS = 1e3;
 var WEIGHTED_ALGORITHM_NAME = "weightedShortestPath";
@@ -12189,9 +12141,6 @@ function formatWeightValue(value) {
   }
   return JSON.stringify(value);
 }
-function compareNodeIdentityCodePoints(left, right) {
-  return compareCodePoints(left.id, right.id) || compareCodePoints(left.kind, right.kind);
-}
 async function findWeightedShortestPathInWorkingTable(ctx, sourceId, targetId, maxIterations, options) {
   return runIterativeGraphOperation(ctx, options, {
     algorithm: WEIGHTED_ALGORITHM_NAME,
@@ -12247,11 +12196,6 @@ async function findWeightedShortestPathInWorkingTable(ctx, sourceId, targetId, m
     }
   });
 }
-function frontierIndexIdentifier(context) {
-  return sql.identifier(
-    `typegraph_iterative_${context.runId.replaceAll("-", "_")}_frontier`
-  );
-}
 async function hasVisibleNode(operation, nodeId) {
   const rows = await operation.backend.execute(
     asCompiledRowsSql(sql`
@@ -12420,7 +12364,7 @@ async function findWeightedSelfPath(ctx, nodeId, options) {
     );
     const nodes = await fetchVisibleWorkingNodes(operation, [nodeId]);
     const node = nodes.toSorted(
-      (left, right) => compareNodeIdentityCodePoints(left, right)
+      (left, right) => compareNodeIdentity(left, right)
     )[0];
     if (node === void 0) return;
     return { nodes: [node], depth: 0, totalWeight: 0 };
@@ -12496,7 +12440,7 @@ async function findWeightedShortestPathInline(ctx, sourceId, targetId, maxIterat
         }
       }
       frontier = improved.toSorted(
-        (left, right) => compareNodeIdentityCodePoints(left, right)
+        (left, right) => compareNodeIdentity(left, right)
       );
     }
     return buildWeightedPathResult(settled, targetId);
@@ -12508,7 +12452,7 @@ function reduceWeightedCandidate(existing, expansion, settled) {
   const sourceEntry = settled.get(nodeIdentityKey(expansion.source));
   if (sourceEntry === void 0) return existing;
   const candidateDistance = sourceEntry.distance + weight;
-  if (existing !== void 0 && (existing.distance < candidateDistance || existing.distance === candidateDistance && compareNodeIdentityCodePoints(
+  if (existing !== void 0 && (existing.distance < candidateDistance || existing.distance === candidateDistance && compareNodeIdentity(
     { id: existing.parentId, kind: existing.parentKind },
     expansion.source
   ) <= 0)) {
@@ -12527,7 +12471,7 @@ function buildWeightedPathResult(visited, targetId) {
   let target;
   for (const node of visited.values()) {
     if (node.id !== targetId) continue;
-    if (target === void 0 || node.distance < target.distance || node.distance === target.distance && compareNodeIdentityCodePoints(node, target) < 0) {
+    if (target === void 0 || node.distance < target.distance || node.distance === target.distance && compareNodeIdentity(node, target) < 0) {
       target = node;
     }
   }
@@ -17755,5 +17699,5 @@ async function createVerifiedStore(graph, backend, options) {
 }
 
 export { ExecutableAggregateQuery, ExecutableQuery, MAX_EXPLICIT_RECURSIVE_DEPTH, MAX_RECURSIVE_DEPTH, PreparedQuery, QueryBuilder, RecordedStoreView, StoreSearch, StoreView, UnionableQuery, avg, composeFragments, count, countDistinct, countDistinctEdges, countEdges, createFragment, createQueryBuilder, createStore, createStoreWithSchema, createVerifiedStore, defineSubgraphProject, field, having, havingEq, havingGt, havingGte, havingLt, havingLte, limitFragment, max, min, offsetFragment, orderByFragment, sum };
-//# sourceMappingURL=chunk-552KNYQJ.js.map
-//# sourceMappingURL=chunk-552KNYQJ.js.map
+//# sourceMappingURL=chunk-GA4TT3DH.js.map
+//# sourceMappingURL=chunk-GA4TT3DH.js.map