@lucern/graph-sync 1.0.28 → 1.0.30

package/dist/neo4jSync.js

@@ -1,11 +1,14 @@
 "use node";
-import { v } from 'convex/values';
-import { NODE_TYPE_TO_LABEL, EDGE_TYPE_TO_REL } from '@lucern/graph-primitives/graphTypes';
 import { permissiveReturn } from '@lucern/contracts/schema-helpers/validators';
-import { anyApi, internalActionGeneric } from 'convex/server';
+import { NODE_TYPE_TO_LABEL, EDGE_TYPE_TO_REL } from '@lucern/graph-primitives/graphTypes';
+import { v } from 'convex/values';
+import { unsafeConvexAnyApi } from '@lucern/contracts/convex/unsafeAnyApi';
+import { internalActionGeneric } from 'convex/server';
 import neo4j from 'neo4j-driver';
 
-var internal = anyApi;
+var internal = unsafeConvexAnyApi(
+  "graph-sync top-level module bundle lacks a committed Convex _generated/api surface"
+);
 var internalAction = internalActionGeneric;
 var VALID_NODE_LABELS = /* @__PURE__ */ new Set([
   // Ontological
@@ -98,7 +101,7 @@ function getDriver() {
     const uri = process.env.NEO4J_URI;
     const user = process.env.NEO4J_USER;
     const password = process.env.NEO4J_PASSWORD;
-    if (!uri || !user || !password) {
+    if (!(uri && user && password)) {
       throw new Error(
         "[Neo4j Driver] Missing credentials. Set NEO4J_URI, NEO4J_USER, NEO4J_PASSWORD via `npx convex env set`"
       );
@@ -159,9 +162,7 @@ async function runWriteTransaction(query, params = {}, timeoutMs = DEFAULT_QUERY
   try {
     const neo4jParams = toNeo4jParams(params);
     const result = await session.executeWrite(
-      async (tx) => {
-        return await tx.run(query, neo4jParams);
-      },
+      async (tx) => await tx.run(query, neo4jParams),
       { timeout: timeoutMs }
     );
     return result.records.map((record) => {
@@ -339,6 +340,9 @@ function convertNeo4jValue(value) {
 }
 
 // src/neo4jSync.ts
+var graphSyncHelpers = internal.neo4jSyncHelpers;
+var graphSyncActions = internal.neo4jSync;
+var graphSyncEdgeApi = internal.neo4jEdgeAPI;
 function buildSyncResponse(entityType, operation, fields) {
   return {
     entityType,
@@ -359,53 +363,100 @@ function buildSyncFailure(entityType, operation, error, fields) {
     ...fields
   });
 }
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readString(value) {
+  return typeof value === "string" ? value : "";
+}
+function readFirstString(...values) {
+  for (const value of values) {
+    const stringValue = readString(value);
+    if (stringValue.length > 0) {
+      return stringValue;
+    }
+  }
+  return "";
+}
+function readArrayLength(value) {
+  return Array.isArray(value) ? value.length : 0;
+}
+function nodeSyncEventType(operation) {
+  return operation === "delete" ? "node_deleted" : "node_updated";
+}
+function edgeSyncEventType(operation) {
+  return operation === "delete" ? "edge_deleted" : "edge_created";
+}
+function readNeo4jEndpointFailure(edge, operation) {
+  if (edge.fromGlobalId && edge.toGlobalId) {
+    return null;
+  }
+  console.warn(
+    "[Neo4j Sync] Edge missing fromGlobalId or toGlobalId, skipping"
+  );
+  return buildSyncFailure(
+    "edge",
+    operation,
+    "Edge missing connected node globalIds",
+    {
+      skippedReason: "edge_endpoint_missing"
+    }
+  );
+}
+async function applyEdgeOperation(edge, operation, edgeId) {
+  const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
+  if (operation === "delete") {
+    await deleteEdge(edge.globalId);
+    console.log(`[Neo4j Sync] Deleted edge ${edge.globalId}`);
+    return relType;
+  }
+  await upsertEdge(
+    relType,
+    edge.globalId,
+    edge.fromGlobalId ?? "",
+    edge.toGlobalId ?? "",
+    {
+      ...buildEdgeProperties(edge),
+      convexId: edgeId
+    }
+  );
+  console.log(`[Neo4j Sync] Upserted edge ${edge.globalId} as ${relType}`);
+  return relType;
+}
 function buildNodeProperties(node) {
-  const metadata = node.metadata || {};
-  const pillar = metadata.pillar || metadata.topic || "";
-  const stage = metadata.stage || metadata.beliefStage || "";
-  const criticality = metadata.criticality || "";
-  const synthesizedFrom = metadata.synthesizedFrom || [];
-  const epistemicStatus = node.epistemicStatus || "";
-  const methodology = node.methodology || "";
-  const informationAsymmetry = node.informationAsymmetry || "";
-  const questionType = node.questionType || "";
-  const questionPriority = node.questionPriority || "";
-  const answerQuality = node.answerQuality || "";
-  const reversibility = node.reversibility || "";
-  const predictionMeta = node.predictionMeta;
+  const metadata = readRecord(node.metadata);
+  const predictionMeta = readRecord(node.predictionMeta);
   return {
-    convexId: node._id,
+    answerQuality: readString(node.answerQuality),
     canonicalText: node.canonicalText || "",
-    title: node.title || "",
-    status: node.status || "active",
-    subtype: node.subtype || "",
-    domain: node.domain || "",
     confidence: node.confidence || 0,
-    verificationStatus: node.verificationStatus || "unverified",
-    sourceType: node.sourceType || "unknown",
+    convexId: node._id,
     createdAt: node.createdAt,
-    updatedAt: node.updatedAt || Date.now(),
     createdBy: node.createdBy || "",
-    nodeType: node.nodeType,
+    criticality: readString(metadata.criticality),
+    domain: node.domain || "",
     epistemicLayer: node.epistemicLayer || "",
-    // Project and metadata fields
+    epistemicStatus: readString(node.epistemicStatus),
+    expectedBy: predictionMeta?.expectedBy ? String(predictionMeta.expectedBy) : "",
+    informationAsymmetry: readString(node.informationAsymmetry),
+    isPrediction: predictionMeta?.isPrediction ? "true" : "false",
+    methodology: readString(node.methodology),
+    nodeType: node.nodeType,
+    pillar: readFirstString(metadata.pillar, metadata.topic),
     projectId: node.projectId || "",
+    questionPriority: readString(node.questionPriority),
+    questionType: readString(node.questionType),
+    reversibility: readString(node.reversibility),
+    sourceType: node.sourceType || "unknown",
+    stage: readFirstString(metadata.stage, metadata.beliefStage),
+    status: node.status || "active",
+    subtype: node.subtype || "",
+    synthesizedFromCount: readArrayLength(metadata.synthesizedFrom),
     tenantId: node.tenantId || "",
-    workspaceId: node.workspaceId || "",
-    pillar,
-    stage,
-    criticality,
-    synthesizedFromCount: synthesizedFrom.length,
-    // Classification fields (Logic Machine)
-    epistemicStatus,
-    methodology,
-    informationAsymmetry,
-    questionType,
-    questionPriority,
-    answerQuality,
-    reversibility,
-    isPrediction: predictionMeta?.isPrediction ? "true" : "false",
-    expectedBy: predictionMeta?.expectedBy ? String(predictionMeta.expectedBy) : ""
+    title: node.title || "",
+    updatedAt: node.updatedAt || Date.now(),
+    verificationStatus: node.verificationStatus || "unverified",
+    workspaceId: node.workspaceId || ""
   };
 }
 function buildEdgeProperties(edge) {
@@ -445,7 +496,7 @@ var syncNodeToNeo4j = internalAction({
         skippedReason: "credentials_missing"
       });
     }
-    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+    const node = await ctx.runQuery(graphSyncHelpers.getNodeForSync, {
       nodeId: args.nodeId
     });
     if (!node) {
@@ -468,7 +519,7 @@ var syncNodeToNeo4j = internalAction({
       } else {
         const props = buildNodeProperties(node);
         const embedding = await ctx.runQuery(
-          internal.neo4jSyncHelpers.getEmbeddingForSync,
+          graphSyncHelpers.getEmbeddingForSync,
           { nodeId: args.nodeId }
         );
         if (embedding) {
@@ -479,8 +530,8 @@ var syncNodeToNeo4j = internalAction({
           `[Neo4j Sync] Upserted node ${node.globalId} as ${label} with projectId=${node.projectId}` + (embedding ? ` (with ${embedding.length}-dim embedding)` : "")
         );
       }
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
-        eventType: args.operation === "delete" ? "node_deleted" : node ? "node_updated" : "node_created",
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
+        eventType: nodeSyncEventType(args.operation),
         entityId: args.nodeId,
         entityType: node.nodeType,
         status: "success"
@@ -489,14 +540,14 @@ var syncNodeToNeo4j = internalAction({
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : "Unknown error";
       console.error("[Neo4j Sync] Node sync error:", errorMsg);
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
         eventType: args.operation === "delete" ? "node_deleted" : "node_updated",
         entityId: args.nodeId,
         entityType: node.nodeType,
         status: "failed",
         error: errorMsg
       });
-      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+      await ctx.runMutation(graphSyncHelpers.queueForRetry, {
         entityType: "node",
         entityId: args.nodeId,
         operation: args.operation,
@@ -522,7 +573,7 @@ var syncEdgeToNeo4j = internalAction({
         skippedReason: "credentials_missing"
       });
     }
-    const edge = await ctx.runQuery(internal.neo4jSyncHelpers.getEdgeForSync, {
+    const edge = await ctx.runQuery(graphSyncHelpers.getEdgeForSync, {
       edgeId: args.edgeId
     });
     if (!edge) {
@@ -537,53 +588,18 @@ var syncEdgeToNeo4j = internalAction({
         skippedReason: "source_edge_missing"
       });
     }
-    if (!edge.fromGlobalId || !edge.toGlobalId) {
-      console.warn(
-        "[Neo4j Sync] Edge missing fromGlobalId or toGlobalId, skipping"
-      );
-      return buildSyncFailure(
-        "edge",
-        args.operation,
-        "Edge missing connected node globalIds",
-        {
-          skippedReason: "edge_endpoint_missing"
-        }
-      );
+    const edgeForSync = edge;
+    const endpointFailure = readNeo4jEndpointFailure(
+      edgeForSync,
+      args.operation
+    );
+    if (endpointFailure) {
+      return endpointFailure;
     }
-    const relType = EDGE_TYPE_TO_REL[edge.edgeType] || edge.edgeType.toUpperCase();
     try {
-      if (args.operation === "delete") {
-        await deleteEdge(edge.globalId);
-        console.log(`[Neo4j Sync] Deleted edge ${edge.globalId}`);
-      } else {
-        await upsertEdge(
-          relType,
-          edge.globalId,
-          edge.fromGlobalId,
-          edge.toGlobalId,
-          {
-            convexId: args.edgeId,
-            weight: edge.weight || 1,
-            confidence: edge.confidence || 0,
-            context: edge.context || "",
-            derivationType: edge.derivationType || "",
-            createdAt: edge.createdAt,
-            createdBy: edge.createdBy || "",
-            edgeType: edge.edgeType,
-            fromLayer: edge.fromLayer || "",
-            toLayer: edge.toLayer || "",
-            // Classification fields (Logic Machine)
-            reasoningMethod: edge.reasoningMethod || "",
-            logicalRole: edge.logicalRole || "",
-            temporalClass: edge.temporalClass || ""
-          }
-        );
-        console.log(
-          `[Neo4j Sync] Upserted edge ${edge.globalId} as ${relType}`
-        );
-      }
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
-        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+      await applyEdgeOperation(edgeForSync, args.operation, args.edgeId);
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
+        eventType: edgeSyncEventType(args.operation),
         entityId: args.edgeId,
         entityType: edge.edgeType,
         status: "success"
@@ -592,14 +608,14 @@ var syncEdgeToNeo4j = internalAction({
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : "Unknown error";
       console.error("[Neo4j Sync] Edge sync error:", errorMsg);
-      await ctx.runMutation(internal.neo4jSyncHelpers.logSyncEvent, {
-        eventType: args.operation === "delete" ? "edge_deleted" : "edge_created",
+      await ctx.runMutation(graphSyncHelpers.logSyncEvent, {
+        eventType: edgeSyncEventType(args.operation),
         entityId: args.edgeId,
         entityType: edge.edgeType,
         status: "failed",
         error: errorMsg
       });
-      await ctx.runMutation(internal.neo4jSyncHelpers.queueForRetry, {
+      await ctx.runMutation(graphSyncHelpers.queueForRetry, {
         entityType: "edge",
         entityId: args.edgeId,
         operation: args.operation,
@@ -617,13 +633,10 @@ var syncAllNodesToNeo4j = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 100;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getNodeBatchForSync,
-      {
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getNodeBatchForSync, {
+      limit: batchSize,
+      cursor: args.cursor
+    });
     if (result.nodes.length === 0) {
       return { synced: 0, failed: 0, hasMore: false };
     }
@@ -668,19 +681,16 @@ var syncAllEdgesToNeo4j = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 100;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getEdgeBatchForSync,
-      {
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getEdgeBatchForSync, {
+      limit: batchSize,
+      cursor: args.cursor
+    });
     if (result.edges.length === 0) {
       return { synced: 0, failed: 0, hasMore: false };
     }
     const edgesToSync = [];
     for (const edge of result.edges) {
-      if (!edge.fromGlobalId || !edge.toGlobalId) {
+      if (!(edge.fromGlobalId && edge.toGlobalId)) {
         console.warn(
           `[Neo4j Sync] Skipping edge ${edge.globalId} - missing globalIds`
         );
@@ -726,16 +736,13 @@ var backfillAllToNeo4j = internalAction({
     console.log("[Neo4j Sync] Starting full backfill...");
     let nodeCursor;
     do {
-      const result = await ctx.runAction(
-        internal.neo4jSync.syncAllNodesToNeo4j,
-        {
-          batchSize,
-          cursor: nodeCursor
-        }
-      );
+      const result = await ctx.runAction(graphSyncActions.syncAllNodesToNeo4j, {
+        batchSize,
+        cursor: nodeCursor
+      });
       totalNodes += result.synced;
       totalFailed += result.failed;
-      nodeCursor = result.hasMore ? result.nextCursor : void 0;
+      nodeCursor = result.hasMore ? result.nextCursor ?? void 0 : void 0;
       console.log(
         `[Neo4j Sync] Nodes progress: ${totalNodes} synced, ${totalFailed} failed`
       );
@@ -743,16 +750,13 @@ var backfillAllToNeo4j = internalAction({
     console.log(`[Neo4j Sync] Finished nodes: ${totalNodes} synced`);
     let edgeCursor;
     do {
-      const result = await ctx.runAction(
-        internal.neo4jSync.syncAllEdgesToNeo4j,
-        {
-          batchSize,
-          cursor: edgeCursor
-        }
-      );
+      const result = await ctx.runAction(graphSyncActions.syncAllEdgesToNeo4j, {
+        batchSize,
+        cursor: edgeCursor
+      });
       totalEdges += result.synced;
       totalFailed += result.failed;
-      edgeCursor = result.hasMore ? result.nextCursor : void 0;
+      edgeCursor = result.hasMore ? result.nextCursor ?? void 0 : void 0;
       console.log(
         `[Neo4j Sync] Edges progress: ${totalEdges} synced, ${totalFailed} failed`
       );
@@ -775,7 +779,7 @@ var processRetryQueue = internalAction({
   handler: async (ctx, args) => {
     const limit = args.limit ?? 10;
     const pendingItems = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getPendingRetries,
+      graphSyncHelpers.getPendingRetries,
       { limit }
     );
     if (pendingItems.length === 0) {
@@ -784,31 +788,31 @@ var processRetryQueue = internalAction({
     let succeeded = 0;
     let failed = 0;
     for (const item of pendingItems) {
-      await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+      await ctx.runMutation(graphSyncHelpers.updateQueueStatus, {
         queueId: item._id,
         status: "in_progress"
       });
       let result;
       if (item.entityType === "node") {
-        result = await ctx.runAction(internal.neo4jSync.syncNodeToNeo4j, {
+        result = await ctx.runAction(graphSyncActions.syncNodeToNeo4j, {
           nodeId: item.entityId,
           operation: item.operation
         });
       } else {
         const resolved = await ctx.runQuery(
-          internal.neo4jSyncHelpers.resolveEdgeRetryTarget,
+          graphSyncHelpers.resolveEdgeRetryTarget,
           {
             entityId: item.entityId
           }
         );
         if (resolved.mode === "convex_id" || resolved.mode === "global_id_in_convex") {
-          result = await ctx.runAction(internal.neo4jSync.syncEdgeToNeo4j, {
+          result = await ctx.runAction(graphSyncActions.syncEdgeToNeo4j, {
             edgeId: resolved.edgeId,
             operation: item.operation
           });
         } else {
           result = await ctx.runAction(
-            internal.neo4jEdgeAPI.retryProjectionByGlobalId,
+            graphSyncEdgeApi.retryProjectionByGlobalId,
             {
               globalId: resolved.edgeGlobalId
             }
@@ -816,14 +820,14 @@ var processRetryQueue = internalAction({
         }
       }
       if (result.success) {
-        await ctx.runMutation(internal.neo4jSyncHelpers.updateQueueStatus, {
+        await ctx.runMutation(graphSyncHelpers.updateQueueStatus, {
           queueId: item._id,
           status: "succeeded"
         });
         succeeded++;
       } else {
         const updated = await ctx.runMutation(
-          internal.neo4jSyncHelpers.incrementAttempts,
+          graphSyncHelpers.incrementAttempts,
           {
             queueId: item._id,
             error: result.error || "Unknown error"
@@ -849,7 +853,7 @@ var syncEmbeddingToNeo4j = internalAction({
         skippedReason: "credentials_missing"
       });
     }
-    const node = await ctx.runQuery(internal.neo4jSyncHelpers.getNodeForSync, {
+    const node = await ctx.runQuery(graphSyncHelpers.getNodeForSync, {
       nodeId: args.nodeId
     });
     if (!node?.globalId) {
@@ -857,10 +861,9 @@ var syncEmbeddingToNeo4j = internalAction({
         skippedReason: "source_node_missing"
       });
     }
-    const embedding = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getEmbeddingForSync,
-      { nodeId: args.nodeId }
-    );
+    const embedding = await ctx.runQuery(graphSyncHelpers.getEmbeddingForSync, {
+      nodeId: args.nodeId
+    });
     if (!embedding) {
       return buildSyncFailure("embedding", "sync", "Embedding not found", {
         skippedReason: "embedding_missing"
@@ -910,20 +913,17 @@ var resyncAllNodes = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 50;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getAllNodesForResync,
-      {
-        nodeType: args.nodeType,
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getAllNodesForResync, {
+      nodeType: args.nodeType,
+      limit: batchSize,
+      cursor: args.cursor
+    });
     let synced = 0;
     let failed = 0;
     for (const node of result.nodes) {
       try {
         const syncResult = await ctx.runAction(
-          internal.neo4jSync.syncNodeToNeo4j,
+          graphSyncActions.syncNodeToNeo4j,
           {
             nodeId: node._id,
             operation: "upsert"
@@ -956,19 +956,16 @@ var resyncAllEdges = internalAction({
   returns: permissiveReturn,
   handler: async (ctx, args) => {
     const batchSize = args.batchSize ?? 50;
-    const result = await ctx.runQuery(
-      internal.neo4jSyncHelpers.getAllEdgesForResync,
-      {
-        limit: batchSize,
-        cursor: args.cursor
-      }
-    );
+    const result = await ctx.runQuery(graphSyncHelpers.getAllEdgesForResync, {
+      limit: batchSize,
+      cursor: args.cursor
+    });
     let synced = 0;
     let failed = 0;
     for (const edge of result.edges) {
       try {
         const syncResult = await ctx.runAction(
-          internal.neo4jSync.syncEdgeToNeo4j,
+          graphSyncActions.syncEdgeToNeo4j,
           {
             edgeId: edge._id,
             operation: "upsert"