Skip to content

Free, simple, and intuitive online database diagram editor and SQL generator.

Make the dbml editor editable (#1091)

1ilit9f5f7a21302a
diff --git a/src/components/CodeEditor/index.jsx b/src/components/CodeEditor/index.jsx
index 15576df4..5f694c9b 100644
--- a/src/components/CodeEditor/index.jsx
+++ b/src/components/CodeEditor/index.jsx
@@ -1,4 +1,4 @@
-import { useState } from "react";
+import { useRef, useState } from "react";
import { Editor } from "@monaco-editor/react";
import { useDiagram, useSettings } from "../../hooks";
import { Button } from "@douyinfe/semi-ui";
@@ -11,16 +11,19 @@ export default function CodeEditor({
extraControls,
filename,
className = "",
+ formatOnMount = true,
+ onEditorMount,
...props
}) {
const { settings } = useSettings();
const { database } = useDiagram();
const { t } = useTranslation();
const [copied, setCopied] = useState(false);
+ const editorRef = useRef(null);
const copyCode = () => {
navigator.clipboard
- .writeText(props.value)
+ .writeText(editorRef.current?.getValue() ?? props.value ?? "")
.then(() => {
setCopied(true);
setTimeout(() => setCopied(false), 3000);
@@ -29,10 +32,14 @@ export default function CodeEditor({
};
const handleEditorMount = (editor, monaco) => {
+ editorRef.current = editor;
setUpDBML(monaco, database);
- setTimeout(() => {
- editor.getAction("editor.action.formatDocument").run();
- }, 300);
+ if (formatOnMount) {
+ setTimeout(() => {
+ editor.getAction("editor.action.formatDocument")?.run();
+ }, 300);
+ }
+ onEditorMount?.(editor, monaco);
};
return (
diff --git a/src/components/EditorHeader/ControlPanel.jsx b/src/components/EditorHeader/ControlPanel.jsx
index da924c24..d1a5548d 100644
--- a/src/components/EditorHeader/ControlPanel.jsx
+++ b/src/components/EditorHeader/ControlPanel.jsx
@@ -82,6 +82,8 @@ import { jsonToDocumentation } from "../../utils/exportAs/documentation";
import { IdContext } from "../Workspace";
import { socials } from "../../data/socials";
import { toDBML } from "../../utils/exportAs/dbml";
+import { applyDiagramPlan } from "../../utils/dbml/applyPlan";
+import { diffDiagram } from "../../utils/dbml/diff";
import { exportSavedData } from "../../utils/exportSavedData";
import { nanoid } from "nanoid";
import { getTableHeight } from "../../utils/utils";
@@ -91,6 +93,11 @@ import ConfigureCustomTypes from "./ConfigureCustomTypes";
import { useDiagramList } from "./Modal/Open/hooks/useDiagramList";
import { mergeDiagrams, sortDiagrams } from "./Modal/Open/diagram";
+const EDITOR_HOTKEY = {
+ preventDefault: true,
+ ignoreEventWhen: (e) => Boolean(e.target?.closest?.(".monaco-editor")),
+};
+
export default function ControlPanel({
title,
setTitle,
@@ -149,6 +156,21 @@ export default function ControlPanel({
const navigate = useNavigateWithParams();
const extensions = useExtensions();
+ const swapDbmlSnapshot = (entry) => {
+ const current = { tables, relationships, enums };
+ applyDiagramPlan(diffDiagram(current, entry.data.snapshot), {
+ addTable,
+ updateTable,
+ updateField,
+ deleteTable,
+ addRelationship,
+ updateRelationship,
+ deleteRelationship,
+ setEnums,
+ });
+ return { ...entry, data: { snapshot: current } };
+ };
+
const undo = () => {
if (undoStack.length === 0) return;
const a = undoStack[undoStack.length - 1];
@@ -168,6 +190,11 @@ export default function ControlPanel({
return;
}
+ if (a.element === ObjectType.DBML) {
+ setRedoStack((prev) => [...prev, swapDbmlSnapshot(a)]);
+ return;
+ }
+
if (a.action === Action.ADD) {
if (a.element === ObjectType.TABLE) {
deleteTable(a.data.table.id, false);
@@ -368,6 +395,11 @@ export default function ControlPanel({
return;
}
+ if (a.element === ObjectType.DBML) {
+ setUndoStack((prev) => [...prev, swapDbmlSnapshot(a)]);
+ return;
+ }
+
if (a.action === Action.ADD) {
if (a.element === ObjectType.TABLE) {
addTable(a.data, false);
@@ -830,7 +862,7 @@ export default function ControlPanel({
const save = async () => {
if (typeof extensions.cloudSave === "function") {
// TODO: dont have blank here have null
- const isNew = diagramId === 'blank';
+ const isNew = diagramId === "blank";
const newId = isNew ? uuidv4() : diagramId;
const diagramData = {
diagramId: newId,
@@ -1047,10 +1079,7 @@ export default function ControlPanel({
if (typeof extensions.cloudDelete === "function") {
await extensions.cloudDelete(diagramId);
} else {
- await db.diagrams
- .where("diagramId")
- .equals(diagramId)
- .delete();
+ await db.diagrams.where("diagramId").equals(diagramId).delete();
}
setTitle("Untitled diagram");
setTables([]);
@@ -1744,36 +1773,28 @@ export default function ControlPanel({
},
};
- useHotkeys("mod+i", fileImport, { preventDefault: true });
- useHotkeys("mod+z", undo, { preventDefault: true });
- useHotkeys("mod+y", redo, { preventDefault: true });
- useHotkeys("mod+s", save, { preventDefault: true });
- useHotkeys("mod+o", open, { preventDefault: true });
- useHotkeys("mod+e", edit, { preventDefault: true });
- useHotkeys("mod+d", duplicate, { preventDefault: true });
- useHotkeys("mod+c", copy, { preventDefault: true });
- useHotkeys("mod+v", paste, { preventDefault: true });
- useHotkeys("mod+x", cut, { preventDefault: true });
- useHotkeys("delete", del, { preventDefault: true });
- useHotkeys("mod+shift+g", viewGrid, { preventDefault: true });
- useHotkeys("mod+up", zoomIn, { preventDefault: true });
- useHotkeys("mod+down", zoomOut, { preventDefault: true });
- useHotkeys("mod+shift+m", viewStrictMode, {
- preventDefault: true,
- });
- useHotkeys("mod+shift+f", viewFieldSummary, {
- preventDefault: true,
- });
- useHotkeys("mod+shift+s", saveDiagramAs, {
- preventDefault: true,
- });
- useHotkeys("mod+alt+c", copyAsImage, { preventDefault: true });
- useHotkeys("enter", resetView, { preventDefault: true });
- useHotkeys("mod+h", () => window.open(socials.docs, "_blank"), {
- preventDefault: true,
- });
- useHotkeys("mod+alt+w", fitWindow, { preventDefault: true });
- useHotkeys("alt+e", toggleDBMLEditor, { preventDefault: true });
+ useHotkeys("mod+i", fileImport, EDITOR_HOTKEY);
+ useHotkeys("mod+z", undo, EDITOR_HOTKEY);
+ useHotkeys("mod+y", redo, EDITOR_HOTKEY);
+ useHotkeys("mod+s", save, EDITOR_HOTKEY);
+ useHotkeys("mod+o", open, EDITOR_HOTKEY);
+ useHotkeys("mod+e", edit, EDITOR_HOTKEY);
+ useHotkeys("mod+d", duplicate, EDITOR_HOTKEY);
+ useHotkeys("mod+c", copy, EDITOR_HOTKEY);
+ useHotkeys("mod+v", paste, EDITOR_HOTKEY);
+ useHotkeys("mod+x", cut, EDITOR_HOTKEY);
+ useHotkeys("delete", del, EDITOR_HOTKEY);
+ useHotkeys("mod+shift+g", viewGrid, EDITOR_HOTKEY);
+ useHotkeys("mod+up", zoomIn, EDITOR_HOTKEY);
+ useHotkeys("mod+down", zoomOut, EDITOR_HOTKEY);
+ useHotkeys("mod+shift+m", viewStrictMode, EDITOR_HOTKEY);
+ useHotkeys("mod+shift+f", viewFieldSummary, EDITOR_HOTKEY);
+ useHotkeys("mod+shift+s", saveDiagramAs, EDITOR_HOTKEY);
+ useHotkeys("mod+alt+c", copyAsImage, EDITOR_HOTKEY);
+ useHotkeys("enter", resetView, EDITOR_HOTKEY);
+ useHotkeys("mod+h", () => window.open(socials.docs, "_blank"), EDITOR_HOTKEY);
+ useHotkeys("mod+alt+w", fitWindow, EDITOR_HOTKEY);
+ useHotkeys("alt+e", toggleDBMLEditor, EDITOR_HOTKEY);
return (
<>
@@ -2060,8 +2081,10 @@ export default function ControlPanel({
}}
onClick={!layout.readOnly && (() => setModal(MODAL.RENAME))}
>
- <span>{(isTemplate ? "Templates" : "Diagrams")}</span>
- <span className="select-none text-zinc-400 dark:text-zinc-500 mx-1">/</span>
+ <span>{isTemplate ? "Templates" : "Diagrams"}</span>
+ <span className="select-none text-zinc-400 dark:text-zinc-500 mx-1">
+ /
+ </span>
<span>{title}</span>
{version && (
<Tag className="mt-1" color="blue" size="small">
diff --git a/src/components/EditorHeader/Modal/ImportDiagram.jsx b/src/components/EditorHeader/Modal/ImportDiagram.jsx
index 3d744c48..b38eb344 100644
--- a/src/components/EditorHeader/Modal/ImportDiagram.jsx
+++ b/src/components/EditorHeader/Modal/ImportDiagram.jsx
@@ -129,7 +129,7 @@ export default function ImportDiagram({
const loadDBMLData = (e) => {
try {
- setImportData(fromDBML(e.target.result));
+ setImportData(fromDBML(e.target.result, database));
} catch (error) {
const message = `${error.diags[0].name} [Ln ${error.diags[0].location.start.line}, Col ${error.diags[0].location.start.column}]: ${error.diags[0].message}`;
diff --git a/src/components/EditorSidePanel/DBMLEditor.jsx b/src/components/EditorSidePanel/DBMLEditor.jsx
index 0994e4e2..705a1691 100644
--- a/src/components/EditorSidePanel/DBMLEditor.jsx
+++ b/src/components/EditorSidePanel/DBMLEditor.jsx
@@ -1,28 +1,252 @@
-import { useEffect, useState } from "react";
-import { useDiagram, useEnums } from "../../hooks";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useTranslation } from "react-i18next";
+import { Action, ObjectType } from "../../data/constants";
+import { useDiagram, useEnums, useLayout, useUndoRedo } from "../../hooks";
+import { applyDiagramPlan } from "../../utils/dbml/applyPlan";
+import { diffDiagram } from "../../utils/dbml/diff";
+import { parseDbml } from "../../utils/dbml/parse";
+import { reconcileDbml } from "../../utils/dbml/reconcile";
import { toDBML } from "../../utils/exportAs/dbml";
import CodeEditor from "../CodeEditor";
-export default function DBMLEditor() {
- const { tables: currentTables, relationships } = useDiagram();
+const APPLY_DELAY_MS = 500;
+const MARKER_OWNER = "dbml";
+
+function toProblems(error) {
+ const diags = Array.isArray(error?.diags) ? error.diags : [];
+
+ if (!diags.length) {
+ return [
+ {
+ message: error?.message ?? "Invalid DBML",
+ startLine: 1,
+ startColumn: 1,
+ endLine: 1,
+ endColumn: 2,
+ },
+ ];
+ }
+
+ return diags.map((diag) => {
+ const start = diag.location?.start ?? { line: 1, column: 1 };
+ const end = diag.location?.end ?? {
+ line: start.line,
+ column: start.column + 1,
+ };
+ return {
+ message: diag.message,
+ startLine: start.line,
+ startColumn: start.column,
+ endLine: end.line,
+ endColumn: end.column,
+ };
+ });
+}
+
+export default function DBMLEditor({ onProblemsChange }) {
const diagram = useDiagram();
- const { enums } = useEnums();
- const [value, setValue] = useState(() => toDBML({ ...diagram, enums }));
+ const { enums, setEnums } = useEnums();
+ const { layout } = useLayout();
+ const { setUndoStack, setRedoStack } = useUndoRedo();
+ const { t } = useTranslation();
+
+ const { tables, relationships, database } = diagram;
+ const readOnly = layout.readOnly;
+
+ const [focused, setFocused] = useState(false);
+
+ const liveRef = useRef(null);
+ liveRef.current = { database, tables, relationships, enums };
+
+ const readOnlyRef = useRef(readOnly);
+ readOnlyRef.current = readOnly;
+
+ const onProblemsChangeRef = useRef(onProblemsChange);
+ onProblemsChangeRef.current = onProblemsChange;
+
+ const planContextRef = useRef(null);
+ planContextRef.current = {
+ addTable: diagram.addTable,
+ updateTable: diagram.updateTable,
+ updateField: diagram.updateField,
+ deleteTable: diagram.deleteTable,
+ addRelationship: diagram.addRelationship,
+ updateRelationship: diagram.updateRelationship,
+ deleteRelationship: diagram.deleteRelationship,
+ setEnums,
+ };
+
+ const editorRef = useRef(null);
+ const monacoRef = useRef(null);
+ const draftRef = useRef(null);
+ const timerRef = useRef(null);
+ const baseRef = useRef(null);
+ const printedRef = useRef(null);
+ const reportedRef = useRef([]);
+ const initialValueRef = useRef(null);
+
+ if (initialValueRef.current === null) {
+ initialValueRef.current = toDBML(liveRef.current);
+ baseRef.current = liveRef.current;
+ printedRef.current = initialValueRef.current;
+ }
+
+ const cancelPendingApply = () => {
+ if (timerRef.current === null) return;
+ clearTimeout(timerRef.current);
+ timerRef.current = null;
+ };
+
+ const reportProblems = useCallback((found) => {
+ if (!reportedRef.current.length && !found.length) return;
+ reportedRef.current = found;
+
+ const monaco = monacoRef.current;
+ const model = editorRef.current?.getModel();
+ if (monaco && model && !model.isDisposed()) {
+ monaco.editor.setModelMarkers(
+ model,
+ MARKER_OWNER,
+ found.map((problem) => ({
+ severity: monaco.MarkerSeverity.Error,
+ message: problem.message,
+ startLineNumber: problem.startLine,
+ startColumn: problem.startColumn,
+ endLineNumber: problem.endLine,
+ endColumn: problem.endColumn,
+ })),
+ );
+ }
+
+ onProblemsChangeRef.current?.(found);
+ }, []);
+
+ const applyDraft = useCallback(() => {
+ cancelPendingApply();
+ const draft = draftRef.current;
+ if (draft === null || readOnlyRef.current) return;
+
+ const base = baseRef.current;
+ let next;
+ let plan;
+ try {
+ const parsed = parseDbml(draft);
+ next = reconcileDbml(parsed, base, base.database);
+ plan = diffDiagram(base, next);
+ } catch (error) {
+ reportProblems(toProblems(error));
+ return;
+ }
+
+ if (plan.length) {
+ const live = liveRef.current;
+ setUndoStack((prev) => [
+ ...prev,
+ {
+ action: Action.EDIT,
+ element: ObjectType.DBML,
+ data: {
+ snapshot: {
+ tables: live.tables,
+ relationships: live.relationships,
+ enums: live.enums,
+ },
+ },
+ message: t("edit_dbml"),
+ },
+ ]);
+ setRedoStack([]);
+ applyDiagramPlan(plan, planContextRef.current);
+ }
+
+ baseRef.current = { ...base, ...next };
+ printedRef.current = toDBML({ ...next, database: base.database });
+ draftRef.current = null;
+ reportProblems([]);
+ }, [reportProblems, setRedoStack, setUndoStack, t]);
+
+ const applyDraftRef = useRef(applyDraft);
+ applyDraftRef.current = applyDraft;
+
+ const reprint = useCallback(
+ (text) => {
+ cancelPendingApply();
+ baseRef.current = liveRef.current;
+ printedRef.current = text;
+ draftRef.current = null;
+ reportProblems([]);
+
+ const model = editorRef.current?.getModel();
+ if (model && !model.isDisposed() && model.getValue() !== text) {
+ model.setValue(text);
+ }
+ },
+ [reportProblems],
+ );
useEffect(() => {
- setValue(toDBML({ tables: currentTables, enums, relationships }));
- }, [currentTables, enums, relationships]);
+ const generated = toDBML(liveRef.current);
+ if (generated === printedRef.current) return;
+
+ if (focused || draftRef.current !== null) return;
+
+ reprint(generated);
+ }, [database, tables, relationships, enums, focused, reprint]);
+
+ useEffect(
+ () => () => {
+ applyDraftRef.current();
+ onProblemsChangeRef.current?.([]);
+ },
+ [],
+ );
+
+ const handleChange = (value) => {
+ if (readOnlyRef.current) return;
+
+ if (value === printedRef.current) {
+ cancelPendingApply();
+ draftRef.current = null;
+ reportProblems([]);
+ return;
+ }
+
+ draftRef.current = value;
+ cancelPendingApply();
+ timerRef.current = setTimeout(
+ () => applyDraftRef.current(),
+ APPLY_DELAY_MS,
+ );
+ };
+
+ const handleMount = (editor, monaco) => {
+ editorRef.current = editor;
+ monacoRef.current = monaco;
+
+ editor.onDidFocusEditorText(() => setFocused(true));
+ editor.onDidBlurEditorText(() => {
+ setFocused(false);
+ applyDraftRef.current();
+ });
+ editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS, () =>
+ applyDraftRef.current(),
+ );
+ };
return (
<CodeEditor
showCopyButton
- value={value}
+ defaultValue={initialValueRef.current}
language="dbml"
- onChange={setValue}
height="100%"
+ formatOnMount={false}
+ onChange={handleChange}
+ onEditorMount={handleMount}
options={{
- readOnly: true,
+ readOnly,
minimap: { enabled: false },
+ scrollBeyondLastLine: false,
+ acceptSuggestionOnEnter: "off",
}}
/>
);
diff --git a/src/components/EditorSidePanel/Issues.jsx b/src/components/EditorSidePanel/Issues.jsx
index f3de9a30..3090a307 100644
--- a/src/components/EditorSidePanel/Issues.jsx
+++ b/src/components/EditorSidePanel/Issues.jsx
@@ -5,7 +5,7 @@ import { getIssues } from "../../utils/issues";
import { useEnums, useSettings, useDiagram, useTypes } from "../../hooks";
import { useTranslation } from "react-i18next";
-export default function Issues() {
+export default function Issues({ dbmlProblems = [] }) {
const { types } = useTypes();
const { t } = useTranslation();
const { settings } = useSettings();
@@ -31,13 +31,17 @@ export default function Issues() {
findIssues();
}, [tables, relationships, issues, types, database, enums]);
+ const badgeCount = settings.strictMode
+ ? dbmlProblems.length || null
+ : issues.length + dbmlProblems.length;
+
return (
<Collapse lazyRender keepDOM={false} style={{ width: "100%" }}>
<Collapse.Panel
header={
<Badge
- type={issues.length > 0 ? "danger" : "primary"}
- count={settings.strictMode ? null : issues.length}
+ type={badgeCount > 0 ? "danger" : "primary"}
+ count={badgeCount}
overflowCount={99}
className="mt-1"
>
@@ -50,18 +54,25 @@ export default function Issues() {
itemKey="1"
>
<div className="max-h-[160px] overflow-y-auto">
+ {dbmlProblems.map((problem, i) => (
+ <div key={`dbml-${i}`} className="py-2 text-red-500">
+ {t("dbml_problem", {
+ line: problem.startLine,
+ column: problem.startColumn,
+ message: problem.message,
+ })}
+ </div>
+ ))}
{settings.strictMode ? (
<div className="mb-1">{t("strict_mode_is_on_no_issues")}</div>
) : issues.length > 0 ? (
- <>
- {issues.map((e, i) => (
- <div key={i} className="py-2">
- {e}
- </div>
- ))}
- </>
+ issues.map((e, i) => (
+ <div key={i} className="py-2">
+ {e}
+ </div>
+ ))
) : (
- <div>{t("no_issues")}</div>
+ !dbmlProblems.length && <div>{t("no_issues")}</div>
)}
</div>
</Collapse.Panel>
diff --git a/src/components/EditorSidePanel/SidePanel.jsx b/src/components/EditorSidePanel/SidePanel.jsx
index 4f145bb4..7b2d6a3c 100644
--- a/src/components/EditorSidePanel/SidePanel.jsx
+++ b/src/components/EditorSidePanel/SidePanel.jsx
@@ -1,4 +1,4 @@
-import { useMemo } from "react";
+import { useMemo, useState } from "react";
import { Tabs, TabPane } from "@douyinfe/semi-ui";
import { IconCode, IconList } from "@douyinfe/semi-icons";
import { IconTable, IconRelationship } from "../../icons";
@@ -36,6 +36,7 @@ export default function SidePanel({ width, resize, setResize }) {
const { typesCount } = useTypes();
const { enumsCount } = useEnums();
const { t } = useTranslation();
+ const [dbmlProblems, setDbmlProblems] = useState([]);
const tabList = useMemo(() => {
const tabs = [
@@ -101,7 +102,7 @@ export default function SidePanel({ width, resize, setResize }) {
>
<div className="h-full flex-1 overflow-y-auto">
{layout.dbmlEditor ? (
- <DBMLEditor />
+ <DBMLEditor onProblemsChange={setDbmlProblems} />
) : (
<Tabs
type="card"
@@ -168,7 +169,7 @@ export default function SidePanel({ width, resize, setResize }) {
</div>
{layout.issues && (
<div className="mt-auto border-t-2 border-color shadow-inner">
- <Issues />
+ <Issues dbmlProblems={layout.dbmlEditor ? dbmlProblems : []} />
</div>
)}
</div>
diff --git a/src/context/DiagramContext.jsx b/src/context/DiagramContext.jsx
index 6eac27fe..9652cd1d 100644
--- a/src/context/DiagramContext.jsx
+++ b/src/context/DiagramContext.jsx
@@ -244,7 +244,7 @@ export default function DiagramContextProvider({ children }) {
} else {
setRelationships((prev) => {
const temp = prev.slice();
- temp.splice(data.index, 0, data.relationship || data);
+ temp.splice(data.index ?? temp.length, 0, data.relationship || data);
return temp;
});
}
diff --git a/src/data/constants.js b/src/data/constants.js
index c56a68f6..39ab1376 100644
--- a/src/data/constants.js
+++ b/src/data/constants.js
@@ -56,6 +56,7 @@ export const ObjectType = {
RELATIONSHIP: 4,
TYPE: 5,
ENUM: 6,
+ DBML: 7,
};
export const Action = {
diff --git a/src/i18n/locales/en.js b/src/i18n/locales/en.js
index 4271daa4..b20438a0 100644
--- a/src/i18n/locales/en.js
+++ b/src/i18n/locales/en.js
@@ -50,7 +50,7 @@ const en = {
header: "Menubar",
sidebar: "Sidebar",
toolbar: "Toolbar",
- issues: "Issues",
+ issues: "Problems",
presentation_mode: "Presentation mode",
strict_mode: "Strict mode",
field_details: "Field details",
@@ -113,9 +113,9 @@ const en = {
no_notes_text: "Use notes to record extra info",
no_types: "No types",
no_types_text: "Make your own custom data types",
- no_issues: "No issues were detected.",
+ no_issues: "No problems were detected.",
strict_mode_is_on_no_issues:
- "Strict mode is off so no issues will be displayed.",
+ "Strict mode is off so no problems will be displayed.",
name: "Name",
type: "Type",
null: "Null",
@@ -309,6 +309,8 @@ const en = {
foreign_key: "Foreign key",
import_with_ai: "Import with AI",
ai_import_failed: "AI import failed. Please try again.",
+ edit_dbml: "Edit DBML",
+ dbml_problem: "Ln {{line}}, Col {{column}}: {{message}}",
},
};
diff --git a/src/utils/dbml/applyPlan.js b/src/utils/dbml/applyPlan.js
new file mode 100644
index 00000000..51aa7af1
--- /dev/null
+++ b/src/utils/dbml/applyPlan.js
@@ -0,0 +1,28 @@
+export function applyDiagramPlan(plan, ctx) {
+ for (const op of plan) {
+ switch (op.target) {
+ case "enums":
+ ctx.setEnums(op.enums);
+ break;
+ case "table":
+ if (op.action === "create") ctx.addTable({ table: op.table }, false);
+ else if (op.action === "delete") ctx.deleteTable(op.id, false);
+ else ctx.updateTable(op.id, op.values);
+ break;
+ case "field":
+ ctx.updateField(op.tableId, op.fieldId, op.values);
+ break;
+ case "relationship":
+ if (op.action === "create") {
+ ctx.addRelationship({ relationship: op.relationship }, false);
+ } else if (op.action === "delete") {
+ ctx.deleteRelationship(op.id, false);
+ } else {
+ ctx.updateRelationship(op.id, op.values);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+}
diff --git a/src/utils/dbml/diff.js b/src/utils/dbml/diff.js
new file mode 100644
index 00000000..3ff3c241
--- /dev/null
+++ b/src/utils/dbml/diff.js
@@ -0,0 +1,172 @@
+const TABLE_KEYS = ["name", "comment", "color", "indices", "uniqueConstraints"];
+
+const FIELD_KEYS = [
+ "name",
+ "type",
+ "size",
+ "default",
+ "primary",
+ "unique",
+ "notNull",
+ "increment",
+ "comment",
+ "values",
+];
+
+const RELATIONSHIP_KEYS = [
+ "name",
+ "startTableId",
+ "endTableId",
+ "startFieldId",
+ "endFieldId",
+ "fields",
+ "cardinality",
+ "updateConstraint",
+ "deleteConstraint",
+];
+
+function isEqual(a, b) {
+ if (a === b) return true;
+
+ if (Array.isArray(a) && Array.isArray(b)) {
+ return a.length === b.length && a.every((item, i) => isEqual(item, b[i]));
+ }
+
+ if (a && b && typeof a === "object" && typeof b === "object") {
+ const keys = Object.keys(a);
+ return (
+ keys.length === Object.keys(b).length &&
+ keys.every((key) => isEqual(a[key], b[key]))
+ );
+ }
+
+ return false;
+}
+
+function changedValues(before, after, keys) {
+ const values = {};
+ for (const key of keys) {
+ if (!isEqual(before[key], after[key])) values[key] = after[key];
+ }
+ return values;
+}
+
+function byId(items) {
+ return new Map(items.map((item) => [item.id, item]));
+}
+
+function diffFields(before, after) {
+ const beforeFields = before.fields ?? [];
+ const afterFields = after.fields ?? [];
+
+ const sameShape =
+ beforeFields.length === afterFields.length &&
+ beforeFields.every((field, i) => field.id === afterFields[i].id);
+ if (!sameShape) return { replaceFields: true, updates: [] };
+
+ const updates = [];
+ afterFields.forEach((field, i) => {
+ const values = changedValues(beforeFields[i], field, FIELD_KEYS);
+ if (Object.keys(values).length) {
+ updates.push({
+ target: "field",
+ action: "update",
+ tableId: after.id,
+ fieldId: field.id,
+ values,
+ });
+ }
+ });
+
+ return { replaceFields: false, updates };
+}
+
+function diffTables(before, after) {
+ const beforeById = byId(before);
+ const afterById = byId(after);
+
+ const deletes = before
+ .filter((table) => !afterById.has(table.id))
+ .map((table) => ({ target: "table", action: "delete", id: table.id }));
+
+ const creates = after
+ .filter((table) => !beforeById.has(table.id))
+ .map((table) => ({ target: "table", action: "create", table }));
+
+ const updates = [];
+ const fieldUpdates = [];
+
+ for (const table of after) {
+ const previous = beforeById.get(table.id);
+ if (!previous) continue;
+
+ const values = changedValues(previous, table, TABLE_KEYS);
+ const fields = diffFields(previous, table);
+ if (fields.replaceFields) values.fields = table.fields;
+ else fieldUpdates.push(...fields.updates);
+
+ if (Object.keys(values).length) {
+ updates.push({ target: "table", action: "update", id: table.id, values });
+ }
+ }
+
+ return { deletes, creates, updates, fieldUpdates };
+}
+
+function diffRelationships(before, after) {
+ const beforeById = byId(before);
+ const afterById = byId(after);
+
+ const deletes = before
+ .filter((rel) => !afterById.has(rel.id))
+ .map((rel) => ({ target: "relationship", action: "delete", id: rel.id }));
+
+ const creates = after
+ .filter((rel) => !beforeById.has(rel.id))
+ .map((rel) => ({
+ target: "relationship",
+ action: "create",
+ relationship: rel,
+ }));
+
+ const updates = [];
+ for (const rel of after) {
+ const previous = beforeById.get(rel.id);
+ if (!previous) continue;
+
+ const values = changedValues(previous, rel, RELATIONSHIP_KEYS);
+ if (Object.keys(values).length) {
+ updates.push({
+ target: "relationship",
+ action: "update",
+ id: rel.id,
+ values,
+ });
+ }
+ }
+
+ return { deletes, creates, updates };
+}
+
+export function diffDiagram(from, to) {
+ const enums = isEqual(from.enums ?? [], to.enums ?? [])
+ ? []
+ : [{ target: "enums", action: "update", enums: to.enums ?? [] }];
+
+ const tables = diffTables(from.tables ?? [], to.tables ?? []);
+ const relationships = diffRelationships(
+ from.relationships ?? [],
+ to.relationships ?? [],
+ );
+
+ return [
+ ...enums,
+ ...tables.deletes,
+ ...tables.creates,
+ ...tables.updates,
+ ...tables.fieldUpdates,
+ ...relationships.deletes,
+ ...relationships.creates,
+ ...relationships.updates,
+ ];
+}
diff --git a/src/utils/dbml/parse.js b/src/utils/dbml/parse.js
new file mode 100644
index 00000000..736c0b43
--- /dev/null
+++ b/src/utils/dbml/parse.js
@@ -0,0 +1,135 @@
+import { Parser } from "@dbml/core";
+import { Cardinality, Constraint } from "../../data/constants";
+import { inlineEnumTypeName } from "./types";
+
+const parser = new Parser();
+
+const CONSTRAINT_BY_KEYWORD = {
+ "no action": Constraint.NONE,
+ restrict: Constraint.RESTRICT,
+ cascade: Constraint.CASCADE,
+ "set null": Constraint.SET_NULL,
+ "set default": Constraint.SET_DEFAULT,
+};
+
+const CARDINALITY_BY_RELATION = {
+ "*:1": Cardinality.MANY_TO_ONE,
+ "1:*": Cardinality.ONE_TO_MANY,
+ "1:1": Cardinality.ONE_TO_ONE,
+};
+
+function baseTypeName(type) {
+ const name = String(type?.type_name ?? "");
+ if (type?.args == null) return name;
+
+ const openingBracket = name.lastIndexOf("(");
+ return openingBracket === -1 ? name : name.slice(0, openingBracket);
+}
+
+function fieldDefault(column) {
+ const value = column.dbdefault?.value;
+ return value === undefined || value === null ? "" : String(value);
+}
+
+function parseField(column) {
+ return {
+ name: column.name,
+ type: baseTypeName(column.type).toUpperCase(),
+ size: column.type?.args ?? "",
+ default: fieldDefault(column),
+ primary: !!column.pk,
+ unique: !!column.unique,
+ notNull: !!column.not_null,
+ increment: !!column.increment,
+ comment: column.note ?? "",
+ };
+}
+
+function parseTable(table) {
+ return {
+ name: table.name,
+ comment: table.note ?? "",
+ color: table.headerColor ?? null,
+ fields: table.fields.map(parseField),
+ indices: table.indexes.map((index) => ({
+ name: index.name ?? "",
+ fields: index.columns.map((column) => column.value),
+ unique: !!index.unique,
+ })),
+ };
+}
+
+function parseRef(ref) {
+ const [start, end] = ref.endpoints;
+ const cardinality =
+ CARDINALITY_BY_RELATION[`${start.relation}:${end.relation}`];
+ if (!cardinality) return null;
+
+ return {
+ name:
+ ref.name ||
+ `fk_${start.tableName}_${start.fieldNames[0]}_${end.tableName}`,
+ startTableName: start.tableName,
+ startFieldNames: [...start.fieldNames],
+ endTableName: end.tableName,
+ endFieldNames: [...end.fieldNames],
+ cardinality,
+ deleteConstraint: constraintFor(ref.onDelete),
+ updateConstraint: constraintFor(ref.onUpdate),
+ };
+}
+
+function constraintFor(keyword) {
+ return (
+ CONSTRAINT_BY_KEYWORD[String(keyword).toLowerCase()] ?? Constraint.NONE
+ );
+}
+
+function foldInlineEnums(tables, enums) {
+ const enumsByName = new Map(enums.map((en) => [en.name.toUpperCase(), en]));
+ const folded = new Set();
+
+ for (const table of tables) {
+ for (const field of table.fields) {
+ const candidate = enumsByName.get(field.type);
+ if (!candidate) continue;
+
+ const expected = inlineEnumTypeName({
+ name: field.name,
+ values: candidate.values,
+ });
+ if (expected.toUpperCase() !== field.type) continue;
+
+ field.type = "ENUM";
+ field.values = [...candidate.values];
+ folded.add(candidate.name);
+ }
+ }
+
+ return enums.filter((en) => !folded.has(en.name));
+}
+
+export function parseDbml(src) {
+ const ast = parser.parse(src, "dbmlv2");
+
+ const tables = [];
+ const relationships = [];
+ const enums = [];
+
+ for (const schema of ast.schemas) {
+ tables.push(...schema.tables.map(parseTable));
+ relationships.push(...schema.refs.map(parseRef).filter(Boolean));
+ enums.push(
+ ...schema.enums.map((en) => ({
+ name: en.name,
+ values: en.values.map((value) => value.name),
+ })),
+ );
+ }
+
+ return {
+ tables,
+ relationships,
+ enums: foldInlineEnums(tables, enums),
+ };
+}
diff --git a/src/utils/dbml/reconcile.js b/src/utils/dbml/reconcile.js
new file mode 100644
index 00000000..3fe42b34
--- /dev/null
+++ b/src/utils/dbml/reconcile.js
@@ -0,0 +1,372 @@
+import { nanoid } from "nanoid";
+import { defaultBlue, tableWidth } from "../../data/constants";
+import { arrangeTables } from "../arrangeTables";
+import { isKeyword } from "../utils";
+import { isInlineEnumType, typeTakesSize } from "./types";
+
+const NEW_TABLE_GAP_X = 80;
+const NEW_TABLE_GAP_Y = 240;
+
+function sameList(a, b) {
+ if (!Array.isArray(a) || !Array.isArray(b)) return false;
+ return a.length === b.length && a.every((item, i) => item === b[i]);
+}
+
+function matchByName(parsedItems, baseItems, canRename) {
+ const matched = new Map();
+ const usedBase = new Set();
+
+ const claim = (parsedIndex, baseIndex) => {
+ matched.set(parsedIndex, baseItems[baseIndex]);
+ usedBase.add(baseIndex);
+ };
+
+ const findFreeBase = (predicate) =>
+ baseItems.findIndex((item, i) => !usedBase.has(i) && predicate(item));
+
+ parsedItems.forEach((parsed, i) => {
+ const exact = findFreeBase((item) => item.name === parsed.name);
+ if (exact !== -1) claim(i, exact);
+ });
+
+ parsedItems.forEach((parsed, i) => {
+ if (matched.has(i)) return;
+ const name = String(parsed.name).toLowerCase();
+ const insensitive = findFreeBase(
+ (item) => String(item.name).toLowerCase() === name,
+ );
+ if (insensitive !== -1) claim(i, insensitive);
+ });
+
+ const unmatchedParsed = parsedItems
+ .map((_, i) => i)
+ .filter((i) => !matched.has(i));
+ const unmatchedBase = baseItems
+ .map((_, i) => i)
+ .filter((i) => !usedBase.has(i));
+
+ unmatchedParsed.forEach((parsedIndex, position) => {
+ const baseIndex = unmatchedBase[position];
+ if (baseIndex === undefined) return;
+ if (!canRename(parsedItems[parsedIndex], baseItems[baseIndex])) return;
+ claim(parsedIndex, baseIndex);
+ });
+
+ return matched;
+}
+
+function sharesFieldName(parsedTable, baseTable) {
+ const baseNames = new Set((baseTable.fields ?? []).map((f) => f.name));
+ return parsedTable.fields.some((field) => baseNames.has(field.name));
+}
+
+function resolveType(parsed, base) {
+ if (isInlineEnumType(parsed.type) && isInlineEnumType(base.type)) {
+ return base.type;
+ }
+ return parsed.type;
+}
+
+function resolveDefault(parsed, base) {
+ const sameKeyword =
+ isKeyword(base.default) &&
+ String(base.default).toLowerCase() === String(parsed.default).toLowerCase();
+ return sameKeyword ? base.default : parsed.default;
+}
+
+function resolveSize(parsed, base, type, database) {
+ if (!typeTakesSize(type, database)) return base.size;
+ if (parsed.size === "") return undefined;
+ if (String(base.size) === String(parsed.size)) return base.size;
+ return parsed.size;
+}
+
+function createField(parsed) {
+ const field = {
+ id: nanoid(),
+ name: parsed.name,
+ type: parsed.type,
+ default: parsed.default,
+ check: "",
+ primary: parsed.primary,
+ unique: parsed.unique,
+ notNull: parsed.notNull,
+ increment: parsed.increment,
+ comment: parsed.comment,
+ };
+
+ if (parsed.size !== "") field.size = parsed.size;
+ if (isInlineEnumType(parsed.type)) field.values = parsed.values ?? [];
+
+ return field;
+}
+
+function mergeField(parsed, base, database) {
+ const type = resolveType(parsed, base);
+ const merged = {
+ ...base,
+ name: parsed.name,
+ type,
+ default: resolveDefault(parsed, base),
+ primary: parsed.primary,
+ unique: parsed.unique,
+ notNull: parsed.notNull,
+ increment: parsed.increment,
+ comment: parsed.comment,
+ };
+
+ if (isInlineEnumType(type)) {
+ merged.values = sameList(base.values, parsed.values)
+ ? base.values
+ : parsed.values ?? [];
+ }
+
+ const size = resolveSize(parsed, base, type, database);
+ if (size === undefined) delete merged.size;
+ else merged.size = size;
+
+ return merged;
+}
+
+function reconcileFields(parsedFields, baseFields, database) {
+ const matched = matchByName(parsedFields, baseFields, () => true);
+ return parsedFields.map((parsed, i) => {
+ const base = matched.get(i);
+ return base ? mergeField(parsed, base, database) : createField(parsed);
+ });
+}
+
+function mergeIndexEntry(parsed, base, position) {
+ return {
+ ...base,
+ id: position,
+ name: parsed.name,
+ fields: sameList(base?.fields, parsed.fields) ? base.fields : parsed.fields,
+ };
+}
+
+function reconcileIndexes(parsedIndexes, baseTable) {
+ const baseIndices = baseTable.indices ?? [];
+ const baseConstraints = baseTable.uniqueConstraints ?? [];
+ const constraintNames = new Set(
+ baseConstraints.filter((c) => c.name).map((c) => c.name),
+ );
+
+ const indices = [];
+ const uniqueConstraints = [];
+
+ for (const parsed of parsedIndexes) {
+ if (parsed.unique && constraintNames.has(parsed.name)) {
+ const base = baseConstraints.find((c) => c.name === parsed.name);
+ uniqueConstraints.push(
+ mergeIndexEntry(parsed, base, uniqueConstraints.length),
+ );
+ } else {
+ const base =
+ baseIndices.find((index) => index.name === parsed.name) ??
+ baseIndices[indices.length];
+ indices.push({
+ ...mergeIndexEntry(parsed, base, indices.length),
+ unique: parsed.unique,
+ });
+ }
+ }
+
+ return { indices, uniqueConstraints };
+}
+
+function mergeTable(parsed, base, database) {
+ return {
+ ...base,
+ name: parsed.name,
+ comment: parsed.comment,
+ color: parsed.color ?? base.color,
+ fields: reconcileFields(parsed.fields, base.fields ?? [], database),
+ ...reconcileIndexes(parsed.indices, base),
+ };
+}
+
+function createTable(parsed) {
+ return {
+ id: nanoid(),
+ name: parsed.name,
+ comment: parsed.comment,
+ color: parsed.color ?? defaultBlue,
+ fields: parsed.fields.map(createField),
+ indices: parsed.indices.map((index, i) => ({
+ id: i,
+ name: index.name,
+ fields: index.fields,
+ unique: index.unique,
+ })),
+ uniqueConstraints: [],
+ locked: false,
+ collapsed: false,
+ };
+}
+
+function placeNewTables(tables) {
+ const unplaced = tables.filter((table) => table.x === undefined);
+ if (!unplaced.length) return;
+
+ const placed = tables.filter((table) => table.x !== undefined);
+ if (!placed.length) {
+ arrangeTables({ tables });
+ return;
+ }
+
+ const x =
+ Math.max(...placed.map((table) => table.x + tableWidth)) + NEW_TABLE_GAP_X;
+ const y = Math.min(...placed.map((table) => table.y));
+
+ unplaced.forEach((table, i) => {
+ table.x = x;
+ table.y = y + i * NEW_TABLE_GAP_Y;
+ });
+}
+
+function keepFieldlessTables(tables, baseTables) {
+ const present = new Set(tables.map((table) => table.id));
+ baseTables.forEach((table, index) => {
+ if ((table.fields ?? []).length > 0 || present.has(table.id)) return;
+ tables.splice(Math.min(index, tables.length), 0, table);
+ });
+}
+
+function reconcileEnums(parsedEnums, baseEnums) {
+ const matched = matchByName(parsedEnums, baseEnums, () => true);
+ return parsedEnums.map((parsed, i) => {
+ const base = matched.get(i);
+ return {
+ ...base,
+ id: base?.id ?? nanoid(),
+ name: parsed.name,
+ values: sameList(base?.values, parsed.values)
+ ? base.values
+ : parsed.values,
+ };
+ });
+}
+
+function endpointSignature(rel) {
+ const pairs = rel.fields
+ .map((pair) => `${pair.startFieldId}>${pair.endFieldId}`)
+ .join(",");
+ return `${rel.startTableId}|${rel.endTableId}|${pairs}`;
+}
+
+function resolveEndpoints(parsed, tables) {
+ const startTable = tables.find(
+ (table) => table.name === parsed.startTableName,
+ );
+ const endTable = tables.find((table) => table.name === parsed.endTableName);
+ if (!startTable || !endTable) return null;
+
+ const fields = [];
+ for (let i = 0; i < parsed.startFieldNames.length; i++) {
+ const startField = startTable.fields.find(
+ (field) => field.name === parsed.startFieldNames[i],
+ );
+ const endField = endTable.fields.find(
+ (field) => field.name === parsed.endFieldNames[i],
+ );
+ if (!startField || !endField) return null;
+ fields.push({ startFieldId: startField.id, endFieldId: endField.id });
+ }
+
+ return { startTableId: startTable.id, endTableId: endTable.id, fields };
+}
+
+function reconcileRelationships(
+ parsedRelationships,
+ baseRelationships,
+ tables,
+) {
+ const resolved = parsedRelationships
+ .map((parsed) => {
+ const endpoints = resolveEndpoints(parsed, tables);
+ return endpoints ? { parsed, endpoints } : null;
+ })
+ .filter(Boolean);
+
+ const available = baseRelationships.slice();
+ const take = (predicate) => {
+ const index = available.findIndex(predicate);
+ if (index === -1) return null;
+ return available.splice(index, 1)[0];
+ };
+
+ return resolved.map(({ parsed, endpoints }) => {
+ const signature = endpointSignature({ ...endpoints });
+ const base =
+ take((rel) => rel.name === parsed.name) ??
+ take(
+ (rel) => endpointSignature(normalizeRelationship(rel)) === signature,
+ );
+
+ const fields = sameRelationshipFields(base?.fields, endpoints.fields)
+ ? base.fields
+ : endpoints.fields;
+
+ return {
+ ...base,
+ id: base?.id ?? nanoid(),
+ name: parsed.name,
+ startTableId: endpoints.startTableId,
+ endTableId: endpoints.endTableId,
+ fields,
+ startFieldId: fields[0].startFieldId,
+ endFieldId: fields[0].endFieldId,
+ cardinality: parsed.cardinality,
+ updateConstraint: parsed.updateConstraint,
+ deleteConstraint: parsed.deleteConstraint,
+ };
+ });
+}
+
+function normalizeRelationship(rel) {
+ return {
+ startTableId: rel.startTableId,
+ endTableId: rel.endTableId,
+ fields:
+ Array.isArray(rel.fields) && rel.fields.length
+ ? rel.fields
+ : [{ startFieldId: rel.startFieldId, endFieldId: rel.endFieldId }],
+ };
+}
+
+function sameRelationshipFields(a, b) {
+ if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) {
+ return false;
+ }
+ return a.every(
+ (pair, i) =>
+ pair.startFieldId === b[i].startFieldId &&
+ pair.endFieldId === b[i].endFieldId,
+ );
+}
+
+export function reconcileDbml(parsed, base, database) {
+ const baseTables = base?.tables ?? [];
+ const matched = matchByName(parsed.tables, baseTables, sharesFieldName);
+
+ const tables = parsed.tables.map((parsedTable, i) => {
+ const baseTable = matched.get(i);
+ return baseTable
+ ? mergeTable(parsedTable, baseTable, database)
+ : createTable(parsedTable);
+ });
+
+ placeNewTables(tables);
+ keepFieldlessTables(tables, baseTables);
+
+ return {
+ tables,
+ relationships: reconcileRelationships(
+ parsed.relationships,
+ base?.relationships ?? [],
+ tables,
+ ),
+ enums: reconcileEnums(parsed.enums, base?.enums ?? []),
+ };
+}
diff --git a/src/utils/dbml/types.js b/src/utils/dbml/types.js
new file mode 100644
index 00000000..6b483251
--- /dev/null
+++ b/src/utils/dbml/types.js
@@ -0,0 +1,43 @@
+import { dbToTypes } from "../../data/datatypes";
+
+const IDENT_SAFE_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+export function quoteIdentifier(name) {
+ const value = String(name ?? "");
+ if (IDENT_SAFE_RE.test(value)) return value;
+ return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+
+export function isInlineEnumType(type) {
+ return type === "ENUM" || type === "SET";
+}
+
+export function inlineEnumTypeName(field) {
+ const values = Array.isArray(field.values) ? field.values : [];
+ return `${field.name}_${values.join("_")}_t`;
+}
+
+export function typeTakesSize(type, database) {
+ const meta = dbToTypes[database][type];
+ return Boolean(meta && (meta.isSized || meta.hasPrecision));
+}
+
+export function dbmlTypeName(field, enumNamesByUpperCase) {
+ const type = String(field.type ?? "");
+ if (isInlineEnumType(type)) return inlineEnumTypeName(field);
+
+ const declared = enumNamesByUpperCase?.get(type.toUpperCase());
+ if (declared) return declared;
+
+ if (type.toUpperCase() === "TIMESTAMP WITH TIME ZONE") return "timestamptz";
+
+ return type.toLowerCase();
+}
+
+export function dbmlFieldSize(field, database) {
+ if (!typeTakesSize(field.type, database)) return "";
+ if (field.size === undefined || field.size === null || field.size === "") {
+ return "";
+ }
+ return `(${field.size})`;
+}
diff --git a/src/utils/exportAs/dbml.js b/src/utils/exportAs/dbml.js
index beb9dc25..da610328 100644
--- a/src/utils/exportAs/dbml.js
+++ b/src/utils/exportAs/dbml.js
@@ -1,20 +1,15 @@
-import { Cardinality } from "../../data/constants";
+import { Cardinality, Constraint } from "../../data/constants";
import { dbToTypes } from "../../data/datatypes";
import i18n from "../../i18n/i18n";
import { escapeQuotes } from "../exportSQL/shared";
import { isFunction, isKeyword, getRelationshipFields } from "../utils";
-
-const IDENT_SAFE_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
-
-function escapeIdentifier(s) {
- return String(s).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-
-function quoteIdentifier(name) {
- if (name == null) return name;
- const s = String(name);
- return IDENT_SAFE_RE.test(s) ? s : `"${escapeIdentifier(s)}"`;
-}
+import {
+ dbmlFieldSize,
+ dbmlTypeName,
+ inlineEnumTypeName,
+ isInlineEnumType,
+ quoteIdentifier,
+} from "../dbml/types";
function parseDefaultDbml(field, database) {
if (isFunction(field.default)) {
@@ -41,16 +36,14 @@ function columnDefault(field, database) {
}
function columnSettings(field, database) {
- let constraints = [];
-
- field.primary && constraints.push("pk");
- field.increment && constraints.push("increment");
- field.notNull && constraints.push("not null");
- field.unique && constraints.push("unique");
- constraints.push(columnDefault(field, database));
- constraints.push(columnComment(field));
-
- constraints = constraints.filter((x) => Boolean(x));
+ const constraints = [
+ field.primary && "pk",
+ field.increment && "increment",
+ field.notNull && "not null",
+ field.unique && "unique",
+ columnDefault(field, database),
+ columnComment(field),
+ ].filter(Boolean);
if (!constraints.length) {
return "";
@@ -70,18 +63,11 @@ function cardinality(rel) {
case i18n.t(Cardinality.MANY_TO_ONE):
case Cardinality.MANY_TO_ONE:
return ">";
+ default:
+ return null;
}
}
-function fieldSize(field, database) {
- const typeMetadata = dbToTypes[database][field.type];
-
- if ((typeMetadata?.isSized || typeMetadata?.hasPrecision) && field.size)
- return `(${field.size})`;
-
- return "";
-}
-
function processComment(comment) {
if (comment.includes("\n")) {
return `'''${comment}'''`;
@@ -98,101 +84,129 @@ function columnComment(field) {
return `note: ${processComment(field.comment)}`;
}
-function processType(type) {
- // TODO: remove after a while
- if (type.toUpperCase() === "TIMESTAMP WITH TIME ZONE") {
- return "timestamptz";
- }
+function enumBlock(name, values) {
+ const body = values.map((value) => `\t${quoteIdentifier(value)}`).join("\n");
+ return `enum ${quoteIdentifier(name)} {\n${body}\n}`;
+}
- return type.toLowerCase();
+function enumNameIndex(enums) {
+ return new Map(enums.map((en) => [String(en.name).toUpperCase(), en.name]));
}
-export function toDBML(diagram) {
- const columnRef = (tableName, fieldNames) => {
- const cols = fieldNames.map((n) => quoteIdentifier(n));
- const colPart = cols.length === 1 ? cols[0] : `(${cols.join(", ")})`;
- return `${quoteIdentifier(tableName)}.${colPart}`;
- };
-
- const generateRelString = (rel) => {
- const { fields: startTableFields, name: startTableName } =
- diagram.tables.find((t) => t.id === rel.startTableId);
- const { fields: endTableFields, name: endTableName } = diagram.tables.find(
- (t) => t.id === rel.endTableId,
- );
-
- const pairs = getRelationshipFields(rel);
- const startFieldNames = pairs.map(
- (p) => startTableFields.find((f) => f.id === p.startFieldId)?.name,
- );
- const endFieldNames = pairs.map(
- (p) => endTableFields.find((f) => f.id === p.endFieldId)?.name,
- );
-
- return `Ref ${quoteIdentifier(rel.name)} {\n\t${columnRef(startTableName, startFieldNames)} ${cardinality(rel)} ${columnRef(endTableName, endFieldNames)} [ delete: ${rel.deleteConstraint.toLowerCase()}, update: ${rel.updateConstraint.toLowerCase()} ]\n}`;
- };
-
- let enumDefinitions = "";
-
- for (const table of diagram.tables) {
+function inlineEnumBlocks(tables) {
+ const declared = new Set();
+ const blocks = [];
+
+ for (const table of tables) {
for (const field of table.fields) {
- if (
- (field.type === "ENUM" || field.type === "SET") &&
- Array.isArray(field.values)
- ) {
- enumDefinitions += `enum ${quoteIdentifier(`${field.name}_${field.values.join("_")}_t`)} {\n\t${field.values.map((v) => quoteIdentifier(v)).join("\n\t")}\n}\n\n`;
- }
+ if (!isInlineEnumType(field.type) || !Array.isArray(field.values))
+ continue;
+
+ const name = inlineEnumTypeName(field);
+ if (declared.has(name)) continue;
+
+ declared.add(name);
+ blocks.push(enumBlock(name, field.values));
}
}
- return `${diagram.enums
- .map(
- (en) =>
- `enum ${quoteIdentifier(en.name)} {\n${en.values.map((v) => `\t${quoteIdentifier(v)}`).join("\n")}\n}\n\n`,
- )
- .join("\n\n")}${enumDefinitions}${diagram.tables
+ return blocks;
+}
+
+function indexEntry(fields, name, unique) {
+ if (!Array.isArray(fields) || !fields.length) return null;
+
+ const settings = [
+ name ? `name: '${escapeQuotes(String(name))}'` : "",
+ unique ? "unique" : "",
+ ].filter(Boolean);
+ const columns = fields.map((field) => quoteIdentifier(field)).join(", ");
+
+ return `\t\t(${columns})${settings.length ? ` [ ${settings.join(", ")} ]` : ""}`;
+}
+
+function indexesBlock(table) {
+ const entries = [
+ ...(table.indices ?? []).map((index) =>
+ indexEntry(index.fields, index.name, index.unique),
+ ),
+ ...(table.uniqueConstraints ?? []).map((constraint) =>
+ indexEntry(constraint.fields, constraint.name, true),
+ ),
+ ].filter(Boolean);
+
+ if (!entries.length) return "";
+
+ return `\n\n\tindexes {\n${entries.join("\n")}\n\t}`;
+}
+
+function tableBlock(table, database, enumNames) {
+ const headerColor = table.color ? ` [headercolor: ${table.color}]` : "";
+ const fields = table.fields
.map(
- (table) =>
- `Table ${quoteIdentifier(table.name)} [headercolor: ${table.color}] {\n${table.fields
- .map(
- (field) =>
- `\t${quoteIdentifier(field.name)} ${
- field.type === "ENUM" || field.type === "SET"
- ? quoteIdentifier(`${field.name}_${field.values.join("_")}_t`)
- : processType(field.type)
- }${fieldSize(
- field,
- diagram.database,
- )}${columnSettings(field, diagram.database)}`,
- )
- .join("\n")}${(() => {
- const indexEntries = table.indices.map(
- (index) =>
- `\t\t(${index.fields
- .map((f) => quoteIdentifier(f))
- .join(", ")}) [ name: '${index.name}'${
- index.unique ? ", unique" : ""
- } ]`,
- );
- const uniqueEntries = (table.uniqueConstraints || [])
- .filter((uc) => Array.isArray(uc.fields) && uc.fields.length > 0)
- .map(
- (uc) =>
- `\t\t(${uc.fields
- .map((f) => quoteIdentifier(f))
- .join(", ")}) [ name: '${uc.name}', unique ]`,
- );
- const entries = [...indexEntries, ...uniqueEntries];
- return entries.length > 0
- ? "\n\n\tindexes {\n" + entries.join("\n") + "\n\t}"
- : "";
- })()}${
- table.comment && table.comment.trim() !== ""
- ? `\n\n\tNote: ${processComment(table.comment)}`
- : ""
- }\n}`,
+ (field) =>
+ `\t${quoteIdentifier(field.name)} ${quoteIdentifier(
+ dbmlTypeName(field, enumNames),
+ )}${dbmlFieldSize(field, database)}${columnSettings(field, database)}`,
)
- .join("\n\n")}\n\n${diagram.relationships
- .map((rel) => generateRelString(rel))
- .join("\n\n")}`;
+ .join("\n");
+ const comment =
+ table.comment && table.comment.trim() !== ""
+ ? `\n\n\tNote: ${processComment(table.comment)}`
+ : "";
+
+ return `Table ${quoteIdentifier(table.name)}${headerColor} {\n${fields}${indexesBlock(table)}${comment}\n}`;
+}
+
+function columnRef(tableName, fieldNames) {
+ const columns = fieldNames.map((name) => quoteIdentifier(name));
+ const target = columns.length === 1 ? columns[0] : `(${columns.join(", ")})`;
+ return `${quoteIdentifier(tableName)}.${target}`;
+}
+
+function constraintKeyword(constraint) {
+ return String(constraint ?? Constraint.NONE).toLowerCase();
+}
+
+function refBlock(rel, tables) {
+ const startTable = tables.find((table) => table.id === rel.startTableId);
+ const endTable = tables.find((table) => table.id === rel.endTableId);
+ if (!startTable || !endTable) return null;
+
+ const symbol = cardinality(rel);
+ if (!symbol) return null;
+
+ const pairs = getRelationshipFields(rel);
+ const startFields = pairs.map(
+ (pair) => startTable.fields.find((f) => f.id === pair.startFieldId)?.name,
+ );
+ const endFields = pairs.map(
+ (pair) => endTable.fields.find((f) => f.id === pair.endFieldId)?.name,
+ );
+ if (startFields.some((name) => !name) || endFields.some((name) => !name)) {
+ return null;
+ }
+
+ const name = rel.name ? `${quoteIdentifier(rel.name)} ` : "";
+ const settings = `[ delete: ${constraintKeyword(rel.deleteConstraint)}, update: ${constraintKeyword(rel.updateConstraint)} ]`;
+
+ return `Ref ${name}{\n\t${columnRef(startTable.name, startFields)} ${symbol} ${columnRef(endTable.name, endFields)} ${settings}\n}`;
+}
+
+export function toDBML(diagram) {
+ const database = diagram.database;
+ const enums = diagram.enums ?? [];
+ const tables = (diagram.tables ?? []).filter(
+ (table) => (table.fields ?? []).length > 0,
+ );
+ const enumNames = enumNameIndex(enums);
+
+ return [
+ ...enums.map((en) => enumBlock(en.name, en.values ?? [])),
+ ...inlineEnumBlocks(tables),
+ ...tables.map((table) => tableBlock(table, database, enumNames)),
+ ...(diagram.relationships ?? []).map((rel) => refBlock(rel, tables)),
+ ]
+ .filter(Boolean)
+ .join("\n\n");
}
diff --git a/src/utils/importFrom/dbml.js b/src/utils/importFrom/dbml.js
index 5ef3c5f9..af86c851 100644
--- a/src/utils/importFrom/dbml.js
+++ b/src/utils/importFrom/dbml.js
@@ -1,131 +1,7 @@
-import { Parser } from "@dbml/core";
-import { arrangeTables } from "../arrangeTables";
-import { Cardinality, Constraint } from "../../data/constants";
-import { nanoid } from "nanoid";
+import { parseDbml } from "../dbml/parse";
+import { reconcileDbml } from "../dbml/reconcile";
-const parser = new Parser();
-
-export function fromDBML(src) {
- const ast = parser.parse(src, "dbmlv2");
-
- const tables = [];
- const enums = [];
- const relationships = [];
-
- for (const schema of ast.schemas) {
- for (const table of schema.tables) {
- let parsedTable = {};
- parsedTable.id = nanoid();
- parsedTable.name = table.name;
- parsedTable.comment = table.note ?? "";
- parsedTable.color = table.headerColor ?? "#175e7a";
- parsedTable.fields = [];
- parsedTable.indices = [];
- parsedTable.uniqueConstraints = [];
-
- for (const column of table.fields) {
- const field = {};
-
- field.id = nanoid();
- field.name = column.name;
- field.type = column.type.type_name.toUpperCase();
- field.default = column.dbdefault?.value ?? "";
- field.check = "";
- field.primary = !!column.pk;
- field.unique = !!column.pk;
- field.notNull = !!column.not_null;
- field.increment = !!column.increment;
- field.comment = column.note ?? "";
-
- parsedTable.fields.push(field);
- }
-
- for (const idx of table.indexes) {
- const parsedIndex = {};
-
- parsedIndex.id = idx.id - 1;
- parsedIndex.fields = idx.columns.map((x) => x.value);
- parsedIndex.name =
- idx.name ?? `${parsedTable.name}_index_${parsedIndex.id}`;
- parsedIndex.unique = !!idx.unique;
-
- parsedTable.indices.push(parsedIndex);
- }
-
- tables.push(parsedTable);
- }
-
- for (const ref of schema.refs) {
- const startTableName = ref.endpoints[0].tableName;
- const endTableName = ref.endpoints[1].tableName;
- const startFieldNames = ref.endpoints[0].fieldNames;
- const endFieldNames = ref.endpoints[1].fieldNames;
- const startFieldName = startFieldNames[0];
-
- const startTable = tables.find((t) => t.name === startTableName);
- if (!startTable) continue;
-
- const endTable = tables.find((t) => t.name === endTableName);
- if (!endTable) continue;
-
- const fieldPairs = [];
- for (let i = 0; i < startFieldNames.length; i++) {
- const sf = startTable.fields.find((f) => f.name === startFieldNames[i]);
- const ef = endTable.fields.find((f) => f.name === endFieldNames[i]);
- if (!sf || !ef) break;
- fieldPairs.push({ startFieldId: sf.id, endFieldId: ef.id });
- }
- if (fieldPairs.length !== startFieldNames.length) continue;
-
- const relationship = {};
-
- relationship.name =
- "fk_" + startTableName + "_" + startFieldName + "_" + endTableName;
- relationship.startTableId = startTable.id;
- relationship.endTableId = endTable.id;
- relationship.fields = fieldPairs;
- relationship.endFieldId = fieldPairs[0].endFieldId;
- relationship.startFieldId = fieldPairs[0].startFieldId;
- relationship.id = nanoid();
-
- relationship.updateConstraint = ref.onDelete
- ? ref.onDelete[0].toUpperCase() + ref.onDelete.substring(1)
- : Constraint.NONE;
- relationship.deleteConstraint = ref.onUpdate
- ? ref.onUpdate[0].toUpperCase() + ref.onUpdate.substring(1)
- : Constraint.NONE;
-
- const startRelation = ref.endpoints[0].relation;
- const endRelation = ref.endpoints[1].relation;
-
- if (startRelation === "*" && endRelation === "1") {
- relationship.cardinality = Cardinality.MANY_TO_ONE;
- }
-
- if (startRelation === "1" && endRelation === "*") {
- relationship.cardinality = Cardinality.ONE_TO_MANY;
- }
-
- if (startRelation === "1" && endRelation === "1") {
- relationship.cardinality = Cardinality.ONE_TO_ONE;
- }
-
- relationships.push(relationship);
- }
-
- for (const schemaEnum of schema.enums) {
- const parsedEnum = {};
-
- parsedEnum.name = schemaEnum.name;
- parsedEnum.values = schemaEnum.values.map((x) => x.name);
-
- enums.push(parsedEnum);
- }
- }
-
- const diagram = { tables, enums, relationships };
-
- arrangeTables(diagram);
-
- return diagram;
+export function fromDBML(src, database) {
+ const parsed = parseDbml(src);
+ return reconcileDbml(parsed, null, database);
}