Skip to content

Database diagrams editor that allows you to visualize and design your DB with a single query.

fix: resolve race condition between edge creation and handle registration (#1118)

Jonathan Fishner81dae56bcda0
diff --git a/src/pages/editor-page/canvas/canvas.tsx b/src/pages/editor-page/canvas/canvas.tsx
index eb24305e..7e868bcb 100644
--- a/src/pages/editor-page/canvas/canvas.tsx
+++ b/src/pages/editor-page/canvas/canvas.tsx
@@ -27,6 +27,7 @@ import {
useReactFlow,
useKeyPress,
SelectionMode,
+ useUpdateNodeInternals,
} from '@xyflow/react';
import '@xyflow/react/dist/style.css';
import equal from 'fast-deep-equal';
@@ -164,6 +165,7 @@ const tableToTableNode = (
showDBViews,
forceShow,
isRelationshipCreatingTarget = false,
+ targetEdgeCounts,
}: {
filter?: DiagramFilter;
databaseType: DatabaseType;
@@ -171,6 +173,7 @@ const tableToTableNode = (
showDBViews?: boolean;
forceShow?: boolean;
isRelationshipCreatingTarget?: boolean;
+ targetEdgeCounts?: Record<string, number>;
}
): TableNodeType => {
// Always use absolute position for now
@@ -199,6 +202,7 @@ const tableToTableNode = (
table,
isOverlapping: false,
isRelationshipCreatingTarget,
+ targetEdgeCounts,
},
width: table.width ?? MIN_TABLE_SIZE,
hidden,
@@ -271,6 +275,7 @@ export interface CanvasProps {
export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
const { getEdge, getInternalNode, getNode } = useReactFlow();
+ const updateNodeInternals = useUpdateNodeInternals();
const [selectedTableIds, setSelectedTableIds] = useState<string[]>([]);
const [selectedRelationshipIds, setSelectedRelationshipIds] = useState<
string[]
@@ -400,66 +405,90 @@ export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
}, [isInitialLoadingNodes, fitView]);
useEffect(() => {
- const targetIndexes: Record<string, number> = relationships.reduce(
- (acc, relationship) => {
- acc[
- `${relationship.targetTableId}${relationship.targetFieldId}`
- ] = 0;
- return acc;
- },
- {} as Record<string, number>
- );
-
- const targetDepIndexes: Record<string, number> = dependencies.reduce(
- (acc, dep) => {
- acc[dep.tableId] = 0;
- return acc;
- },
- {} as Record<string, number>
- );
+ // Force React Flow to re-register handles for all table nodes
+ // This ensures handles exist before edges reference them
+ const tableNodeIds = tables.map((t) => t.id);
+ if (tableNodeIds.length > 0) {
+ updateNodeInternals(tableNodeIds);
+ }
- setEdges((prevEdges) => {
- // Create a map of previous edge states to preserve selection
- const prevEdgeStates = new Map(
- prevEdges.map((edge) => [
- edge.id,
- { selected: edge.selected, animated: edge.animated },
- ])
+ // Delay edge creation to ensure handles are registered
+ const timeoutId = setTimeout(() => {
+ const targetIndexes: Record<string, number> = relationships.reduce(
+ (acc, relationship) => {
+ acc[
+ `${relationship.targetTableId}${relationship.targetFieldId}`
+ ] = 0;
+ return acc;
+ },
+ {} as Record<string, number>
);
- return [
- ...relationships.map((relationship): RelationshipEdgeType => {
- const prevState = prevEdgeStates.get(relationship.id);
- return {
- id: relationship.id,
- source: relationship.sourceTableId,
- target: relationship.targetTableId,
- sourceHandle: `${LEFT_HANDLE_ID_PREFIX}${relationship.sourceFieldId}`,
- targetHandle: `${TARGET_ID_PREFIX}${targetIndexes[`${relationship.targetTableId}${relationship.targetFieldId}`]++}_${relationship.targetFieldId}`,
- type: 'relationship-edge',
- data: { relationship },
- selected: prevState?.selected ?? false,
- animated: prevState?.animated ?? false,
- };
- }),
- ...dependencies.map((dep): DependencyEdgeType => {
- const prevState = prevEdgeStates.get(dep.id);
- return {
- id: dep.id,
- source: dep.dependentTableId,
- target: dep.tableId,
- sourceHandle: `${TOP_SOURCE_HANDLE_ID_PREFIX}${dep.dependentTableId}`,
- targetHandle: `${TARGET_DEP_PREFIX}${targetDepIndexes[dep.tableId]++}_${dep.tableId}`,
- type: 'dependency-edge',
- data: { dependency: dep },
- hidden: !showDBViews,
- selected: prevState?.selected ?? false,
- animated: prevState?.animated ?? false,
- };
- }),
- ];
- });
- }, [relationships, dependencies, setEdges, showDBViews]);
+ const targetDepIndexes: Record<string, number> =
+ dependencies.reduce(
+ (acc, dep) => {
+ acc[dep.tableId] = 0;
+ return acc;
+ },
+ {} as Record<string, number>
+ );
+
+ setEdges((prevEdges) => {
+ // Create a map of previous edge states to preserve selection
+ const prevEdgeStates = new Map(
+ prevEdges.map((edge) => [
+ edge.id,
+ { selected: edge.selected, animated: edge.animated },
+ ])
+ );
+
+ return [
+ ...relationships.map(
+ (relationship): RelationshipEdgeType => {
+ const prevState = prevEdgeStates.get(
+ relationship.id
+ );
+ return {
+ id: relationship.id,
+ source: relationship.sourceTableId,
+ target: relationship.targetTableId,
+ sourceHandle: `${LEFT_HANDLE_ID_PREFIX}${relationship.sourceFieldId}`,
+ targetHandle: `${TARGET_ID_PREFIX}${targetIndexes[`${relationship.targetTableId}${relationship.targetFieldId}`]++}_${relationship.targetFieldId}`,
+ type: 'relationship-edge',
+ data: { relationship },
+ selected: prevState?.selected ?? false,
+ animated: prevState?.animated ?? false,
+ };
+ }
+ ),
+ ...dependencies.map((dep): DependencyEdgeType => {
+ const prevState = prevEdgeStates.get(dep.id);
+ return {
+ id: dep.id,
+ source: dep.dependentTableId,
+ target: dep.tableId,
+ sourceHandle: `${TOP_SOURCE_HANDLE_ID_PREFIX}${dep.dependentTableId}`,
+ targetHandle: `${TARGET_DEP_PREFIX}${targetDepIndexes[dep.tableId]++}_${dep.tableId}`,
+ type: 'dependency-edge',
+ data: { dependency: dep },
+ hidden: !showDBViews,
+ selected: prevState?.selected ?? false,
+ animated: prevState?.animated ?? false,
+ };
+ }),
+ ];
+ });
+ }, 100); // Delay to let handles register after updateNodeInternals
+
+ return () => clearTimeout(timeoutId);
+ }, [
+ relationships,
+ dependencies,
+ setEdges,
+ showDBViews,
+ tables,
+ updateNodeInternals,
+ ]);
useEffect(() => {
const selectedNodesIds = nodes
@@ -555,11 +584,30 @@ export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
}, [selectedRelationshipIds, selectedTableIds, setEdges]);
useEffect(() => {
+ // Compute target edge counts per field (same logic as edge creation)
+ // This ensures handle creation is synchronized with edge indices
+ const targetEdgeCountsByField: Record<string, number> = {};
+ relationships.forEach((rel) => {
+ const fieldId = rel.targetFieldId;
+ targetEdgeCountsByField[fieldId] =
+ (targetEdgeCountsByField[fieldId] || 0) + 1;
+ });
+
setNodes((prevNodes) => {
const newNodes = [
...tables.map((table) => {
const isOverlapping =
(overlapGraph.graph.get(table.id) ?? []).length > 0;
+
+ // Get target edge counts for this table's fields
+ const tableTargetEdgeCounts: Record<string, number> = {};
+ table.fields.forEach((field) => {
+ if (targetEdgeCountsByField[field.id]) {
+ tableTargetEdgeCounts[field.id] =
+ targetEdgeCountsByField[field.id];
+ }
+ });
+
const node = tableToTableNode(table, {
filter,
databaseType,
@@ -567,6 +615,7 @@ export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
showDBViews,
forceShow: shouldForceShowTable(table.id),
isRelationshipCreatingTarget: false,
+ targetEdgeCounts: tableTargetEdgeCounts,
});
// Check if table uses the highlighted custom type
@@ -625,6 +674,7 @@ export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
filterLoading,
showDBViews,
shouldForceShowTable,
+ relationships,
]);
// Surgical update for relationship creation target highlighting
diff --git a/src/pages/editor-page/canvas/table-node/table-node-field.tsx b/src/pages/editor-page/canvas/table-node/table-node-field.tsx
index d94bea83..724d3f9a 100644
--- a/src/pages/editor-page/canvas/table-node/table-node-field.tsx
+++ b/src/pages/editor-page/canvas/table-node/table-node-field.tsx
@@ -48,6 +48,8 @@ export interface TableNodeFieldProps {
highlighted: boolean;
visible: boolean;
isConnectable: boolean;
+ // Target edge count passed from canvas to ensure sync with edge creation
+ targetEdgeCount?: number;
}
const arePropsEqual = (
@@ -72,12 +74,21 @@ const arePropsEqual = (
prevProps.highlighted === nextProps.highlighted &&
prevProps.visible === nextProps.visible &&
prevProps.isConnectable === nextProps.isConnectable &&
- prevProps.tableNodeId === nextProps.tableNodeId
+ prevProps.tableNodeId === nextProps.tableNodeId &&
+ prevProps.targetEdgeCount === nextProps.targetEdgeCount
);
};
export const TableNodeField: React.FC<TableNodeFieldProps> = React.memo(
- ({ field, focused, tableNodeId, highlighted, visible, isConnectable }) => {
+ ({
+ field,
+ focused,
+ tableNodeId,
+ highlighted,
+ visible,
+ isConnectable,
+ targetEdgeCount,
+ }) => {
const { relationships, readonly, highlightedCustomType, databaseType } =
useChartDB();
@@ -117,6 +128,11 @@ export const TableNodeField: React.FC<TableNodeFieldProps> = React.memo(
);
const numberOfEdgesToField = useMemo(() => {
+ // Use targetEdgeCount from canvas when available (ensures sync with edge creation)
+ if (targetEdgeCount !== undefined) {
+ return targetEdgeCount;
+ }
+ // Fallback: count from relationships
let count = 0;
for (const rel of relationships) {
if (
@@ -127,7 +143,7 @@ export const TableNodeField: React.FC<TableNodeFieldProps> = React.memo(
}
}
return count;
- }, [relationships, tableNodeId, field.id]);
+ }, [targetEdgeCount, relationships, tableNodeId, field.id]);
const isForeignKey = useMemo(() => {
return relationships.some((rel) => {
@@ -154,18 +170,21 @@ export const TableNodeField: React.FC<TableNodeFieldProps> = React.memo(
});
}, [relationships, tableNodeId, field.id]);
- const previousNumberOfEdgesToFieldRef = useRef(numberOfEdgesToField);
+ const previousNumberOfEdgesToFieldRef = useRef<number | null>(null);
useEffect(() => {
+ // Always update on first render, then only when count changes
if (
+ previousNumberOfEdgesToFieldRef.current === null ||
previousNumberOfEdgesToFieldRef.current !== numberOfEdgesToField
) {
- const timer = setTimeout(() => {
+ // Use requestAnimationFrame for immediate but batched update
+ const frameId = requestAnimationFrame(() => {
updateNodeInternals(tableNodeId);
previousNumberOfEdgesToFieldRef.current =
numberOfEdgesToField;
- }, 100);
- return () => clearTimeout(timer);
+ });
+ return () => cancelAnimationFrame(frameId);
}
}, [tableNodeId, updateNodeInternals, numberOfEdgesToField]);
diff --git a/src/pages/editor-page/canvas/table-node/table-node.tsx b/src/pages/editor-page/canvas/table-node/table-node.tsx
index b4c9f0b6..50bb2eb7 100644
--- a/src/pages/editor-page/canvas/table-node/table-node.tsx
+++ b/src/pages/editor-page/canvas/table-node/table-node.tsx
@@ -65,6 +65,8 @@ export type TableNodeType = Node<
hasHighlightedCustomType?: boolean;
highlightTable?: boolean;
isRelationshipCreatingTarget?: boolean;
+ // Map of fieldId -> number of edges targeting that field (for handle creation)
+ targetEdgeCounts?: Record<string, number>;
},
'table'
>;
@@ -81,6 +83,7 @@ export const TableNode: React.FC<NodeProps<TableNodeType>> = React.memo(
hasHighlightedCustomType,
highlightTable,
isRelationshipCreatingTarget,
+ targetEdgeCounts,
},
}) => {
const { updateTable, relationships, readonly } = useChartDB();
@@ -620,6 +623,7 @@ export const TableNode: React.FC<NodeProps<TableNodeType>> = React.memo(
highlighted={highlightedFieldIds.has(field.id)}
visible={true}
isConnectable={!table.isView}
+ targetEdgeCount={targetEdgeCounts?.[field.id]}
/>
))}
</div>