Skip to content

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

fix(dbml-export): merge field attributes into single brackets and fix schema syntax (#790)

Jonathan Fishner309ee9cb0ff1
diff --git a/src/lib/dbml/dbml-export/__tests__/dbml-export-issue-fix.test.ts b/src/lib/dbml/dbml-export/__tests__/dbml-export-issue-fix.test.ts
new file mode 100644
index 00000000..3a554d38
--- /dev/null
+++ b/src/lib/dbml/dbml-export/__tests__/dbml-export-issue-fix.test.ts
@@ -0,0 +1,216 @@
+import { describe, it, expect } from 'vitest';
+import { generateDBMLFromDiagram } from '../dbml-export';
+import { DatabaseType } from '@/lib/domain/database-type';
+import type { Diagram } from '@/lib/domain/diagram';
+
+describe('DBML Export - Issue Fixes', () => {
+ it('should merge field attributes into a single bracket instead of multiple', () => {
+ const diagram: Diagram = {
+ id: 'test-diagram',
+ name: 'Test',
+ databaseType: DatabaseType.POSTGRESQL,
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ tables: [
+ {
+ id: 'table1',
+ name: 'service_tenant',
+ x: 0,
+ y: 0,
+ fields: [
+ {
+ id: 'field1',
+ name: 'tenant_id',
+ type: { id: 'bigint', name: 'bigint' },
+ primaryKey: true,
+ nullable: false,
+ unique: false,
+ collation: null,
+ default: null,
+ characterMaximumLength: null,
+ createdAt: Date.now(),
+ },
+ ],
+ indexes: [],
+ color: 'blue',
+ isView: false,
+ createdAt: Date.now(),
+ },
+ {
+ id: 'table2',
+ name: 'users',
+ x: 0,
+ y: 0,
+ fields: [
+ {
+ id: 'field2',
+ name: 'id',
+ type: { id: 'bigint', name: 'bigint' },
+ primaryKey: true,
+ nullable: false,
+ unique: false,
+ collation: null,
+ default: null,
+ characterMaximumLength: null,
+ createdAt: Date.now(),
+ },
+ ],
+ indexes: [],
+ color: 'blue',
+ isView: false,
+ createdAt: Date.now(),
+ },
+ ],
+ relationships: [
+ {
+ id: 'rel1',
+ name: 'fk_users_tenant',
+ sourceTableId: 'table2',
+ sourceFieldId: 'field2',
+ targetTableId: 'table1',
+ targetFieldId: 'field1',
+ sourceCardinality: 'many',
+ targetCardinality: 'one',
+ createdAt: Date.now(),
+ },
+ ],
+ };
+
+ const result = generateDBMLFromDiagram(diagram);
+
+ // Check that inline DBML has merged attributes in a single bracket
+ expect(result.inlineDbml).toContain(
+ '"id" bigint [pk, not null, ref: < "service_tenant"."tenant_id"]'
+ );
+
+ // Should NOT have separate brackets like [pk, not null] [ref: < ...]
+ expect(result.inlineDbml).not.toMatch(/\[pk, not null\]\s*\[ref:/);
+ });
+
+ it('should handle table names with schema using proper quoted syntax', () => {
+ const diagram: Diagram = {
+ id: 'test-diagram',
+ name: 'Test',
+ databaseType: DatabaseType.POSTGRESQL,
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ tables: [
+ {
+ id: 'table1',
+ name: 'users',
+ schema: 'public',
+ x: 0,
+ y: 0,
+ fields: [
+ {
+ id: 'field1',
+ name: 'id',
+ type: { id: 'bigint', name: 'bigint' },
+ primaryKey: true,
+ nullable: false,
+ unique: false,
+ collation: null,
+ default: null,
+ characterMaximumLength: null,
+ createdAt: Date.now(),
+ },
+ ],
+ indexes: [],
+ color: 'blue',
+ isView: false,
+ createdAt: Date.now(),
+ },
+ ],
+ relationships: [],
+ };
+
+ const result = generateDBMLFromDiagram(diagram);
+
+ // Should use quoted syntax for schema.table
+ expect(result.standardDbml).toContain('Table "public"."users"');
+
+ // Should NOT use bracket syntax like [public].[users]
+ expect(result.standardDbml).not.toContain('[public].[users]');
+ });
+
+ it('should preserve schema in table references within relationships', () => {
+ const diagram: Diagram = {
+ id: 'test-diagram',
+ name: 'Test',
+ databaseType: DatabaseType.POSTGRESQL,
+ createdAt: new Date(),
+ updatedAt: new Date(),
+ tables: [
+ {
+ id: 'table1',
+ name: 'tenant',
+ schema: 'service',
+ x: 0,
+ y: 0,
+ fields: [
+ {
+ id: 'field1',
+ name: 'id',
+ type: { id: 'bigint', name: 'bigint' },
+ primaryKey: true,
+ nullable: false,
+ unique: false,
+ collation: null,
+ default: null,
+ characterMaximumLength: null,
+ createdAt: Date.now(),
+ },
+ ],
+ indexes: [],
+ color: 'blue',
+ isView: false,
+ createdAt: Date.now(),
+ },
+ {
+ id: 'table2',
+ name: 'users',
+ schema: 'public',
+ x: 0,
+ y: 0,
+ fields: [
+ {
+ id: 'field2',
+ name: 'tenant_id',
+ type: { id: 'bigint', name: 'bigint' },
+ primaryKey: false,
+ nullable: false,
+ unique: false,
+ collation: null,
+ default: null,
+ characterMaximumLength: null,
+ createdAt: Date.now(),
+ },
+ ],
+ indexes: [],
+ color: 'blue',
+ isView: false,
+ createdAt: Date.now(),
+ },
+ ],
+ relationships: [
+ {
+ id: 'rel1',
+ name: 'fk_users_tenant',
+ sourceTableId: 'table2',
+ sourceFieldId: 'field2',
+ targetTableId: 'table1',
+ targetFieldId: 'field1',
+ sourceCardinality: 'many',
+ targetCardinality: 'one',
+ createdAt: Date.now(),
+ },
+ ],
+ };
+
+ const result = generateDBMLFromDiagram(diagram);
+
+ // Check inline DBML preserves schema in references
+ // The foreign key is on the users.tenant_id field, referencing service.tenant.id
+ expect(result.inlineDbml).toContain('ref: < "service"."tenant"."id"');
+ });
+});
diff --git a/src/lib/dbml/dbml-export/dbml-export.ts b/src/lib/dbml/dbml-export/dbml-export.ts
index 85e1bbfd..044a2f02 100644
--- a/src/lib/dbml/dbml-export/dbml-export.ts
+++ b/src/lib/dbml/dbml-export/dbml-export.ts
@@ -210,14 +210,17 @@ export const sanitizeSQLforDBML = (sql: string): string => {
// Post-process DBML to convert separate Ref statements to inline refs
const convertToInlineRefs = (dbml: string): string => {
- // Extract all Ref statements - Corrected pattern
+ // Extract all Ref statements - Updated pattern to handle schema.table.field format
+ // Matches both "table"."field" and "schema"."table"."field" formats
const refPattern =
- /Ref\s+"([^"]+)"\s*:\s*"([^"]+)"\."([^"]+)"\s*([<>*])\s*"([^"]+)"\."([^"]+)"/g;
+ /Ref\s+"([^"]+)"\s*:\s*(?:"([^"]+)"\.)?"([^"]+)"\."([^"]+)"\s*([<>*])\s*(?:"([^"]+)"\.)?"([^"]+)"\."([^"]+)"/g;
const refs: Array<{
refName: string;
+ sourceSchema?: string;
sourceTable: string;
sourceField: string;
direction: string;
+ targetSchema?: string;
targetTable: string;
targetField: string;
}> = [];
@@ -226,27 +229,52 @@ const convertToInlineRefs = (dbml: string): string => {
while ((match = refPattern.exec(dbml)) !== null) {
refs.push({
refName: match[1], // Reference name
- sourceTable: match[2], // Source table
- sourceField: match[3], // Source field
- direction: match[4], // Direction (<, >)
- targetTable: match[5], // Target table
- targetField: match[6], // Target field
+ sourceSchema: match[2] || undefined, // Source schema (optional)
+ sourceTable: match[3], // Source table
+ sourceField: match[4], // Source field
+ direction: match[5], // Direction (<, >)
+ targetSchema: match[6] || undefined, // Target schema (optional)
+ targetTable: match[7], // Target table
+ targetField: match[8], // Target field
});
}
- // Extract all table definitions - Corrected pattern and handling
+ // Extract all table definitions - Support both quoted and bracketed table names
const tables: {
- [key: string]: { start: number; end: number; content: string };
+ [key: string]: {
+ start: number;
+ end: number;
+ content: string;
+ fullMatch: string;
+ };
} = {};
- const tablePattern = /Table\s+"([^"]+)"\s*{([^}]*)}/g; // Simpler pattern, assuming content doesn't have {}
+ // Updated pattern to handle various table name formats including schema.table
+ const tablePattern =
+ /Table\s+(?:"([^"]+)"(?:\."([^"]+)")?|(\[?[^\s[]+\]?\.\[?[^\s\]]+\]?)|(\[?[^\s[{]+\]?))\s*{([^}]*)}/g;
let tableMatch;
while ((tableMatch = tablePattern.exec(dbml)) !== null) {
- const tableName = tableMatch[1];
- tables[tableName] = {
+ // Extract table name - handle schema.table format
+ let tableName;
+ if (tableMatch[1] && tableMatch[2]) {
+ // Format: "schema"."table"
+ tableName = `${tableMatch[1]}.${tableMatch[2]}`;
+ } else if (tableMatch[1]) {
+ // Format: "table" (no schema)
+ tableName = tableMatch[1];
+ } else {
+ // Other formats
+ tableName = tableMatch[3] || tableMatch[4];
+ }
+
+ // Clean up any bracket syntax from table names
+ const cleanTableName = tableName.replace(/\[([^\]]+)\]/g, '$1');
+
+ tables[cleanTableName] = {
start: tableMatch.index,
end: tableMatch.index + tableMatch[0].length,
- content: tableMatch[2],
+ content: tableMatch[5],
+ fullMatch: tableMatch[0],
};
}
@@ -262,38 +290,66 @@ const convertToInlineRefs = (dbml: string): string => {
let targetTableName, fieldNameToModify, inlineRefSyntax;
if (ref.direction === '<') {
- targetTableName = ref.targetTable;
+ targetTableName = ref.targetSchema
+ ? `${ref.targetSchema}.${ref.targetTable}`
+ : ref.targetTable;
fieldNameToModify = ref.targetField;
- inlineRefSyntax = `[ref: < "${ref.sourceTable}"."${ref.sourceField}"]`;
+ const sourceRef = ref.sourceSchema
+ ? `"${ref.sourceSchema}"."${ref.sourceTable}"."${ref.sourceField}"`
+ : `"${ref.sourceTable}"."${ref.sourceField}"`;
+ inlineRefSyntax = `ref: < ${sourceRef}`;
} else {
- targetTableName = ref.sourceTable;
+ targetTableName = ref.sourceSchema
+ ? `${ref.sourceSchema}.${ref.sourceTable}`
+ : ref.sourceTable;
fieldNameToModify = ref.sourceField;
- inlineRefSyntax = `[ref: > "${ref.targetTable}"."${ref.targetField}"]`;
+ const targetRef = ref.targetSchema
+ ? `"${ref.targetSchema}"."${ref.targetTable}"."${ref.targetField}"`
+ : `"${ref.targetTable}"."${ref.targetField}"`;
+ inlineRefSyntax = `ref: > ${targetRef}`;
}
const tableData = tableMap.get(targetTableName);
if (tableData) {
+ // Updated pattern to capture field definition and all existing attributes in brackets
const fieldPattern = new RegExp(
- `("(${fieldNameToModify})"[^\n]*?)([ \t]*[[].*?[]])?([ \t]*//.*)?$`,
- 'm'
+ `^([ \t]*"${fieldNameToModify}"[^\\n]*?)(?:\\s*(\\[[^\\]]*\\]))*\\s*(//.*)?$`,
+ 'gm'
);
let newContent = tableData.content;
newContent = newContent.replace(
fieldPattern,
- (
- lineMatch,
- fieldPart,
- _fieldName,
- existingAttributes,
- commentPart
- ) => {
+ (lineMatch, fieldPart, existingBrackets, commentPart) => {
// Avoid adding duplicate refs
- if (lineMatch.includes('[ref:')) {
+ if (lineMatch.includes('ref:')) {
return lineMatch;
}
- return `${fieldPart.trim()} ${inlineRefSyntax}${existingAttributes || ''}${commentPart || ''}`;
+ // Collect all attributes from existing brackets
+ const allAttributes: string[] = [];
+ if (existingBrackets) {
+ // Extract all bracket contents
+ const bracketPattern = /\[([^\]]*)\]/g;
+ let bracketMatch;
+ while (
+ (bracketMatch = bracketPattern.exec(lineMatch)) !==
+ null
+ ) {
+ const content = bracketMatch[1].trim();
+ if (content) {
+ allAttributes.push(content);
+ }
+ }
+ }
+
+ // Add the new ref
+ allAttributes.push(inlineRefSyntax);
+
+ // Combine all attributes into a single bracket
+ const combinedAttributes = allAttributes.join(', ');
+
+ return `${fieldPart.trim()} [${combinedAttributes}]${commentPart || ''}`;
}
);
@@ -312,9 +368,15 @@ const convertToInlineRefs = (dbml: string): string => {
([, a], [, b]) => a.start - b.start
);
- for (const [tableName, tableData] of sortedTables) {
+ for (const [, tableData] of sortedTables) {
reconstructedDbml += dbml.substring(lastIndex, tableData.start);
- reconstructedDbml += `Table "${tableName}" {${tableData.content}}`;
+ // Preserve the original table definition format but with updated content
+ const originalTableDef = tableData.fullMatch;
+ const updatedTableDef = originalTableDef.replace(
+ /{[^}]*}/,
+ `{${tableData.content}}`
+ );
+ reconstructedDbml += updatedTableDef;
lastIndex = tableData.end;
}
reconstructedDbml += dbml.substring(lastIndex);
@@ -410,6 +472,64 @@ const normalizeCharTypeFormat = (dbml: string): string => {
.replace(/character \(([0-9]+)\)/g, 'character($1)');
};
+// Fix table definitions with incorrect bracket syntax
+const fixTableBracketSyntax = (dbml: string): string => {
+ // Fix patterns like Table [schema].[table] to Table "schema"."table"
+ return dbml.replace(
+ /Table\s+\[([^\]]+)\]\.\[([^\]]+)\]/g,
+ 'Table "$1"."$2"'
+ );
+};
+
+// Restore schema information that may have been stripped by the DBML importer
+const restoreTableSchemas = (dbml: string, diagram: Diagram): string => {
+ if (!diagram.tables) return dbml;
+
+ let result = dbml;
+
+ // For each table with a schema, restore it in the DBML
+ diagram.tables.forEach((table) => {
+ if (table.schema) {
+ // Match table definition without schema (e.g., Table "users" {)
+ const tablePattern = new RegExp(
+ `Table\\s+"${table.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"\\s*{`,
+ 'g'
+ );
+ const schemaTableName = `Table "${table.schema}"."${table.name}" {`;
+ result = result.replace(tablePattern, schemaTableName);
+
+ // Update references in Ref statements more carefully
+ // Match patterns like: Ref "name":"tablename"."field" or < "tablename"."field"
+ const escapedTableName = table.name.replace(
+ /[.*+?^${}()|[\]\\]/g,
+ '\\$&'
+ );
+
+ // Pattern 1: In Ref definitions - :"tablename"."field"
+ const refDefPattern = new RegExp(
+ `(Ref\\s+"[^"]+")\\s*:\\s*"${escapedTableName}"\\."([^"]+)"`,
+ 'g'
+ );
+ result = result.replace(
+ refDefPattern,
+ `$1:"${table.schema}"."${table.name}"."$2"`
+ );
+
+ // Pattern 2: In Ref targets - [<>] "tablename"."field"
+ const refTargetPattern = new RegExp(
+ `([<>])\\s*"${escapedTableName}"\\."([^"]+)"`,
+ 'g'
+ );
+ result = result.replace(
+ refTargetPattern,
+ `$1 "${table.schema}"."${table.name}"."$2"`
+ );
+ }
+ });
+
+ return result;
+};
+
export interface DBMLExportResult {
standardDbml: string;
inlineDbml: string;
@@ -577,12 +697,17 @@ export function generateDBMLFromDiagram(diagram: Diagram): DBMLExportResult {
}
standard = normalizeCharTypeFormat(
- importer.import(
- baseScript,
- databaseTypeToImportFormat(diagram.databaseType)
+ fixTableBracketSyntax(
+ importer.import(
+ baseScript,
+ databaseTypeToImportFormat(diagram.databaseType)
+ )
)
);
+ // Restore schema information that may have been stripped by DBML importer
+ standard = restoreTableSchemas(standard, diagram);
+
// Prepend Enum DBML to the standard output
standard = enumsDBML + '\n' + standard;