@lucern/graph-primitives 1.0.17 → 1.0.19

package/dist/epistemicBeliefs.js

@@ -7,6 +7,7 @@ import { componentsGeneric, anyApi, internalMutationGeneric, mutationGeneric, qu
 import { isNodeType, getLayerForNodeType } from '@lucern/contracts/schema-helpers/spine/tables/epistemicNodes';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
 import { assertSchemaEnumValue } from '@lucern/contracts/schema-helpers/enumValidation';
+import { generateGlobalId } from '@lucern/contracts/ids';
 import { listAudienceRegistryRows } from '@lucern/access-control/audienceRegistry';
 
 // src/epistemicBeliefs.helpers.ts
@@ -2080,7 +2081,7 @@ function scopeFromTopicAnchor(topicNode) {
 }
 async function createRequiredBeliefTopicEdge(ctx, args) {
   const topicGlobalId = args.topicNode.globalId;
-  const edgeGlobalId = `edge:${args.beliefGlobalId}:${topicGlobalId}:scoped_by`;
+  const edgeGlobalId = `edge:${args.beliefGlobalId}:${topicGlobalId}:belongs_to`;
   const now = Date.now();
   const existing = await ctx.db.query("epistemicEdges").withIndex("by_globalId", (q) => q.eq("globalId", edgeGlobalId)).first();
   if (!existing) {
@@ -2090,7 +2091,7 @@ async function createRequiredBeliefTopicEdge(ctx, args) {
       toNodeId: String(args.topicNode._id),
       sourceGlobalId: args.beliefGlobalId,
       targetGlobalId: topicGlobalId,
-      edgeType: "scoped_by",
+      edgeType: "belongs_to",
       weight: 1,
       confidence: 1,
       context: "Belief creation topic anchor invariant.",
@@ -2114,7 +2115,7 @@ async function createRequiredBeliefTopicEdge(ctx, args) {
     globalId: edgeGlobalId,
     fromGlobalId: args.beliefGlobalId,
     toGlobalId: topicGlobalId,
-    edgeType: "scoped_by",
+    edgeType: "belongs_to",
     weight: 1,
     confidence: 1,
     context: "Belief creation topic anchor invariant.",
@@ -2158,18 +2159,6 @@ async function scheduleEmbeddingGeneration(args) {
   }
 }
 
-// src/globalId.ts
-function generateGlobalId() {
-  const bytes = new Uint8Array(16);
-  crypto.getRandomValues(bytes);
-  bytes[6] = bytes[6] & 15 | 64;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join(
-    ""
-  );
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
-}
-
 // src/epistemicBeliefs.core.ts
 var create = mutation({
   args: {
@@ -3674,6 +3663,39 @@ var getWithEvidence = query({
     };
   }
 });
+async function collectRelationshipNodeRefs(ctx, nodeId) {
+  const refs = /* @__PURE__ */ new Set([String(nodeId)]);
+  const node = await ctx.db.get(nodeId);
+  const globalId = typeof node?.globalId === "string" ? node.globalId.trim() : "";
+  if (globalId.length > 0) {
+    refs.add(globalId);
+  }
+  return [...refs];
+}
+function endpointMatches(q, fields, refs) {
+  return q.or(
+    ...fields.flatMap(
+      (field) => refs.map((ref) => q.eq(q.field(field), ref))
+    )
+  );
+}
+async function resolveRelationshipEndpoint(ctx, endpointId, globalEndpointId) {
+  const candidates = [endpointId, globalEndpointId].map((value) => typeof value === "string" ? value.trim() : "").filter((value, index, values) => value.length > 0 && values.indexOf(value) === index);
+  for (const candidate of candidates) {
+    try {
+      const direct = await ctx.db.get(candidate);
+      if (direct) {
+        return direct;
+      }
+    } catch {
+    }
+    const byGlobalId = await ctx.db.query("epistemicNodes").withIndex("by_globalId", (q) => q.eq("globalId", candidate)).first();
+    if (byGlobalId) {
+      return byGlobalId;
+    }
+  }
+  return null;
+}
 var getRelationships = query({
   args: {
     nodeId: v.id("epistemicNodes"),
@@ -3688,17 +3710,38 @@ var getRelationships = query({
       incoming: [],
       outgoing: []
     };
+    const nodeRefs = await collectRelationshipNodeRefs(ctx, args.nodeId);
     if (direction === "in" || direction === "both") {
-      const inEdges = await ctx.db.query("epistemicEdges").filter((q) => q.eq(q.field("toNodeId"), args.nodeId)).collect();
+      const inEdges = await ctx.db.query("epistemicEdges").filter(
+        (q) => endpointMatches(
+          q,
+          ["toNodeId", "targetGlobalId", "toGlobalId", "toUuid"],
+          nodeRefs
+        )
+      ).collect();
       for (const edge of inEdges) {
-        const sourceNode = await ctx.db.get(edge.fromNodeId);
+        const sourceNode = await resolveRelationshipEndpoint(
+          ctx,
+          edge.fromNodeId,
+          edge.sourceGlobalId ?? edge.fromGlobalId ?? edge.fromUuid
+        );
         results.incoming.push({ edge, node: sourceNode });
       }
     }
     if (direction === "out" || direction === "both") {
-      const outEdges = await ctx.db.query("epistemicEdges").filter((q) => q.eq(q.field("fromNodeId"), args.nodeId)).collect();
+      const outEdges = await ctx.db.query("epistemicEdges").filter(
+        (q) => endpointMatches(
+          q,
+          ["fromNodeId", "sourceGlobalId", "fromGlobalId", "fromUuid"],
+          nodeRefs
+        )
+      ).collect();
       for (const edge of outEdges) {
-        const targetNode = edge.toNodeId ? await ctx.db.get(edge.toNodeId) : null;
+        const targetNode = await resolveRelationshipEndpoint(
+          ctx,
+          edge.toNodeId,
+          edge.targetGlobalId ?? edge.toGlobalId ?? edge.toUuid
+        );
         results.outgoing.push({ edge, node: targetNode });
       }
     }