update translate (#957)

* fix: preserve multi-word types in DBML export/import

* fix

src/hooks/use-update-table-field.ts

@@ -10,6 +10,8 @@ import {
     dataTypeDataToDataType,
     sortedDataTypeMap,
     supportsArrayDataType,
+    autoIncrementAlwaysOn,
+    requiresNotNull,
 } from '@/lib/data/data-types/data-types';
 import { generateDBFieldSuffix } from '@/lib/domain/db-field';
 import type { DataTypeData } from '@/lib/data/data-types/data-types';
@@ -224,12 +226,17 @@ export const useUpdateTableField = (
                 }
             }
 
+            const newTypeName = dataType?.name ?? (value as string);
+            const typeRequiresNotNull = requiresNotNull(newTypeName);
+            const shouldForceIncrement = autoIncrementAlwaysOn(newTypeName);
+
             updateField(table.id, field.id, {
                 characterMaximumLength,
                 precision,
                 scale,
                 isArray,
-                increment: undefined,
+                ...(typeRequiresNotNull ? { nullable: false } : {}),
+                increment: shouldForceIncrement ? true : undefined,
                 default: undefined,
                 type: dataTypeDataToDataType(
                     dataType ?? {
@@ -267,9 +274,16 @@ export const useUpdateTableField = (
     const debouncedNullableUpdate = useDebounce(
         useCallback(
             (value: boolean) => {
-                updateField(table.id, field.id, { nullable: value });
+                const updates: Partial<DBField> = { nullable: value };
+
+                // If setting to nullable, clear increment (auto-increment requires NOT NULL)
+                if (value && field.increment) {
+                    updates.increment = undefined;
+                }
+
+                updateField(table.id, field.id, updates);
             },
-            [updateField, table.id, field.id]
+            [updateField, table.id, field.id, field.increment]
         ),
         100 // 100ms debounce for toggle
     );

src/i18n/locales/ar.ts

@@ -308,7 +308,7 @@ export const ar: LanguageTranslation = {
             cancel: 'إلغاء',
             import_from_file: 'استيراد من ملف',
             back: 'رجوع',
-            empty_diagram: 'مخطط فارغ',
+            empty_diagram: 'قاعدة بيانات فارغة',
             continue: 'متابعة',
             import: 'استيراد',
         },

src/i18n/locales/bn.ts

@@ -310,7 +310,7 @@ export const bn: LanguageTranslation = {
             cancel: 'বাতিল করুন',
             back: 'ফিরে যান',
             import_from_file: 'ফাইল থেকে আমদানি করুন',
-            empty_diagram: 'ফাঁকা চিত্র',
+            empty_diagram: 'খালি ডাটাবেস',
             continue: 'চালিয়ে যান',
             import: 'আমদানি করুন',
         },

src/i18n/locales/de.ts

@@ -313,7 +313,7 @@ export const de: LanguageTranslation = {
             back: 'Zurück',
             // TODO: Translate
             import_from_file: 'Import from File',
-            empty_diagram: 'Leeres Diagramm',
+            empty_diagram: 'Leere Datenbank',
             continue: 'Weiter',
             import: 'Importieren',
         },

src/i18n/locales/en.ts

@@ -301,7 +301,7 @@ export const en = {
             cancel: 'Cancel',
             import_from_file: 'Import from File',
             back: 'Back',
-            empty_diagram: 'Empty diagram',
+            empty_diagram: 'Empty database',
             continue: 'Continue',
             import: 'Import',
         },

src/i18n/locales/es.ts

@@ -310,7 +310,7 @@ export const es: LanguageTranslation = {
             back: 'Atrás',
             // TODO: Translate
             import_from_file: 'Import from File',
-            empty_diagram: 'Diagrama vacío',
+            empty_diagram: 'Base de datos vacía',
             continue: 'Continuar',
             import: 'Importar',
         },

src/i18n/locales/fr.ts

@@ -307,7 +307,7 @@ export const fr: LanguageTranslation = {
             cancel: 'Annuler',
             back: 'Retour',
             import_from_file: "Importer à partir d'un fichier",
-            empty_diagram: 'Diagramme vide',
+            empty_diagram: 'Base de données vide',
             continue: 'Continuer',
             import: 'Importer',
         },

src/i18n/locales/gu.ts

@@ -310,7 +310,7 @@ export const gu: LanguageTranslation = {
             cancel: 'રદ કરો',
             back: 'પાછા',
             import_from_file: 'ફાઇલમાંથી આયાત કરો',
-            empty_diagram: 'ખાલી ડાયાગ્રામ',
+            empty_diagram: 'ખાલી ડેટાબેસ',
             continue: 'ચાલુ રાખો',
             import: 'આયાત કરો',
         },

src/i18n/locales/hi.ts

@@ -312,7 +312,7 @@ export const hi: LanguageTranslation = {
             back: 'वापस',
             // TODO: Translate
             import_from_file: 'Import from File',
-            empty_diagram: 'खाली आरेख',
+            empty_diagram: 'खाली डेटाबेस',
             continue: 'जारी रखें',
             import: 'आयात करें',
         },

src/i18n/locales/hr.ts

@@ -305,7 +305,7 @@ export const hr: LanguageTranslation = {
             cancel: 'Odustani',
             import_from_file: 'Uvezi iz datoteke',
             back: 'Natrag',
-            empty_diagram: 'Prazan dijagram',
+            empty_diagram: 'Prazna baza podataka',
             continue: 'Nastavi',
             import: 'Uvezi',
         },

src/i18n/locales/id_ID.ts

@@ -309,7 +309,7 @@ export const id_ID: LanguageTranslation = {
             cancel: 'Batal',
             import_from_file: 'Impor dari file',
             back: 'Kembali',
-            empty_diagram: 'Diagram Kosong',
+            empty_diagram: 'Database Kosong',
             continue: 'Lanjutkan',
             import: 'Impor',
         },

src/i18n/locales/ja.ts

@@ -314,7 +314,7 @@ export const ja: LanguageTranslation = {
             back: '戻る',
             // TODO: Translate
             import_from_file: 'Import from File',
-            empty_diagram: '空のダイアグラム',
+            empty_diagram: '空のデータベース',
             continue: '続行',
             import: 'インポート',
         },

src/i18n/locales/ko_KR.ts

@@ -309,7 +309,7 @@ export const ko_KR: LanguageTranslation = {
             cancel: '취소',
             back: '뒤로가기',
             import_from_file: '파일에서 가져오기',
-            empty_diagram: '빈 다이어그램으로 시작',
+            empty_diagram: '빈 데이터베이스',
             continue: '계속',
             import: '가져오기',
         },

src/i18n/locales/mr.ts

@@ -315,7 +315,7 @@ export const mr: LanguageTranslation = {
             // TODO: Add translations
             import_from_file: 'Import from File',
             back: 'मागे',
-            empty_diagram: 'रिक्त आरेख',
+            empty_diagram: 'रिक्त डेटाबेस',
             continue: 'सुरू ठेवा',
             import: 'आयात करा',
         },

src/i18n/locales/ne.ts

@@ -311,7 +311,7 @@ export const ne: LanguageTranslation = {
             cancel: 'रद्द गर्नुहोस्',
             import_from_file: 'फाइलबाट आयात गर्नुहोस्',
             back: 'फर्क',
-            empty_diagram: 'रिक्त डायाग्राम',
+            empty_diagram: 'खाली डाटाबेस',
             continue: 'जारी राख्नुहोस्',
             import: 'आयात गर्नुहोस्',
         },

src/i18n/locales/pt_BR.ts

@@ -311,7 +311,7 @@ export const pt_BR: LanguageTranslation = {
             back: 'Voltar',
             // TODO: Translate
             import_from_file: 'Import from File',
-            empty_diagram: 'Diagrama vazio',
+            empty_diagram: 'Banco de dados vazio',
             continue: 'Continuar',
             import: 'Importar',
         },

src/i18n/locales/ru.ts

@@ -307,7 +307,7 @@ export const ru: LanguageTranslation = {
             cancel: 'Отменить',
             back: 'Назад',
             import_from_file: 'Импортировать из файла',
-            empty_diagram: 'Пустая диаграмма',
+            empty_diagram: 'Пустая база данных',
             continue: 'Продолжить',
             import: 'Импорт',
         },

src/i18n/locales/te.ts

@@ -312,7 +312,7 @@ export const te: LanguageTranslation = {
             // TODO: Translate
             import_from_file: 'Import from File',
             back: 'తిరుగు',
-            empty_diagram: 'ఖాళీ చిత్రము',
+            empty_diagram: 'ఖాళీ డేటాబేస్',
             continue: 'కొనసాగించు',
             import: 'డిగుమతి',
         },

src/i18n/locales/tr.ts

@@ -308,7 +308,7 @@ export const tr: LanguageTranslation = {
             import_from_file: 'Import from File',
             cancel: 'İptal',
             back: 'Geri',
-            empty_diagram: 'Boş diyagram',
+            empty_diagram: 'Boş veritabanı',
             continue: 'Devam',
             import: 'İçe Aktar',
         },

src/i18n/locales/uk.ts

@@ -308,7 +308,7 @@ export const uk: LanguageTranslation = {
             cancel: 'Скасувати',
             back: 'Назад',
             import_from_file: 'Імпортувати з файлу',
-            empty_diagram: 'Порожня діаграма',
+            empty_diagram: 'Порожня база даних',
             continue: 'Продовжити',
             import: 'Імпорт',
         },

src/i18n/locales/vi.ts

@@ -309,7 +309,7 @@ export const vi: LanguageTranslation = {
             cancel: 'Hủy',
             import_from_file: 'Nhập từ tệp',
             back: 'Trở lại',
-            empty_diagram: 'Sơ đồ trống',
+            empty_diagram: 'Cơ sở dữ liệu trống',
             continue: 'Tiếp tục',
             import: 'Nhập',
         },

src/i18n/locales/zh_CN.ts

@@ -306,7 +306,7 @@ export const zh_CN: LanguageTranslation = {
             cancel: '取消',
             import_from_file: '从文件导入',
             back: '上一步',
-            empty_diagram: '新建空关系图',
+            empty_diagram: '空数据库',
             continue: '下一步',
             import: '导入',
         },

src/i18n/locales/zh_TW.ts

@@ -305,7 +305,7 @@ export const zh_TW: LanguageTranslation = {
             cancel: '取消',
             import_from_file: '從檔案匯入',
             back: '返回',
-            empty_diagram: '空白圖表',
+            empty_diagram: '空資料庫',
             continue: '繼續',
             import: '匯入',
         },

src/lib/data/data-types/data-types.ts

@@ -167,6 +167,18 @@ export const supportsAutoIncrementDataType = (
     ].includes(dataTypeName.toLocaleLowerCase());
 };
 
+export const autoIncrementAlwaysOn = (dataTypeName: string): boolean => {
+    return ['serial', 'bigserial', 'smallserial'].includes(
+        dataTypeName.toLowerCase()
+    );
+};
+
+export const requiresNotNull = (dataTypeName: string): boolean => {
+    return ['serial', 'bigserial', 'smallserial'].includes(
+        dataTypeName.toLowerCase()
+    );
+};
+
 const ARRAY_INCOMPATIBLE_TYPES = [
     'serial',
     'bigserial',

src/lib/data/sql-export/export-sql-script.ts

@@ -338,7 +338,13 @@ export const exportBaseSQL = ({
 
             const quotedFieldName = getQuotedFieldName(field.name, isDBMLFlow);
 
-            sqlScript += `  ${quotedFieldName} ${typeName}`;
+            // Quote multi-word type names for DBML flow to prevent @dbml/core parser issues
+            const quotedTypeName =
+                isDBMLFlow && typeName.includes(' ')
+                    ? `"${typeName}"`
+                    : typeName;
+
+            sqlScript += `  ${quotedFieldName} ${quotedTypeName}`;
 
             // Add size for character types
             if (
@@ -395,9 +401,26 @@ export const exportBaseSQL = ({
                 sqlScript += ` UNIQUE`;
             }
 
-            // Handle AUTO INCREMENT - add as a comment for AI to process
+            // Handle AUTO INCREMENT
             if (field.increment) {
-                sqlScript += ` /* AUTO_INCREMENT */`;
+                if (isDBMLFlow) {
+                    // For DBML flow, generate proper database-specific syntax
+                    if (
+                        targetDatabaseType === DatabaseType.MYSQL ||
+                        targetDatabaseType === DatabaseType.MARIADB
+                    ) {
+                        sqlScript += ` AUTO_INCREMENT`;
+                    } else if (targetDatabaseType === DatabaseType.SQL_SERVER) {
+                        sqlScript += ` IDENTITY(1,1)`;
+                    } else if (targetDatabaseType === DatabaseType.SQLITE) {
+                        // SQLite AUTOINCREMENT only works with INTEGER PRIMARY KEY
+                        // Will be handled when PRIMARY KEY is added
+                    }
+                    // PostgreSQL/CockroachDB: increment attribute added by restoreIncrementAttribute in DBML export
+                } else {
+                    // For non-DBML flow, add as a comment for AI to process
+                    sqlScript += ` /* AUTO_INCREMENT */`;
+                }
             }
 
             // Handle DEFAULT value
@@ -450,6 +473,17 @@ export const exportBaseSQL = ({
             const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);
             if (field.primaryKey && !hasCompositePrimaryKey && !pkIndex?.name) {
                 sqlScript += ' PRIMARY KEY';
+
+                // For SQLite with DBML flow, add AUTOINCREMENT after PRIMARY KEY
+                if (
+                    isDBMLFlow &&
+                    field.increment &&
+                    targetDatabaseType === DatabaseType.SQLITE &&
+                    (typeName.toLowerCase() === 'integer' ||
+                        typeName.toLowerCase() === 'int')
+                ) {
+                    sqlScript += ' AUTOINCREMENT';
+                }
             }
 
             // Add a comma after each field except the last one (or before PK constraint)

src/lib/dbml/dbml-export/__tests__/cases/3.dbml

@@ -1,6 +1,6 @@
 Table "public"."guy_table" {
   "id" integer [pk, not null]
-  "created_at" timestamp [not null]
+  "created_at" "timestamp without time zone" [not null]
   "column3" text
   "arrayfield" text[]
   "field_5" "character varying"

src/lib/dbml/dbml-export/__tests__/cases/4.dbml

@@ -1,5 +1,5 @@
 Table "public"."orders" {
-  "order_id" integer [pk, not null]
+  "order_id" integer [pk, not null, increment]
   "customer_id" integer [not null]
   "order_date" date [not null, default: `CURRENT_DATE`]
   "total_amount" numeric [not null, default: 0]

src/lib/dbml/dbml-export/__tests__/cases/6.dbml

@@ -0,0 +1,14 @@
+Table "users" {
+  "id" integer [pk, not null, increment]
+  "username" varchar(100) [unique, not null]
+  "email" varchar(255) [not null]
+}
+
+Table "posts" {
+  "post_id" bigint [pk, not null, increment]
+  "user_id" integer [not null]
+  "title" varchar(200) [not null]
+  "order_num" integer [not null, increment]
+}
+
+Ref "fk_0_fk_posts_users":"users"."id" < "posts"."user_id"

src/lib/dbml/dbml-export/__tests__/cases/6.json

@@ -0,0 +1 @@
+{"id":"test_auto_increment","name":"Auto Increment Test (mysql)","createdAt":"2025-01-20T00:00:00.000Z","updatedAt":"2025-01-20T00:00:00.000Z","databaseType":"mysql","tables":[{"id":"table1","name":"users","order":1,"fields":[{"id":"field1","name":"id","type":{"id":"integer","name":"integer"},"nullable":false,"primaryKey":true,"unique":false,"default":"","increment":true,"createdAt":1705708800000},{"id":"field2","name":"username","type":{"id":"varchar","name":"varchar","fieldAttributes":{"hasCharMaxLength":true}},"nullable":false,"primaryKey":false,"unique":true,"default":"","increment":false,"characterMaximumLength":"100","createdAt":1705708800000},{"id":"field3","name":"email","type":{"id":"varchar","name":"varchar","fieldAttributes":{"hasCharMaxLength":true}},"nullable":false,"primaryKey":false,"unique":false,"default":"","increment":false,"characterMaximumLength":"255","createdAt":1705708800000}],"indexes":[],"x":100,"y":100,"color":"#8eb7ff","isView":false,"createdAt":1705708800000},{"id":"table2","name":"posts","order":2,"fields":[{"id":"field4","name":"post_id","type":{"id":"bigint","name":"bigint"},"nullable":false,"primaryKey":true,"unique":false,"default":"","increment":true,"createdAt":1705708800000},{"id":"field5","name":"user_id","type":{"id":"integer","name":"integer"},"nullable":false,"primaryKey":false,"unique":false,"default":"","increment":false,"createdAt":1705708800000},{"id":"field6","name":"title","type":{"id":"varchar","name":"varchar","fieldAttributes":{"hasCharMaxLength":true}},"nullable":false,"primaryKey":false,"unique":false,"default":"","increment":false,"characterMaximumLength":"200","createdAt":1705708800000},{"id":"field7","name":"order_num","type":{"id":"integer","name":"integer"},"nullable":false,"primaryKey":false,"unique":false,"default":"","increment":true,"createdAt":1705708800000}],"indexes":[],"x":300,"y":100,"color":"#8eb7ff","isView":false,"createdAt":1705708800000}],"relationships":[{"id":"rel1","name":"fk_posts_users","sourceTableId":"table2","targetTableId":"table1","sourceFieldId":"field5","targetFieldId":"field1","type":"one_to_many","sourceCardinality":"many","targetCardinality":"one","createdAt":1705708800000}],"dependencies":[],"storageMode":"project","areas":[],"creationMethod":"manual","customTypes":[]}

src/lib/dbml/dbml-export/__tests__/empty-tables.test.ts

@@ -0,0 +1,205 @@
+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';
+import { generateId, generateDiagramId } from '@/lib/utils';
+
+describe('DBML Export - Empty Tables', () => {
+    it('should filter out tables with no fields', () => {
+        const diagram: Diagram = {
+            id: generateDiagramId(),
+            name: 'Test Diagram',
+            databaseType: DatabaseType.POSTGRESQL,
+            tables: [
+                {
+                    id: generateId(),
+                    name: 'valid_table',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [
+                        {
+                            id: generateId(),
+                            name: 'id',
+                            type: { id: 'integer', name: 'integer' },
+                            primaryKey: true,
+                            unique: true,
+                            nullable: false,
+                            createdAt: Date.now(),
+                        },
+                    ],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+                {
+                    id: generateId(),
+                    name: 'empty_table',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [], // Empty fields array
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+                {
+                    id: generateId(),
+                    name: 'another_valid_table',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [
+                        {
+                            id: generateId(),
+                            name: 'name',
+                            type: { id: 'varchar', name: 'varchar' },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                    ],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+            ],
+            relationships: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = generateDBMLFromDiagram(diagram);
+
+        // Verify the DBML doesn't contain the empty table
+        expect(result.inlineDbml).not.toContain('empty_table');
+        expect(result.standardDbml).not.toContain('empty_table');
+
+        // Verify the valid tables are still present
+        expect(result.inlineDbml).toContain('valid_table');
+        expect(result.inlineDbml).toContain('another_valid_table');
+    });
+
+    it('should handle diagram with only empty tables', () => {
+        const diagram: Diagram = {
+            id: generateDiagramId(),
+            name: 'Test Diagram',
+            databaseType: DatabaseType.POSTGRESQL,
+            tables: [
+                {
+                    id: generateId(),
+                    name: 'empty_table_1',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+                {
+                    id: generateId(),
+                    name: 'empty_table_2',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+            ],
+            relationships: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = generateDBMLFromDiagram(diagram);
+
+        // Should not error and should return empty DBML (or just enums if any)
+        expect(result.inlineDbml).toBeTruthy();
+        expect(result.standardDbml).toBeTruthy();
+        expect(result.error).toBeUndefined();
+    });
+
+    it('should filter out table that becomes empty after removing invalid fields', () => {
+        const diagram: Diagram = {
+            id: generateDiagramId(),
+            name: 'Test Diagram',
+            databaseType: DatabaseType.POSTGRESQL,
+            tables: [
+                {
+                    id: generateId(),
+                    name: 'table_with_only_empty_field_names',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [
+                        {
+                            id: generateId(),
+                            name: '', // Empty field name - will be filtered
+                            type: { id: 'integer', name: 'integer' },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                        {
+                            id: generateId(),
+                            name: '', // Empty field name - will be filtered
+                            type: { id: 'varchar', name: 'varchar' },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                    ],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+                {
+                    id: generateId(),
+                    name: 'valid_table',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [
+                        {
+                            id: generateId(),
+                            name: 'id',
+                            type: { id: 'integer', name: 'integer' },
+                            primaryKey: true,
+                            unique: true,
+                            nullable: false,
+                            createdAt: Date.now(),
+                        },
+                    ],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+            ],
+            relationships: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const result = generateDBMLFromDiagram(diagram);
+
+        // Table with only empty field names should be filtered out
+        expect(result.inlineDbml).not.toContain(
+            'table_with_only_empty_field_names'
+        );
+        // Valid table should remain
+        expect(result.inlineDbml).toContain('valid_table');
+    });
+});

src/lib/dbml/dbml-export/__tests__/export-sql-dbml-cases.test.ts

@@ -66,4 +66,12 @@ describe('DBML Export cases', () => {
     it('should handle case 5 diagram', { timeout: 30000 }, async () => {
         testCase('5');
     });
+
+    it(
+        'should handle case 6 diagram - auto increment',
+        { timeout: 30000 },
+        async () => {
+            testCase('6');
+        }
+    );
 });

src/lib/dbml/dbml-export/__tests__/timestamp-with-timezone.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect } from 'vitest';
+import { generateDBMLFromDiagram } from '../dbml-export';
+import { importDBMLToDiagram } from '../../dbml-import/dbml-import';
+import { DatabaseType } from '@/lib/domain/database-type';
+import type { Diagram } from '@/lib/domain/diagram';
+import { generateId, generateDiagramId } from '@/lib/utils';
+
+describe('DBML Export - Timestamp with Time Zone', () => {
+    it('should preserve "timestamp with time zone" type through export and reimport', async () => {
+        // Create a diagram with timestamp with time zone field
+        const diagram: Diagram = {
+            id: generateDiagramId(),
+            name: 'Test Diagram',
+            databaseType: DatabaseType.POSTGRESQL,
+            tables: [
+                {
+                    id: generateId(),
+                    name: 'events',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [
+                        {
+                            id: generateId(),
+                            name: 'id',
+                            type: { id: 'integer', name: 'integer' },
+                            primaryKey: true,
+                            unique: true,
+                            nullable: false,
+                            createdAt: Date.now(),
+                        },
+                        {
+                            id: generateId(),
+                            name: 'created_at',
+                            type: {
+                                id: 'timestamp_with_time_zone',
+                                name: 'timestamp with time zone',
+                            },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                        {
+                            id: generateId(),
+                            name: 'updated_at',
+                            type: {
+                                id: 'timestamp_without_time_zone',
+                                name: 'timestamp without time zone',
+                            },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                    ],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+            ],
+            relationships: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        // Export to DBML
+        const exportResult = generateDBMLFromDiagram(diagram);
+
+        // Verify the DBML contains quoted multi-word types
+        expect(exportResult.inlineDbml).toContain('"timestamp with time zone"');
+        expect(exportResult.inlineDbml).toContain(
+            '"timestamp without time zone"'
+        );
+
+        // Reimport the DBML
+        const reimportedDiagram = await importDBMLToDiagram(
+            exportResult.inlineDbml,
+            {
+                databaseType: DatabaseType.POSTGRESQL,
+            }
+        );
+
+        // Verify the types are preserved
+        const table = reimportedDiagram.tables?.find(
+            (t) => t.name === 'events'
+        );
+        expect(table).toBeDefined();
+
+        const createdAtField = table?.fields.find(
+            (f) => f.name === 'created_at'
+        );
+        const updatedAtField = table?.fields.find(
+            (f) => f.name === 'updated_at'
+        );
+
+        expect(createdAtField?.type.name).toBe('timestamp with time zone');
+        expect(updatedAtField?.type.name).toBe('timestamp without time zone');
+    });
+
+    it('should handle time with time zone types', async () => {
+        const diagram: Diagram = {
+            id: generateDiagramId(),
+            name: 'Test Diagram',
+            databaseType: DatabaseType.POSTGRESQL,
+            tables: [
+                {
+                    id: generateId(),
+                    name: 'schedules',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [
+                        {
+                            id: generateId(),
+                            name: 'id',
+                            type: { id: 'integer', name: 'integer' },
+                            primaryKey: true,
+                            unique: true,
+                            nullable: false,
+                            createdAt: Date.now(),
+                        },
+                        {
+                            id: generateId(),
+                            name: 'start_time',
+                            type: {
+                                id: 'time_with_time_zone',
+                                name: 'time with time zone',
+                            },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                        {
+                            id: generateId(),
+                            name: 'end_time',
+                            type: {
+                                id: 'time_without_time_zone',
+                                name: 'time without time zone',
+                            },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                    ],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+            ],
+            relationships: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const exportResult = generateDBMLFromDiagram(diagram);
+
+        expect(exportResult.inlineDbml).toContain('"time with time zone"');
+        expect(exportResult.inlineDbml).toContain('"time without time zone"');
+
+        const reimportedDiagram = await importDBMLToDiagram(
+            exportResult.inlineDbml,
+            {
+                databaseType: DatabaseType.POSTGRESQL,
+            }
+        );
+
+        const table = reimportedDiagram.tables?.find(
+            (t) => t.name === 'schedules'
+        );
+        const startTimeField = table?.fields.find(
+            (f) => f.name === 'start_time'
+        );
+        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');
+    });
+
+    it('should handle double precision type', async () => {
+        const diagram: Diagram = {
+            id: generateDiagramId(),
+            name: 'Test Diagram',
+            databaseType: DatabaseType.POSTGRESQL,
+            tables: [
+                {
+                    id: generateId(),
+                    name: 'measurements',
+                    schema: 'public',
+                    x: 0,
+                    y: 0,
+                    fields: [
+                        {
+                            id: generateId(),
+                            name: 'id',
+                            type: { id: 'integer', name: 'integer' },
+                            primaryKey: true,
+                            unique: true,
+                            nullable: false,
+                            createdAt: Date.now(),
+                        },
+                        {
+                            id: generateId(),
+                            name: 'value',
+                            type: {
+                                id: 'double_precision',
+                                name: 'double precision',
+                            },
+                            primaryKey: false,
+                            unique: false,
+                            nullable: true,
+                            createdAt: Date.now(),
+                        },
+                    ],
+                    indexes: [],
+                    color: '#8eb7ff',
+                    isView: false,
+                    createdAt: Date.now(),
+                },
+            ],
+            relationships: [],
+            createdAt: new Date(),
+            updatedAt: new Date(),
+        };
+
+        const exportResult = generateDBMLFromDiagram(diagram);
+
+        expect(exportResult.inlineDbml).toContain('"double precision"');
+
+        const reimportedDiagram = await importDBMLToDiagram(
+            exportResult.inlineDbml,
+            {
+                databaseType: DatabaseType.POSTGRESQL,
+            }
+        );
+
+        const table = reimportedDiagram.tables?.find(
+            (t) => t.name === 'measurements'
+        );
+        const valueField = table?.fields.find((f) => f.name === 'value');
+
+        expect(valueField?.type.name).toBe('double precision');
+    });
+});

src/lib/dbml/dbml-export/dbml-export.ts

@@ -583,6 +583,54 @@ const fixMultilineTableNames = (dbml: string): string => {
     );
 };
 
+// Restore increment attribute for auto-incrementing fields
+const restoreIncrementAttribute = (dbml: string, tables: DBTable[]): string => {
+    if (!tables || tables.length === 0) return dbml;
+
+    let result = dbml;
+
+    tables.forEach((table) => {
+        // Find fields with increment=true
+        const incrementFields = table.fields.filter((f) => f.increment);
+
+        incrementFields.forEach((field) => {
+            // Build the table identifier pattern
+            const tableIdentifier = table.schema
+                ? `"${table.schema.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"\\."${table.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"`
+                : `"${table.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"`;
+
+            // Escape field name for regex
+            const escapedFieldName = field.name.replace(
+                /[.*+?^${}()|[\]\\]/g,
+                '\\$&'
+            );
+
+            // Pattern to match the field line with existing attributes in brackets
+            // Matches: "field_name" type [existing, attributes]
+            const fieldPattern = new RegExp(
+                `(Table ${tableIdentifier} \\{[^}]*?^\\s*"${escapedFieldName}"[^\\[\\n]+)(\\[[^\\]]*\\])`,
+                'gms'
+            );
+
+            result = result.replace(
+                fieldPattern,
+                (match, fieldPart, brackets) => {
+                    // Check if increment already exists
+                    if (brackets.includes('increment')) {
+                        return match;
+                    }
+
+                    // Add increment to the attributes
+                    const newBrackets = brackets.replace(']', ', increment]');
+                    return fieldPart + newBrackets;
+                }
+            );
+        });
+    });
+
+    return result;
+};
+
 // Restore composite primary key names in the DBML
 const restoreCompositePKNames = (dbml: string, tables: DBTable[]): string => {
     if (!tables || tables.length === 0) return dbml;
@@ -759,31 +807,37 @@ export function generateDBMLFromDiagram(diagram: Diagram): DBMLExportResult {
             };
         }) ?? [];
 
-    // Remove duplicate tables (consider both schema and table name)
+    // Filter out empty tables and duplicates in a single pass for performance
     const seenTableIdentifiers = new Set<string>();
-    const uniqueTables = sanitizedTables.filter((table) => {
+    const tablesWithFields = sanitizedTables.filter((table) => {
+        // Skip tables with no fields (empty tables cause DBML export to fail)
+        if (table.fields.length === 0) {
+            return false;
+        }
+
         // Create a unique identifier combining schema and table name
         const tableIdentifier = table.schema
             ? `${table.schema}.${table.name}`
             : table.name;
 
+        // Skip duplicate tables
         if (seenTableIdentifiers.has(tableIdentifier)) {
-            return false; // Skip duplicate
+            return false;
         }
         seenTableIdentifiers.add(tableIdentifier);
-        return true; // Keep unique table
+        return true; // Keep unique, non-empty table
     });
 
     // Create the base filtered diagram structure
     const filteredDiagram: Diagram = {
         ...diagram,
-        tables: uniqueTables,
+        tables: tablesWithFields,
         relationships:
             diagram.relationships?.filter((rel) => {
-                const sourceTable = uniqueTables.find(
+                const sourceTable = tablesWithFields.find(
                     (t) => t.id === rel.sourceTableId
                 );
-                const targetTable = uniqueTables.find(
+                const targetTable = tablesWithFields.find(
                     (t) => t.id === rel.targetTableId
                 );
                 const sourceFieldExists = sourceTable?.fields.some(
@@ -883,10 +937,13 @@ export function generateDBMLFromDiagram(diagram: Diagram): DBMLExportResult {
         );
 
         // Restore schema information that may have been stripped by DBML importer
-        standard = restoreTableSchemas(standard, uniqueTables);
+        standard = restoreTableSchemas(standard, tablesWithFields);
 
         // Restore composite primary key names
-        standard = restoreCompositePKNames(standard, uniqueTables);
+        standard = restoreCompositePKNames(standard, tablesWithFields);
+
+        // Restore increment attribute for auto-incrementing fields
+        standard = restoreIncrementAttribute(standard, tablesWithFields);
 
         // Prepend Enum DBML to the standard output
         if (enumsDBML) {

src/lib/dbml/dbml-import/__tests__/dbml-import-cases.test.ts

@@ -342,4 +342,85 @@ describe('DBML Import cases', () => {
         );
         expect(createdAtField?.default).toBe('now()');
     });
+
+    it('should handle auto-increment fields correctly', async () => {
+        const dbmlContent = `Table "public"."table_1" {
+  "id" integer [pk, not null, increment]
+  "field_2" bigint [increment]
+  "field_3" serial [increment]
+  "field_4" varchar(100) [not null]
+}`;
+
+        const result = await importDBMLToDiagram(dbmlContent, {
+            databaseType: DatabaseType.POSTGRESQL,
+        });
+
+        expect(result.tables).toHaveLength(1);
+        const table = result.tables![0];
+        expect(table.name).toBe('table_1');
+        expect(table.fields).toHaveLength(4);
+
+        // field with [pk, not null, increment] - should be not null and increment
+        const idField = table.fields.find((f) => f.name === 'id');
+        expect(idField?.increment).toBe(true);
+        expect(idField?.nullable).toBe(false);
+        expect(idField?.primaryKey).toBe(true);
+
+        // field with [increment] only - should be not null and increment
+        // (auto-increment requires NOT NULL even if not explicitly stated)
+        const field2 = table.fields.find((f) => f.name === 'field_2');
+        expect(field2?.increment).toBe(true);
+        expect(field2?.nullable).toBe(false); // CRITICAL: must be false!
+
+        // SERIAL type with [increment] - should be not null and increment
+        const field3 = table.fields.find((f) => f.name === 'field_3');
+        expect(field3?.increment).toBe(true);
+        expect(field3?.nullable).toBe(false);
+        expect(field3?.type?.name).toBe('serial');
+
+        // Regular field with [not null] - should be not null, no increment
+        const field4 = table.fields.find((f) => f.name === 'field_4');
+        expect(field4?.increment).toBeUndefined();
+        expect(field4?.nullable).toBe(false);
+    });
+
+    it('should handle SERIAL types without increment attribute', async () => {
+        const dbmlContent = `Table "public"."test_table" {
+  "id" serial [pk]
+  "counter" bigserial
+  "small_counter" smallserial
+  "regular" integer
+}`;
+
+        const result = await importDBMLToDiagram(dbmlContent, {
+            databaseType: DatabaseType.POSTGRESQL,
+        });
+
+        expect(result.tables).toHaveLength(1);
+        const table = result.tables![0];
+        expect(table.fields).toHaveLength(4);
+
+        // SERIAL type without [increment] - should STILL be not null (type requires it)
+        const idField = table.fields.find((f) => f.name === 'id');
+        expect(idField?.type?.name).toBe('serial');
+        expect(idField?.nullable).toBe(false); // CRITICAL: Type requires NOT NULL
+        expect(idField?.primaryKey).toBe(true);
+
+        // BIGSERIAL without [increment] - should be not null
+        const counterField = table.fields.find((f) => f.name === 'counter');
+        expect(counterField?.type?.name).toBe('bigserial');
+        expect(counterField?.nullable).toBe(false); // CRITICAL: Type requires NOT NULL
+
+        // SMALLSERIAL without [increment] - should be not null
+        const smallCounterField = table.fields.find(
+            (f) => f.name === 'small_counter'
+        );
+        expect(smallCounterField?.type?.name).toBe('smallserial');
+        expect(smallCounterField?.nullable).toBe(false); // CRITICAL: Type requires NOT NULL
+
+        // Regular INTEGER - should be nullable by default
+        const regularField = table.fields.find((f) => f.name === 'regular');
+        expect(regularField?.type?.name).toBe('integer');
+        expect(regularField?.nullable).toBe(true); // No NOT NULL constraint
+    });
 });

src/lib/dbml/dbml-import/dbml-import.ts

@@ -5,7 +5,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 { DataTypeData } from '@/lib/data/data-types/data-types';
-import { findDataTypeDataById } from '@/lib/data/data-types/data-types';
+import {
+    findDataTypeDataById,
+    requiresNotNull,
+} from '@/lib/data/data-types/data-types';
 import { defaultTableColor } from '@/lib/colors';
 import { DatabaseType } from '@/lib/domain/database-type';
 import type Field from '@dbml/core/types/model_structure/field';
@@ -552,7 +555,10 @@ export const importDBMLToDiagram = async (
                         ...options,
                         enums: extractedData.enums,
                     }),
-                    nullable: !field.not_null,
+                    nullable:
+                        field.increment || requiresNotNull(field.type.type_name)
+                            ? false
+                            : !field.not_null,
                     primaryKey: field.pk || false,
                     unique: field.unique || field.pk || false, // Primary keys are always unique
                     createdAt: Date.now(),

src/pages/editor-page/canvas/table-node/table-edit-mode/table-edit-mode-field.tsx

@@ -13,6 +13,7 @@ import { useTranslation } from 'react-i18next';
 import { SelectBox } from '@/components/select-box/select-box';
 import { cn } from '@/lib/utils';
 import { TableFieldToggle } from './table-field-toggle';
+import { requiresNotNull } from '@/lib/data/data-types/data-types';
 
 export interface TableEditModeFieldProps {
     table: DBTable;
@@ -41,6 +42,8 @@ export const TableEditModeField: React.FC<TableEditModeFieldProps> = React.memo(
 
         const inputRef = React.useRef<HTMLInputElement>(null);
 
+        const typeRequiresNotNull = requiresNotNull(field.type.name);
+
         // Animate the highlight after mount if focused
         useEffect(() => {
             if (focused) {
@@ -135,6 +138,7 @@ export const TableEditModeField: React.FC<TableEditModeFieldProps> = React.memo(
                                 <TableFieldToggle
                                     pressed={nullable}
                                     onPressedChange={handleNullableToggle}
+                                    disabled={typeRequiresNotNull}
                                 >
                                     N
                                 </TableFieldToggle>

src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-field/table-field-modal/table-field-modal.tsx

@@ -9,6 +9,7 @@ import {
     findDataTypeDataById,
     supportsAutoIncrementDataType,
     supportsArrayDataType,
+    autoIncrementAlwaysOn,
 } from '@/lib/data/data-types/data-types';
 import {
     Popover,
@@ -111,6 +112,18 @@ export const TableFieldPopover: React.FC<TableFieldPopoverProps> = ({
         [field.type.name, databaseType]
     );
 
+    // Check if this is a SERIAL-type that is inherently auto-incrementing
+    const forceAutoIncrement = useMemo(
+        () => autoIncrementAlwaysOn(field.type.name) && !localField.nullable,
+        [field.type.name, localField.nullable]
+    );
+
+    // Auto-increment is disabled if the field is nullable (auto-increment requires NOT NULL)
+    const isIncrementDisabled = useMemo(
+        () => localField.nullable || readonly || forceAutoIncrement,
+        [localField.nullable, readonly, forceAutoIncrement]
+    );
+
     return (
         <Popover
             open={isOpen}
@@ -166,10 +179,12 @@ export const TableFieldPopover: React.FC<TableFieldPopoverProps> = ({
                                     )}
                                 </Label>
                                 <Checkbox
-                                    checked={localField.increment ?? false}
-                                    disabled={
-                                        !localField.primaryKey || readonly
+                                    checked={
+                                        forceAutoIncrement
+                                            ? true
+                                            : (localField.increment ?? false)
                                     }
+                                    disabled={isIncrementDisabled}
                                     onCheckedChange={(value) =>
                                         setLocalField((current) => ({
                                             ...current,

src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-field/table-field.tsx

@@ -15,6 +15,7 @@ import { CSS } from '@dnd-kit/utilities';
 import { SelectBox } from '@/components/select-box/select-box';
 import { TableFieldPopover } from './table-field-modal/table-field-modal';
 import type { DatabaseType, DBTable } from '@/lib/domain';
+import { requiresNotNull } from '@/lib/data/data-types/data-types';
 
 export interface TableFieldProps {
     table: DBTable;
@@ -55,6 +56,8 @@ export const TableField: React.FC<TableFieldProps> = ({
         transition,
     };
 
+    const typeRequiresNotNull = requiresNotNull(field.type.name);
+
     return (
         <div
             className="flex flex-1 touch-none flex-row justify-between gap-2 p-1"
@@ -130,7 +133,7 @@ export const TableField: React.FC<TableFieldProps> = ({
                             <TableFieldToggle
                                 pressed={nullable}
                                 onPressedChange={handleNullableToggle}
-                                disabled={readonly}
+                                disabled={readonly || typeRequiresNotNull}
                             >
                                 N
                             </TableFieldToggle>