Database diagrams editor that allows you to visualize and design your DB with a single query.
TypeScript databasedbdb-migrationeditorerdmariadbmssqlmysqlpostgresqlreactreact-flowschema-migrationssqlsqlitetypescriptvisualizationxyflow
fix: add automatic data type synonym resolution for PostgreSQL imports (#994)
Guy Ben-Aharonfbd04e9d5eb1
diff --git a/src/lib/data/data-types/data-types.ts b/src/lib/data/data-types/data-types.tsindex 701da23b..0f099bd0 100644--- a/src/lib/data/data-types/data-types.ts+++ b/src/lib/data/data-types/data-types.ts@@ -5,7 +5,10 @@ import { clickhouseDataTypes } from './clickhouse-data-types';import { genericDataTypes } from './generic-data-types';import { mariadbDataTypes } from './mariadb-data-types';import { mysqlDataTypes } from './mysql-data-types';-import { postgresDataTypes } from './postgres-data-types';+import {+ getPostgresPreferredSynonym,+ postgresDataTypes,+} from './postgres-data-types';import { sqlServerDataTypes } from './sql-server-data-types';import { sqliteDataTypes } from './sqlite-data-types';import { oracleDataTypes } from './oracle-data-types';@@ -197,3 +200,43 @@ export const supportsArrayDataType = (dataTypeName.toLowerCase() as (typeof ARRAY_INCOMPATIBLE_TYPES)[number]);};++/**+ * Resolves a data type to its preferred synonym if one exists for the given database type.+ *+ * This function acts as a dispatcher to database-specific synonym resolution functions.+ * Currently supports PostgreSQL synonyms.+ *+ * @param typeName - The name of the data type to check (case-insensitive)+ * @param databaseType - The database type (e.g., PostgreSQL, MySQL, etc.)+ * @returns The DataTypeData of the preferred synonym, or null if the type+ * is already the preferred form, has no synonyms, or the database type+ * doesn't have synonym mappings+ *+ * @example+ * ```ts+ * getPreferredSynonym('character varying', DatabaseType.POSTGRESQL)+ * // Returns: { name: 'varchar', id: 'varchar', ... }+ *+ * getPreferredSynonym('varchar', DatabaseType.POSTGRESQL)+ * // Returns: null (already the preferred form)+ *+ * getPreferredSynonym('character varying', DatabaseType.MYSQL)+ * // Returns: null (MySQL synonym mappings not implemented)+ * ```+ */+export const getPreferredSynonym = (+ typeName: string,+ databaseType: DatabaseType+): DataTypeData | null => {+ const nameLower = typeName.toLowerCase().trim();++ if (+ databaseType === DatabaseType.POSTGRESQL ||+ databaseType === DatabaseType.COCKROACHDB+ ) {+ return getPostgresPreferredSynonym(nameLower);+ }++ return null;+};diff --git a/src/lib/data/data-types/postgres-data-types.ts b/src/lib/data/data-types/postgres-data-types.tsindex 65a8c156..5bf8319b 100644--- a/src/lib/data/data-types/postgres-data-types.ts+++ b/src/lib/data/data-types/postgres-data-types.ts@@ -2,7 +2,9 @@ import type { DataTypeData } from './data-types';export const postgresDataTypes: readonly DataTypeData[] = [// Level 1 - Most commonly used types- { name: 'integer', id: 'integer', usageLevel: 1 },+ // { name: 'integer', id: 'integer', usageLevel: 1 },+ { name: 'int', id: 'int', usageLevel: 1 },+ // { name: 'int4', id: 'int4', usageLevel: 1 },{name: 'varchar',id: 'varchar',@@ -11,12 +13,14 @@ export const postgresDataTypes: readonly DataTypeData[] = [},{ name: 'text', id: 'text', usageLevel: 1 },{ name: 'boolean', id: 'boolean', usageLevel: 1 },+ // { name: 'bool', id: 'bool', usageLevel: 1 },{ name: 'timestamp', id: 'timestamp', usageLevel: 1 },{ name: 'timestamptz', id: 'timestamptz', usageLevel: 1 },{ name: 'date', id: 'date', usageLevel: 1 },// Level 2 - Second most common types{ name: 'bigint', id: 'bigint', usageLevel: 2 },+ // { name: 'int8', id: 'int8', usageLevel: 2 },{name: 'decimal',id: 'decimal',@@ -38,12 +42,12 @@ export const postgresDataTypes: readonly DataTypeData[] = [{ name: 'json', id: 'json', usageLevel: 2 },{ name: 'jsonb', id: 'jsonb', usageLevel: 2 },{ name: 'uuid', id: 'uuid', usageLevel: 2 },- {- name: 'timestamp with time zone',- id: 'timestamp_with_time_zone',- usageLevel: 2,- },- { name: 'int', id: 'int', usageLevel: 2 },+ // {+ // name: 'timestamp with time zone',+ // id: 'timestamp_with_time_zone',+ // usageLevel: 2,+ // },+ // { name: 'int', id: 'int', usageLevel: 2 },// Less common types{@@ -63,21 +67,30 @@ export const postgresDataTypes: readonly DataTypeData[] = [},},{ name: 'real', id: 'real' },+ // { name: 'float4', id: 'float4' },{ name: 'double precision', id: 'double_precision' },+ // { name: 'float8', id: 'float8' },{ name: 'smallserial', id: 'smallserial' },{ name: 'bigserial', id: 'bigserial' },{ name: 'money', id: 'money' },{ name: 'smallint', id: 'smallint' },+ // { name: 'int2', id: 'int2' },{ name: 'char', id: 'char', fieldAttributes: { hasCharMaxLength: true } },- {- name: 'character varying',- id: 'character_varying',- fieldAttributes: { hasCharMaxLength: true },- },+ // {+ // name: 'character',+ // id: 'character',+ // fieldAttributes: { hasCharMaxLength: true },+ // },+ // {+ // name: 'character varying',+ // id: 'character_varying',+ // fieldAttributes: { hasCharMaxLength: true },+ // },{ name: 'time', id: 'time' },- { name: 'timestamp without time zone', id: 'timestamp_without_time_zone' },- { name: 'time with time zone', id: 'time_with_time_zone' },- { name: 'time without time zone', id: 'time_without_time_zone' },+ { name: 'timetz', id: 'timetz' },+ // { name: 'timestamp without time zone', id: 'timestamp_without_time_zone' },+ // { name: 'time with time zone', id: 'time_with_time_zone' },+ // { name: 'time without time zone', id: 'time_without_time_zone' },{ name: 'interval', id: 'interval' },{ name: 'bytea', id: 'bytea' },{ name: 'enum', id: 'enum' },@@ -93,7 +106,8 @@ export const postgresDataTypes: readonly DataTypeData[] = [{ name: 'macaddr', id: 'macaddr' },{ name: 'macaddr8', id: 'macaddr8' },{ name: 'bit', id: 'bit' },- { name: 'bit varying', id: 'bit_varying' },+ // { name: 'bit varying', id: 'bit_varying' },+ { name: 'varbit', id: 'varbit' },{ name: 'tsvector', id: 'tsvector' },{ name: 'tsquery', id: 'tsquery' },{ name: 'xml', id: 'xml' },@@ -116,3 +130,88 @@ export const postgresDataTypes: readonly DataTypeData[] = [{ name: 'regdictionary', id: 'regdictionary' },{ name: 'user-defined', id: 'user-defined' },] as const;++/**+ * Maps data type names to their preferred synonym names.+ * The preferred synonym is typically the more commonly used or shorter form.+ *+ * Based on PostgreSQL official type names and common usage:+ * - Verbose forms map to their shorter equivalents+ * - Less common aliases map to their primary type names+ * - Types with usageLevel: 1 are generally preferred over those with usageLevel: 2 or no level+ *+ * Note: Keys and values use the actual PostgreSQL type names (with spaces where applicable),+ * not the internal ID format.+ */+const synonymMap: Record<string, string> = {+ // Character types+ 'character varying': 'varchar',+ character: 'char',++ // Boolean types+ bool: 'boolean',++ // Integer types+ integer: 'int',+ int2: 'smallint',+ int4: 'int',+ int8: 'bigint',++ // Floating point types+ float4: 'real',+ float8: 'double precision',++ // Timestamp types+ 'timestamp with time zone': 'timestamptz',+ 'timestamp without time zone': 'timestamp',++ // Time types+ 'time with time zone': 'timetz',+ 'time without time zone': 'time',++ // Bit types+ 'bit varying': 'varbit',+} as const;++/**+ * Resolves a data type to its preferred synonym if one exists.+ *+ * For data types that have synonyms in PostgreSQL, this function returns+ * the more commonly used variant. For example, 'character varying' resolves+ * to 'varchar', and 'integer' resolves to 'int'.+ *+ * @param typeName - The name of the data type to check (case-insensitive)+ * @returns The DataTypeData of the preferred synonym, or null if the type+ * is already the preferred form or has no synonyms+ *+ * @example+ * ```ts+ * getPostgresPreferredSynonym('character varying')+ * // Returns: { name: 'varchar', id: 'varchar', fieldAttributes: { hasCharMaxLength: true }, usageLevel: 1 }+ *+ * getPostgresPreferredSynonym('varchar')+ * // Returns: null (already the preferred form)+ *+ * getPostgresPreferredSynonym('INTEGER')+ * // Returns: { name: 'int', id: 'int', usageLevel: 1 } (case-insensitive)+ * ```+ */+export const getPostgresPreferredSynonym = (+ typeName: string+): DataTypeData | null => {+ // Normalize to lowercase for case-insensitive lookup+ const normalizedTypeName = typeName.toLowerCase().trim();++ const preferredName = synonymMap[normalizedTypeName];++ if (!preferredName) {+ return null;+ }++ return (+ postgresDataTypes.find(+ (dataType) =>+ dataType.name.toLowerCase() === preferredName.toLowerCase()+ ) ?? null+ );+};diff --git a/src/lib/data/import-metadata/import/fields.ts b/src/lib/data/import-metadata/import/fields.tsindex 10cfd77e..77d209dd 100644--- a/src/lib/data/import-metadata/import/fields.ts+++ b/src/lib/data/import-metadata/import/fields.ts@@ -1,20 +1,24 @@import type { DBField } from '@/lib/domain';+import type { DatabaseType } from '@/lib/domain';import type { ColumnInfo } from '../metadata-types/column-info';import type { AggregatedIndexInfo } from '../metadata-types/index-info';import type { PrimaryKeyInfo } from '../metadata-types/primary-key-info';import type { TableInfo } from '../metadata-types/table-info';import { generateId } from '@/lib/utils';+import { getPreferredSynonym } from '@/lib/data/data-types/data-types';export const createFieldsFromMetadata = ({tableColumns,tablePrimaryKeys,aggregatedIndexes,+ databaseType,}: {tableColumns: ColumnInfo[];tableSchema?: string;tableInfo: TableInfo;tablePrimaryKeys: PrimaryKeyInfo[];aggregatedIndexes: AggregatedIndexInfo[];+ databaseType: DatabaseType;}) => {const uniqueColumns = tableColumns.reduce((acc, col) => {if (!acc.has(col.name)) {@@ -31,14 +35,28 @@ export const createFieldsFromMetadata = ({pk.column.trim());- return sortedColumns.map(- (col: ColumnInfo): DBField => ({+ return sortedColumns.map((col: ColumnInfo): DBField => {+ // Create initial type from column metadata+ const initialType = {+ id: col.type.split(' ').join('_').toLowerCase(),+ name: col.type.toLowerCase(),+ };++ // Check if there's a preferred synonym for this type+ const preferredType = getPreferredSynonym(+ initialType.name,+ databaseType+ );++ // Use the preferred synonym if it exists, otherwise use the initial type+ const finalType = preferredType+ ? { id: preferredType.id, name: preferredType.name }+ : initialType;++ return {id: generateId(),name: col.name,- type: {- id: col.type.split(' ').join('_').toLowerCase(),- name: col.type.toLowerCase(),- },+ type: finalType,primaryKey: tablePrimaryKeysColumns.includes(col.name),unique: Object.values(aggregatedIndexes).some((idx) =>@@ -63,6 +81,6 @@ export const createFieldsFromMetadata = ({...(col.is_array !== undefined ? { isArray: col.is_array } : {}),createdAt: Date.now(),comments: col.comment ? col.comment : undefined,- })- );+ };+ });};diff --git a/src/lib/data/import-metadata/import/tables.ts b/src/lib/data/import-metadata/import/tables.tsindex b45689b8..939404e2 100644--- a/src/lib/data/import-metadata/import/tables.ts+++ b/src/lib/data/import-metadata/import/tables.ts@@ -142,6 +142,7 @@ export const createTablesFromMetadata = ({tablePrimaryKeys,tableInfo,tableSchema,+ databaseType,});// Check for composite primary key and find matching index namediff --git a/src/lib/data/sql-import/common.ts b/src/lib/data/sql-import/common.tsindex 2bf1787b..e35a6559 100644--- a/src/lib/data/sql-import/common.ts+++ b/src/lib/data/sql-import/common.ts@@ -4,7 +4,10 @@ import type { DBTable } from '@/lib/domain/db-table';import type { Cardinality, DBRelationship } from '@/lib/domain/db-relationship';import type { DBField } from '@/lib/domain/db-field';import type { DBIndex } from '@/lib/domain/db-index';-import type { DataType } from '@/lib/data/data-types/data-types';+import {+ getPreferredSynonym,+ type DataType,+} from '@/lib/data/data-types/data-types';import { genericDataTypes } from '@/lib/data/data-types/generic-data-types';import { defaultTableColor } from '@/lib/colors';import { DatabaseType } from '@/lib/domain/database-type';@@ -715,10 +718,21 @@ export function convertToChartDBDiagram();}+ // Check if there's a preferred synonym for this type+ const preferredType = getPreferredSynonym(+ mappedType.name,+ targetDatabaseType+ );++ // Use the preferred synonym if it exists, otherwise use the mapped type+ const finalType = preferredType+ ? { id: preferredType.id, name: preferredType.name }+ : mappedType;+const field: DBField = {id: generateId(),name: column.name,- type: mappedType,+ type: finalType,nullable: column.nullable,primaryKey: column.primaryKey,unique: column.unique,diff --git a/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.ts b/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.tsindex 21ba583d..0e03f7b3 100644--- a/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.ts+++ b/src/lib/data/sql-import/dialect-importers/postgresql/__tests__/postgresql-core.test.ts@@ -1,5 +1,10 @@-import { describe, it, expect } from 'vitest';+import { describe, it, expect, vi } from 'vitest';import { fromPostgres } from '../postgresql';+import { sqlImportToDiagram } from '@/lib/data/sql-import';+import { DatabaseType } from '@/lib/domain/database-type';+import * as dataTypes from '@/lib/data/data-types/data-types';+import type { DBTable } from '@/lib/domain/db-table';+import type { DBField } from '@/lib/domain/db-field';describe('PostgreSQL Core Parser Tests', () => {it('should parse basic tables', async () => {@@ -455,4 +460,94 @@ CREATE TRIGGER arcane_audit_apprentices AFTER INSERT OR UPDATE OR DELETE ON apprexpect(fks.length).toBeGreaterThan(0);expect(fks[0].targetTable).toBe('base');});++ describe('Type Synonym Resolution', () => {+ it('should call getPreferredSynonym for PostgreSQL types and use resolved types', async () => {+ // Spy on getPreferredSynonym+ const getPreferredSynonymSpy = vi.spyOn(+ dataTypes,+ 'getPreferredSynonym'+ );++ // Mock return value for 'character varying' -> 'varchar'+ getPreferredSynonymSpy.mockImplementation(+ (typeName, databaseType) => {+ if (+ typeName === 'character varying' &&+ databaseType === DatabaseType.POSTGRESQL+ ) {+ return {+ id: 'varchar',+ name: 'varchar',+ fieldAttributes: { hasCharMaxLength: true },+ usageLevel: 1,+ } as const;+ }+ if (+ typeName === 'integer' &&+ databaseType === DatabaseType.POSTGRESQL+ ) {+ return {+ id: 'int',+ name: 'int',+ usageLevel: 1,+ } as const;+ }+ return null;+ }+ );++ const sql = `+ CREATE TABLE users (+ id INTEGER PRIMARY KEY,+ name CHARACTER VARYING(255),+ email CHARACTER VARYING(100)+ );+ `;++ const diagram = await sqlImportToDiagram({+ sqlContent: sql,+ sourceDatabaseType: DatabaseType.POSTGRESQL,+ targetDatabaseType: DatabaseType.POSTGRESQL,+ });++ // Verify getPreferredSynonym was called+ expect(getPreferredSynonymSpy).toHaveBeenCalled();+ expect(getPreferredSynonymSpy).toHaveBeenCalledWith(+ 'integer',+ DatabaseType.POSTGRESQL+ );+ expect(getPreferredSynonymSpy).toHaveBeenCalledWith(+ 'varchar',+ DatabaseType.POSTGRESQL+ );++ // Verify the resolved types were used in the diagram+ const usersTable = diagram.tables?.find(+ (t: DBTable) => t.name === 'users'+ );+ expect(usersTable).toBeDefined();++ const idField = usersTable?.fields.find(+ (f: DBField) => f.name === 'id'+ );+ expect(idField?.type.id).toBe('int');+ expect(idField?.type.name).toBe('int');++ const nameField = usersTable?.fields.find(+ (f: DBField) => f.name === 'name'+ );+ expect(nameField?.type.id).toBe('varchar');+ expect(nameField?.type.name).toBe('varchar');++ const emailField = usersTable?.fields.find(+ (f: DBField) => f.name === 'email'+ );+ expect(emailField?.type.id).toBe('varchar');+ expect(emailField?.type.name).toBe('varchar');++ // Restore the original implementation+ getPreferredSynonymSpy.mockRestore();+ });+ });});diff --git a/src/lib/dbml/dbml-export/__tests__/timestamp-with-timezone.test.ts b/src/lib/dbml/dbml-export/__tests__/timestamp-with-timezone.test.tsindex 35f5dd3a..f6a5853a 100644--- a/src/lib/dbml/dbml-export/__tests__/timestamp-with-timezone.test.ts+++ b/src/lib/dbml/dbml-export/__tests__/timestamp-with-timezone.test.ts@@ -95,8 +95,8 @@ describe('DBML Export - Timestamp with Time Zone', () => {(f) => f.name === 'updated_at');- expect(createdAtField?.type.name).toBe('timestamp with time zone');- expect(updatedAtField?.type.name).toBe('timestamp without time zone');+ expect(createdAtField?.type.name).toBe('timestamptz');+ expect(updatedAtField?.type.name).toBe('timestamp');});it('should handle time with time zone types', async () => {@@ -177,8 +177,8 @@ describe('DBML Export - Timestamp with Time Zone', () => {);const endTimeField = table?.fields.find((f) => f.name === 'end_time');- expect(startTimeField?.type.name).toBe('time with time zone');- expect(endTimeField?.type.name).toBe('time without time zone');+ expect(startTimeField?.type.name).toBe('timetz');+ expect(endTimeField?.type.name).toBe('time');});it('should handle double precision type', async () => {diff --git a/src/lib/dbml/dbml-import/__tests__/dbml-array-fields.test.ts b/src/lib/dbml/dbml-import/__tests__/dbml-array-fields.test.tsindex 943858b9..fd835956 100644--- a/src/lib/dbml/dbml-import/__tests__/dbml-array-fields.test.ts+++ b/src/lib/dbml/dbml-import/__tests__/dbml-array-fields.test.ts@@ -82,7 +82,7 @@ Table "heroes" {(f) => f.name === 'inventory_slots');expect(inventorySlots?.isArray).toBe(true);- expect(inventorySlots?.type.name).toBe('integer');+ expect(inventorySlots?.type.name).toBe('int');const skillLevels = table.fields.find((f) => f.name === 'skill_levels'@@ -226,7 +226,7 @@ Table "guilds"."members" {// Verify exported DBML has correct array syntax with typesexpect(exportedDbml).toContain('varchar(50)[]');- expect(exportedDbml).toContain('integer[]');+ expect(exportedDbml).toContain('int[]');expect(exportedDbml).toContain('decimal(3,1)[]');expect(exportedDbml).toContain('text[]');diff --git a/src/lib/dbml/dbml-import/__tests__/dbml-import-cases.test.ts b/src/lib/dbml/dbml-import/__tests__/dbml-import-cases.test.tsindex 28cfd3b4..44bd2f63 100644--- a/src/lib/dbml/dbml-import/__tests__/dbml-import-cases.test.ts+++ b/src/lib/dbml/dbml-import/__tests__/dbml-import-cases.test.ts@@ -420,7 +420,7 @@ describe('DBML Import cases', () => {// Regular INTEGER - should be nullable by defaultconst regularField = table.fields.find((f) => f.name === 'regular');- expect(regularField?.type?.name).toBe('integer');+ expect(regularField?.type?.name).toBe('int');expect(regularField?.nullable).toBe(true); // No NOT NULL constraint});});diff --git a/src/lib/dbml/dbml-import/__tests__/dbml-import-fantasy-examples.test.ts b/src/lib/dbml/dbml-import/__tests__/dbml-import-fantasy-examples.test.tsindex 1393db70..929afa27 100644--- a/src/lib/dbml/dbml-import/__tests__/dbml-import-fantasy-examples.test.ts+++ b/src/lib/dbml/dbml-import/__tests__/dbml-import-fantasy-examples.test.ts@@ -1040,11 +1040,11 @@ Table "bb"."users" {expect(bbUsersTable?.fields).toHaveLength(1);expect(aaUsersTable?.fields[0].name).toBe('id');- expect(aaUsersTable?.fields[0].type.id).toBe('integer');+ expect(aaUsersTable?.fields[0].type.id).toBe('int');expect(aaUsersTable?.fields[0].primaryKey).toBe(true);expect(bbUsersTable?.fields[0].name).toBe('id');- expect(bbUsersTable?.fields[0].type.id).toBe('integer');+ expect(bbUsersTable?.fields[0].type.id).toBe('int');expect(bbUsersTable?.fields[0].primaryKey).toBe(true);});diff --git a/src/lib/dbml/dbml-import/__tests__/dbml-import.test.ts b/src/lib/dbml/dbml-import/__tests__/dbml-import.test.tsindex 850d6f77..5b621064 100644--- a/src/lib/dbml/dbml-import/__tests__/dbml-import.test.ts+++ b/src/lib/dbml/dbml-import/__tests__/dbml-import.test.ts@@ -1,4 +1,4 @@-import { describe, it, expect } from 'vitest';+import { describe, it, expect, vi } from 'vitest';import {preprocessDBML,sanitizeDBML,@@ -6,6 +6,7 @@ import {} from '../dbml-import';import { Parser } from '@dbml/core';import { DatabaseType } from '@/lib/domain/database-type';+import * as dataTypes from '@/lib/data/data-types/data-types';describe('DBML Import', () => {describe('preprocessDBML', () => {@@ -177,4 +178,68 @@ Note note_1750185617764 {expect(result).toContain('нужна таблица справочник?');});});++ describe('Type Synonym Resolution', () => {+ it('should call getPreferredSynonym for PostgreSQL types and use resolved types', async () => {+ // Spy on getPreferredSynonym+ const getPreferredSynonymSpy = vi.spyOn(+ dataTypes,+ 'getPreferredSynonym'+ );++ // Mock return value for 'character varying' -> 'varchar'+ getPreferredSynonymSpy.mockImplementation(+ (typeName, databaseType) => {+ if (+ typeName === 'character varying' &&+ databaseType === DatabaseType.POSTGRESQL+ ) {+ return {+ id: 'varchar',+ name: 'varchar',+ fieldAttributes: { hasCharMaxLength: true },+ usageLevel: 1,+ } as const;+ }+ return null;+ }+ );++ const dbml = `+ Table users {+ id int [pk]+ name "character varying"(255)+ email "character varying"(100)+ }+ `;++ const diagram = await importDBMLToDiagram(dbml, {+ databaseType: DatabaseType.POSTGRESQL,+ });++ // Verify getPreferredSynonym was called+ expect(getPreferredSynonymSpy).toHaveBeenCalled();+ expect(getPreferredSynonymSpy).toHaveBeenCalledWith(+ 'character varying',+ DatabaseType.POSTGRESQL+ );++ // Verify the resolved type was used in the diagram+ const usersTable = diagram.tables?.find((t) => t.name === 'users');+ expect(usersTable).toBeDefined();++ const nameField = usersTable?.fields.find((f) => f.name === 'name');+ expect(nameField?.type.id).toBe('varchar');+ expect(nameField?.type.name).toBe('varchar');++ const emailField = usersTable?.fields.find(+ (f) => f.name === 'email'+ );+ expect(emailField?.type.id).toBe('varchar');+ expect(emailField?.type.name).toBe('varchar');++ // Restore the original implementation+ getPreferredSynonymSpy.mockRestore();+ });+ });});diff --git a/src/lib/dbml/dbml-import/dbml-import.ts b/src/lib/dbml/dbml-import/dbml-import.tsindex c82125a9..76710121 100644--- a/src/lib/dbml/dbml-import/dbml-import.ts+++ b/src/lib/dbml/dbml-import/dbml-import.ts@@ -7,6 +7,7 @@ import type { DBField } from '@/lib/domain/db-field';import type { DataTypeData } from '@/lib/data/data-types/data-types';import {findDataTypeDataById,+ getPreferredSynonym,requiresNotNull,} from '@/lib/data/data-types/data-types';import { defaultTableColor } from '@/lib/colors';@@ -548,13 +549,25 @@ export const importDBMLToDiagram = async (}}+ // Map DBML type to DataType+ const mappedType = mapDBMLTypeToDataType(field.type.type_name, {+ ...options,+ enums: extractedData.enums,+ });++ // Check if there's a preferred synonym for this type+ const preferredType = getPreferredSynonym(+ mappedType.name,+ options.databaseType+ );++ // Use the preferred synonym if it exists, otherwise use the mapped type+ const finalType = preferredType ?? mappedType;+return {id: generateId(),name: field.name.replace(/['"]/g, ''),- type: mapDBMLTypeToDataType(field.type.type_name, {- ...options,- enums: extractedData.enums,- }),+ type: finalType,nullable:field.increment || requiresNotNull(field.type.type_name)? false