Free, simple, and intuitive online database diagram editor and SQL generator.
JavaScript databasedatabase-designdatabase-diagramdatabase-schemadbmldiagram-editoreditorer-diagramerderdiagramindexeddbmariadbmcporacle-databaseoracle-dbpostgresqlschema-designsqlsql-serversqlite
Make the dbml editor editable (#1091)
1ilit9f5f7a21302a
diff --git a/src/components/CodeEditor/index.jsx b/src/components/CodeEditor/index.jsxindex 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.jsxindex 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.jsxindex 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.jsxindex 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 (<CodeEditorshowCopyButton- 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.jsxindex 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.Panelheader={<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.jsxindex 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} />) : (<Tabstype="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.jsxindex 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.jsindex 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.jsindex 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.jsnew file mode 100644index 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.jsindex 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.jsindex 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);}