Skip to content

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

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.ts
index 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.ts
index 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.ts
index 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.ts
index 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 name
diff --git a/src/lib/data/sql-import/common.ts b/src/lib/data/sql-import/common.ts
index 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.ts
index 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 appr
expect(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.ts
index 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.ts
index 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 types
expect(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.ts
index 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 default
const 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.ts
index 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.ts
index 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.ts
index 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