Skip to content

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

improve table positioning adjustments

johnnyfishf1832d27018a
diff --git a/src/i18n/locales/en.ts b/src/i18n/locales/en.ts
index dfee92bc..2265756a 100644
--- a/src/i18n/locales/en.ts
+++ b/src/i18n/locales/en.ts
@@ -147,6 +147,7 @@ export const en = {
show_all: 'Show All',
undo: 'Undo',
redo: 'Redo',
+ reorder_diagram: 'Reorder Diagram',
},
new_diagram_dialog: {
diff --git a/src/i18n/locales/es.ts b/src/i18n/locales/es.ts
index 0e42e409..d85aefca 100644
--- a/src/i18n/locales/es.ts
+++ b/src/i18n/locales/es.ts
@@ -147,6 +147,7 @@ export const es: LanguageTranslation = {
show_all: 'Mostrar Todo',
undo: 'Deshacer',
redo: 'Rehacer',
+ reorder_diagram: 'Reordenar Diagrama',
},
new_diagram_dialog: {
diff --git a/src/lib/domain/db-table.ts b/src/lib/domain/db-table.ts
index 126dff86..02e5aaeb 100644
--- a/src/lib/domain/db-table.ts
+++ b/src/lib/domain/db-table.ts
@@ -146,84 +146,131 @@ export const adjustTablePositions = ({
relationships: DBRelationship[];
}): DBTable[] => {
const tableWidth = 200;
- const tableHeight = 300; // Approximate height of each table, adjust as needed
- const gapX = 55;
- const gapY = 42;
- const maxTablesPerRow = 6; // Maximum number of tables per row
+ const tableHeight = 300;
+ const gapX = 100;
+ const gapY = 100;
const startX = 100;
const startY = 100;
- let currentX = startX;
- let currentY = startY;
- let tablesInCurrentRow = 0;
-
- // Step 1: Identify the most connected table and sort the tables by their connectivity
- const tableConnections = new Map<string, number>();
+ // Create a map of table connections
+ const tableConnections = new Map<string, Set<string>>();
relationships.forEach((rel) => {
- tableConnections.set(
- rel.sourceTableId,
- (tableConnections.get(rel.sourceTableId) || 0) + 1
- );
- tableConnections.set(
- rel.targetTableId,
- (tableConnections.get(rel.targetTableId) || 0) + 1
- );
+ if (!tableConnections.has(rel.sourceTableId)) {
+ tableConnections.set(rel.sourceTableId, new Set());
+ }
+ if (!tableConnections.has(rel.targetTableId)) {
+ tableConnections.set(rel.targetTableId, new Set());
+ }
+ tableConnections.get(rel.sourceTableId)!.add(rel.targetTableId);
+ tableConnections.get(rel.targetTableId)!.add(rel.sourceTableId);
});
- const sortedTableIds = [...tableConnections.entries()]
- .sort((a, b) => b[1] - a[1])
- .map((entry) => entry[0]);
+ // Sort tables by number of connections
+ const sortedTables = [...tables].sort(
+ (a, b) =>
+ (tableConnections.get(b.id)?.size || 0) -
+ (tableConnections.get(a.id)?.size || 0)
+ );
const positionedTables = new Set<string>();
+ const tablePositions = new Map<string, { x: number; y: number }>();
- const positionTable = (tableId: string) => {
- const table = tables.find((t) => t.id === tableId);
- if (!table || positionedTables.has(tableId)) {
- return;
+ const isOverlapping = (
+ x: number,
+ y: number,
+ currentTableId: string
+ ): boolean => {
+ for (const [tableId, pos] of tablePositions) {
+ if (tableId === currentTableId) continue;
+ if (
+ Math.abs(x - pos.x) < tableWidth + gapX &&
+ Math.abs(y - pos.y) < tableHeight + gapY
+ ) {
+ return true;
+ }
}
+ return false;
+ };
- // Set the X and Y positions
- table.x = currentX;
- table.y = currentY;
- positionedTables.add(tableId);
-
- // Update position for the next table
- tablesInCurrentRow++;
- if (tablesInCurrentRow >= maxTablesPerRow) {
- tablesInCurrentRow = 0;
- currentX = startX;
- currentY += tableHeight + gapY;
- } else {
- currentX += tableWidth + gapX;
+ const findNonOverlappingPosition = (
+ baseX: number,
+ baseY: number,
+ tableId: string
+ ): { x: number; y: number } => {
+ const spiralStep = Math.max(tableWidth, tableHeight) / 2;
+ let angle = 0;
+ let radius = 0;
+ let iterations = 0;
+ const maxIterations = 1000; // Prevent infinite loop
+
+ while (iterations < maxIterations) {
+ const x = baseX + radius * Math.cos(angle);
+ const y = baseY + radius * Math.sin(angle);
+ if (!isOverlapping(x, y, tableId)) {
+ return { x, y };
+ }
+ angle += Math.PI / 4;
+ if (angle >= 2 * Math.PI) {
+ angle = 0;
+ radius += spiralStep;
+ }
+ iterations++;
}
- // Position connected tables recursively
- const connectedTables = relationships
- .filter(
- (rel) =>
- rel.sourceTableId === tableId ||
- rel.targetTableId === tableId
- )
- .map((rel) =>
- rel.sourceTableId === tableId
- ? rel.targetTableId
- : rel.sourceTableId
- );
+ // If we can't find a non-overlapping position, return a position far from others
+ return {
+ x: baseX + radius * Math.cos(angle),
+ y: baseY + radius * Math.sin(angle),
+ };
+ };
+
+ const positionTable = (table: DBTable, baseX: number, baseY: number) => {
+ if (positionedTables.has(table.id)) return;
+
+ const { x, y } = findNonOverlappingPosition(baseX, baseY, table.id);
+
+ table.x = x;
+ table.y = y;
+ tablePositions.set(table.id, { x: table.x, y: table.y });
+ positionedTables.add(table.id);
- connectedTables.forEach(positionTable);
+ // Position connected tables
+ const connectedTables = tableConnections.get(table.id) || new Set();
+ let angle = 0;
+ const angleStep = (2 * Math.PI) / connectedTables.size;
+
+ connectedTables.forEach((connectedTableId) => {
+ if (!positionedTables.has(connectedTableId)) {
+ const connectedTable = tables.find(
+ (t) => t.id === connectedTableId
+ );
+ if (connectedTable) {
+ const newX = x + Math.cos(angle) * (tableWidth + gapX * 2);
+ const newY = y + Math.sin(angle) * (tableHeight + gapY * 2);
+ positionTable(connectedTable, newX, newY);
+ angle += angleStep;
+ }
+ }
+ });
};
- // Step 2: Start positioning with the most connected tables first
- sortedTableIds.forEach((tableId) => {
- if (!positionedTables.has(tableId)) {
- positionTable(tableId);
+ // Position tables
+ sortedTables.forEach((table, index) => {
+ if (!positionedTables.has(table.id)) {
+ const row = Math.floor(index / 6);
+ const col = index % 6;
+ const x = startX + col * (tableWidth + gapX * 2);
+ const y = startY + row * (tableHeight + gapY * 2);
+ positionTable(table, x, y);
}
});
- // Step 3: Handle any remaining unpositioned tables
+ // Apply positions to tables
tables.forEach((table) => {
- if (!positionedTables.has(table.id)) {
- positionTable(table.id);
+ const position = tablePositions.get(table.id);
+ if (position) {
+ table.x = position.x;
+ table.y = position.y;
}
});
diff --git a/src/pages/editor-page/canvas/canvas.tsx b/src/pages/editor-page/canvas/canvas.tsx
index f83b548c..7d81f0cf 100644
--- a/src/pages/editor-page/canvas/canvas.tsx
+++ b/src/pages/editor-page/canvas/canvas.tsx
@@ -23,16 +23,21 @@ import { useChartDB } from '@/hooks/use-chartdb';
import { LEFT_HANDLE_ID_PREFIX, TARGET_ID_PREFIX } from './table-node-field';
import { Toolbar } from './toolbar/toolbar';
import { useToast } from '@/components/toast/use-toast';
-import { Pencil } from 'lucide-react';
+import { Pencil, LayoutGrid } from 'lucide-react';
import { Button } from '@/components/button/button';
import { useLayout } from '@/hooks/use-layout';
import { useBreakpoint } from '@/hooks/use-breakpoint';
import { Badge } from '@/components/badge/badge';
import { useTheme } from '@/hooks/use-theme';
import { useTranslation } from 'react-i18next';
-import { DBTable } from '@/lib/domain/db-table';
+import { DBTable, adjustTablePositions } from '@/lib/domain/db-table';
import { useLocalConfig } from '@/hooks/use-local-config';
import { schemaNameToSchemaId } from '@/lib/domain/db-schema';
+import {
+ Tooltip,
+ TooltipTrigger,
+ TooltipContent,
+} from '@/components/tooltip/tooltip';
type AddEdgeParams = Parameters<typeof addEdge<TableEdgeType>>[0];
@@ -278,6 +283,12 @@ export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
const isLoadingDOM =
tables.length > 0 ? !getInternalNode(tables[0].id) : false;
+ const reorderTables = useCallback(() => {
+ const newTables = adjustTablePositions({ relationships, tables });
+ setNodes(newTables.map(tableToTableNode));
+ fitView({ padding: 0.2, duration: 1000 });
+ }, [relationships, tables, setNodes, fitView]);
+
return (
<div className="flex h-full">
<ReactFlow
@@ -302,7 +313,31 @@ export const Canvas: React.FC<CanvasProps> = ({ initialTables }) => {
}}
panOnScroll={scrollAction === 'pan'}
>
- {isLoadingDOM ? (
+ <Controls
+ position="top-left"
+ showZoom={false}
+ showFitView={false}
+ showInteractive={false}
+ className="!shadow-none"
+ >
+ <Tooltip>
+ <TooltipTrigger asChild>
+ <span>
+ <Button
+ variant="secondary"
+ className="size-8 p-1 shadow-none"
+ onClick={reorderTables}
+ >
+ <LayoutGrid className="size-4" />
+ </Button>
+ </span>
+ </TooltipTrigger>
+ <TooltipContent>
+ {t('toolbar.reorder_diagram')}
+ </TooltipContent>
+ </Tooltip>
+ </Controls>
+ {isLoadingDOM ? (
<Controls
position="top-center"
orientation="horizontal"
diff --git a/src/pages/editor-page/canvas/table-node.tsx b/src/pages/editor-page/canvas/table-node.tsx
index a808dc8e..57a7b42c 100644
--- a/src/pages/editor-page/canvas/table-node.tsx
+++ b/src/pages/editor-page/canvas/table-node.tsx
@@ -1,4 +1,4 @@
-import React, { useCallback } from 'react';
+import React, { useCallback, useState } from 'react';
import { NodeProps, Node, NodeResizer, useStore } from '@xyflow/react';
import { Button } from '@/components/button/button';
import {
@@ -34,6 +34,7 @@ export const TableNode: React.FC<NodeProps<TableNodeType>> = ({
const { updateTable } = useChartDB();
const edges = useStore((store) => store.edges) as TableEdgeType[];
const { openTableFromSidebar, selectSidebarSection } = useLayout();
+ const [isExpanded, setIsExpanded] = useState(false);
const selectedEdges = edges.filter(
(edge) => (edge.source === id || edge.target === id) && edge.selected
@@ -61,9 +62,20 @@ export const TableNode: React.FC<NodeProps<TableNodeType>> = ({
});
}, [table.id, updateTable]);
+ const toggleExpand = () => {
+ setIsExpanded(!isExpanded);
+ };
+
+ const visibleFields = isExpanded ? table.fields : table.fields.slice(0, 10);
+ const hiddenFieldsCount = table.fields.length - 10;
+
return (
<div
- className={`flex w-full flex-col border-2 bg-slate-50 dark:bg-slate-950 ${selected ? 'border-pink-600' : 'border-slate-500 dark:border-slate-700'} rounded-lg shadow-sm`}
+ className={`flex w-full flex-col border-2 bg-slate-50 dark:bg-slate-950 ${
+ selected
+ ? 'border-pink-600'
+ : 'border-slate-500 dark:border-slate-700'
+ } rounded-lg shadow-sm`}
onClick={(e) => {
if (e.detail === 2) {
openTableInEditor();
@@ -114,20 +126,41 @@ export const TableNode: React.FC<NodeProps<TableNodeType>> = ({
</Button>
</div>
</div>
- {table.fields.map((field) => (
- <TableNodeField
- key={field.id}
- focused={focused}
- tableNodeId={id}
- field={field}
- highlighted={selectedEdges.some(
- (edge) =>
- edge.data?.relationship.sourceFieldId ===
- field.id ||
- edge.data?.relationship.targetFieldId === field.id
- )}
- />
- ))}
+ <div className="flex flex-col">
+ {visibleFields.map((field) => (
+ <TableNodeField
+ key={field.id}
+ tableNodeId={id}
+ field={field}
+ focused={focused}
+ highlighted={selectedEdges.some(
+ (edge) =>
+ edge.sourceHandle?.endsWith(field.id) ||
+ edge.targetHandle?.endsWith(field.id)
+ )}
+ />
+ ))}
+ {!isExpanded && hiddenFieldsCount > 0 && (
+ <div
+ className="flex h-8 cursor-pointer items-center justify-center bg-slate-100 hover:bg-slate-200 dark:bg-slate-800 dark:hover:bg-slate-700"
+ onClick={toggleExpand}
+ >
+ <span className="text-sm text-slate-600 dark:text-slate-400">
+ ... {hiddenFieldsCount} more fields
+ </span>
+ </div>
+ )}
+ {isExpanded && (
+ <div
+ className="flex h-8 cursor-pointer items-center justify-center bg-slate-100 hover:bg-slate-200 dark:bg-slate-800 dark:hover:bg-slate-700"
+ onClick={toggleExpand}
+ >
+ <span className="text-sm text-slate-600 dark:text-slate-400">
+ Show less
+ </span>
+ </div>
+ )}
+ </div>
</div>
);
};