⚡ Bolt: Optimize Prisma Export Dictionary Complexity

.jules/bolt.md

@@ -77,3 +77,7 @@ Optimized metric route processing to O(N) by creating a mapping of routes direct
 ## 2024-07-13 - [Optimize Export Dictionary FK lookups]
 **Learning:** Found O(N * C * E) performance bottleneck in ERD export dictionaries due to repeated array searching with `edges.some()` inside a nested loop over nodes and columns.
 **Action:** Replace repeated linear array scans for edges by precomputing O(1) Set lookups of foreign key column handles per node before looping.
+
+## 2024-10-13 - Optimize O(N * C * E) Complexity in Prisma Export Dictionary
+**Learning:** Nested array iterations (`for (const [_, edgeInfo] of edgesProcessed)`) inside loops parsing graph models and fields (`node.data.columns`) result in O(N * C * E) complexity, creating significant bottlenecks during Prisma schema export for large graphs.
+**Action:** Replace repeated linear edge evaluations by precomputing an O(1) Lookup Map (`edgesProcessedBySource.set(sourceKey, edgeInfo)`) before looping over fields, bringing complexity down to O(E + N * C).

frontend/src/erd/prisma.ts

@@ -60,6 +60,8 @@ export function exportPrisma(
   const fkNodesWithoutHandles = new Set<string>();
   const incomingRelationsByNode = new Map<string, Array<{ relationName: string, sourceModel: string, sourceField: string, isUnique: boolean }>>();
   const edgesProcessed = new Map<string, { sourceModel: string, targetModel: string, sourceFields: string[], targetFields: string[], relationName: string }>();
+  // ⚡ Bolt: Precompute edge lookups by sourceModel+sourceField to avoid O(N*C*E) loops
+  const edgesProcessedBySource = new Map<string, Array<{ sourceModel: string, targetModel: string, sourceFields: string[], targetFields: string[], relationName: string }>>();
 
   for (const edge of edges) {
     const sourceNode = nodesById.get(edge.source);
@@ -93,13 +95,19 @@ export function exportPrisma(
       });
       incomingRelationsByNode.set(edge.target, relList);
 
-      edgesProcessed.set(edge.id, {
+      const edgeInfo = {
         sourceModel: sanitizeName(sourceNode.data.title),
         targetModel: sanitizeName(targetNode.data.title),
         sourceFields: [sanitizeName(sourceField)],
         targetFields: [sanitizeName(targetField)],
         relationName: relName
-      });
+      };
+      edgesProcessed.set(edge.id, edgeInfo);
+
+      const sourceKey = `${edgeInfo.sourceModel}:${edgeInfo.sourceFields[0]}`;
+      const fieldEdges = edgesProcessedBySource.get(sourceKey) || [];
+      fieldEdges.push(edgeInfo);
+      edgesProcessedBySource.set(sourceKey, fieldEdges);
     }
   }
 
@@ -136,12 +144,11 @@ export function exportPrisma(
 
       // Determine if there is a relation defined on this field
       let relationDef = "";
-      for (const [_, edgeInfo] of edgesProcessed) {
-        if (edgeInfo.sourceModel === modelName && edgeInfo.sourceFields.includes(fieldName)) {
-          // This field is a foreign key, but in Prisma, we typically define the relation object field
-          // alongside the scalar field. We will add the relation object field here.
+      const fieldEdges = edgesProcessedBySource.get(`${modelName}:${fieldName}`);
+      if (fieldEdges) {
+        for (const edgeInfo of fieldEdges) {
           const relField = sanitizeName(edgeInfo.targetModel) + "_" + fieldName;
-          relationDef = `\n  ${relField} ${edgeInfo.targetModel}${optional} @relation("${edgeInfo.relationName}", fields: [${fieldName}], references: [${edgeInfo.targetFields[0]}])`;
+          relationDef += `\n  ${relField} ${edgeInfo.targetModel}${optional} @relation("${edgeInfo.relationName}", fields: [${fieldName}], references: [${edgeInfo.targetFields[0]}])`;
         }
       }