Database diagrams editor that allows you to visualize and design your DB with a single query.
TypeScript databasedbdb-migrationeditorerdmariadbmssqlmysqlpostgresqlreactreact-flowschema-migrationssqlsqlitetypescriptvisualizationxyflow
fix: preserve composite primary key constraint names across import/export workflows (#869)
Jonathan Fishner215d57979df2
diff --git a/src/context/chartdb-context/chartdb-provider.tsx b/src/context/chartdb-context/chartdb-provider.tsxindex 7a0b04a8..99a3b985 100644--- a/src/context/chartdb-context/chartdb-provider.tsx+++ b/src/context/chartdb-context/chartdb-provider.tsx@@ -6,7 +6,10 @@ import type { ChartDBContext, ChartDBEvent } from './chartdb-context';import { chartDBContext } from './chartdb-context';import { DatabaseType } from '@/lib/domain/database-type';import type { DBField } from '@/lib/domain/db-field';-import type { DBIndex } from '@/lib/domain/db-index';+import {+ getTableIndexesWithPrimaryKey,+ type DBIndex,+} from '@/lib/domain/db-index';import type { DBRelationship } from '@/lib/domain/db-relationship';import { useStorage } from '@/hooks/use-storage';import { useRedoUndoStack } from '@/hooks/use-redo-undo-stack';@@ -348,6 +351,11 @@ export const ChartDBProvider: React.FC<order: tables.length,...attributes,};++ table.indexes = getTableIndexesWithPrimaryKey({+ table,+ });+await addTable(table);return table;@@ -639,17 +647,30 @@ export const ChartDBProvider: React.FC<options = { updateHistory: true }) => {const prevField = getField(tableId, fieldId);++ const updateTableFn = (table: DBTable) => {+ const updatedTable: DBTable = {+ ...table,+ fields: table.fields.map((f) =>+ f.id === fieldId ? { ...f, ...field } : f+ ),+ } satisfies DBTable;++ updatedTable.indexes = getTableIndexesWithPrimaryKey({+ table: updatedTable,+ });++ return updatedTable;+ };+setTables((tables) =>- tables.map((table) =>- table.id === tableId- ? {- ...table,- fields: table.fields.map((f) =>- f.id === fieldId ? { ...f, ...field } : f- ),- }- : table- )+ tables.map((table) => {+ if (table.id === tableId) {+ return updateTableFn(table);+ }++ return table;+ }));const table = await db.getTable({ diagramId, id: tableId });@@ -664,10 +685,7 @@ export const ChartDBProvider: React.FC<db.updateTable({id: tableId,attributes: {- ...table,- fields: table.fields.map((f) =>- f.id === fieldId ? { ...f, ...field } : f- ),+ ...updateTableFn(table),},}),]);@@ -694,19 +712,29 @@ export const ChartDBProvider: React.FC<fieldId: string,options = { updateHistory: true }) => {+ const updateTableFn = (table: DBTable) => {+ const updatedTable: DBTable = {+ ...table,+ fields: table.fields.filter((f) => f.id !== fieldId),+ } satisfies DBTable;++ updatedTable.indexes = getTableIndexesWithPrimaryKey({+ table: updatedTable,+ });++ return updatedTable;+ };+const fields = getTable(tableId)?.fields ?? [];const prevField = getField(tableId, fieldId);setTables((tables) =>- tables.map((table) =>- table.id === tableId- ? {- ...table,- fields: table.fields.filter(- (f) => f.id !== fieldId- ),- }- : table- )+ tables.map((table) => {+ if (table.id === tableId) {+ return updateTableFn(table);+ }++ return table;+ }));events.emit({@@ -730,8 +758,7 @@ export const ChartDBProvider: React.FC<db.updateTable({id: tableId,attributes: {- ...table,- fields: table.fields.filter((f) => f.id !== fieldId),+ ...updateTableFn(table),},}),]);diff --git a/src/lib/data/export-metadata/__tests__/export-sql-dbml.test.ts b/src/lib/data/export-metadata/__tests__/export-sql-dbml.test.tsindex 47f9e4e4..28f28f55 100644--- a/src/lib/data/export-metadata/__tests__/export-sql-dbml.test.ts+++ b/src/lib/data/export-metadata/__tests__/export-sql-dbml.test.ts@@ -124,6 +124,96 @@ describe('DBML Export - SQL Generation Tests', () => {);});+ it('should not create duplicate index for composite primary key', () => {+ const tableId = testId();+ const field1Id = testId();+ const field2Id = testId();+ const field3Id = testId();++ const diagram: Diagram = createDiagram({+ id: testId(),+ name: 'Landlord System',+ databaseType: DatabaseType.POSTGRESQL,+ tables: [+ createTable({+ id: tableId,+ name: 'users_master_table',+ schema: 'landlord',+ fields: [+ createField({+ id: field1Id,+ name: 'master_user_id',+ type: { id: 'bigint', name: 'bigint' },+ primaryKey: true,+ nullable: false,+ unique: false,+ }),+ createField({+ id: field2Id,+ name: 'tenant_id',+ type: { id: 'bigint', name: 'bigint' },+ primaryKey: true,+ nullable: false,+ unique: false,+ }),+ createField({+ id: field3Id,+ name: 'tenant_user_id',+ type: { id: 'bigint', name: 'bigint' },+ primaryKey: true,+ nullable: false,+ unique: false,+ }),+ createField({+ id: testId(),+ name: 'enabled',+ type: { id: 'boolean', name: 'boolean' },+ primaryKey: false,+ nullable: true,+ unique: false,+ }),+ ],+ indexes: [+ {+ id: testId(),+ name: 'idx_users_master_table_master_user_id_tenant_id_tenant_user_id',+ unique: false,+ fieldIds: [field1Id, field2Id, field3Id],+ createdAt: testTime,+ },+ {+ id: testId(),+ name: 'index_1',+ unique: true,+ fieldIds: [field2Id, field3Id],+ createdAt: testTime,+ },+ ],+ }),+ ],+ relationships: [],+ });++ const sql = exportBaseSQL({+ diagram,+ targetDatabaseType: DatabaseType.POSTGRESQL,+ isDBMLFlow: true,+ });++ // Should contain composite primary key constraint+ expect(sql).toContain(+ 'PRIMARY KEY (master_user_id, tenant_id, tenant_user_id)'+ );++ // Should NOT contain the duplicate index for the primary key fields+ expect(sql).not.toContain(+ 'CREATE INDEX idx_users_master_table_master_user_id_tenant_id_tenant_user_id'+ );++ // Should still contain the unique index on subset of fields+ expect(sql).toContain('CREATE UNIQUE INDEX index_1');+ });+it('should handle single primary keys inline', () => {const diagram: Diagram = createDiagram({id: testId(),diff --git a/src/lib/data/export-metadata/export-per-type/mssql.ts b/src/lib/data/export-metadata/export-per-type/mssql.tsindex 5a52c347..071a6ab2 100644--- a/src/lib/data/export-metadata/export-per-type/mssql.ts+++ b/src/lib/data/export-metadata/export-per-type/mssql.ts@@ -178,7 +178,15 @@ export function exportMSSQL({}).join(',\n')}${table.fields.filter((f) => f.primaryKey).length > 0- ? `,\n PRIMARY KEY (${table.fields+ ? `,\n ${(() => {+ // Find PK index to get the constraint name+ const pkIndex = table.indexes.find(+ (idx) => idx.isPrimaryKey+ );+ return pkIndex?.name+ ? `CONSTRAINT [${pkIndex.name}] `+ : '';+ })()}PRIMARY KEY (${table.fields.filter((f) => f.primaryKey).map((f) => `[${f.name}]`).join(', ')})`diff --git a/src/lib/data/export-metadata/export-per-type/mysql.ts b/src/lib/data/export-metadata/export-per-type/mysql.tsindex 53601525..c8a75ab6 100644--- a/src/lib/data/export-metadata/export-per-type/mysql.ts+++ b/src/lib/data/export-metadata/export-per-type/mysql.ts@@ -313,7 +313,15 @@ export function exportMySQL({.join(',\n')}${// Add PRIMARY KEY as table constraintprimaryKeyFields.length > 0- ? `,\n PRIMARY KEY (${primaryKeyFields+ ? `,\n ${(() => {+ // Find PK index to get the constraint name+ const pkIndex = table.indexes.find(+ (idx) => idx.isPrimaryKey+ );+ return pkIndex?.name+ ? `CONSTRAINT \`${pkIndex.name}\` `+ : '';+ })()}PRIMARY KEY (${primaryKeyFields.map((f) => `\`${f.name}\``).join(', ')})`: ''diff --git a/src/lib/data/export-metadata/export-per-type/postgresql.ts b/src/lib/data/export-metadata/export-per-type/postgresql.tsindex a745bd5d..dbe1ffc5 100644--- a/src/lib/data/export-metadata/export-per-type/postgresql.ts+++ b/src/lib/data/export-metadata/export-per-type/postgresql.ts@@ -325,7 +325,15 @@ export function exportPostgreSQL({}).join(',\n')}${primaryKeyFields.length > 0- ? `,\n PRIMARY KEY (${primaryKeyFields+ ? `,\n ${(() => {+ // Find PK index to get the constraint name+ const pkIndex = table.indexes.find(+ (idx) => idx.isPrimaryKey+ );+ return pkIndex?.name+ ? `CONSTRAINT "${pkIndex.name}" `+ : '';+ })()}PRIMARY KEY (${primaryKeyFields.map((f) => `"${f.name}"`).join(', ')})`: ''diff --git a/src/lib/data/export-metadata/export-sql-script.ts b/src/lib/data/export-metadata/export-sql-script.tsindex f152918e..007bb888 100644--- a/src/lib/data/export-metadata/export-sql-script.ts+++ b/src/lib/data/export-metadata/export-sql-script.ts@@ -313,21 +313,33 @@ export const exportBaseSQL = ({}}- // Handle PRIMARY KEY constraint - only add inline if not composite- if (field.primaryKey && !hasCompositePrimaryKey) {+ // Handle PRIMARY KEY constraint - only add inline if no PK index with custom name+ const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);+ if (field.primaryKey && !hasCompositePrimaryKey && !pkIndex?.name) {sqlScript += ' PRIMARY KEY';}- // Add a comma after each field except the last one (or before composite primary key)- if (index < table.fields.length - 1 || hasCompositePrimaryKey) {+ // Add a comma after each field except the last one (or before PK constraint)+ const needsPKConstraint =+ hasCompositePrimaryKey ||+ (primaryKeyFields.length === 1 && pkIndex?.name);+ if (index < table.fields.length - 1 || needsPKConstraint) {sqlScript += ',\n';}});- // Add composite primary key constraint if needed- if (hasCompositePrimaryKey) {+ // Add primary key constraint if needed (for composite PKs or single PK with custom name)+ const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);+ if (+ hasCompositePrimaryKey ||+ (primaryKeyFields.length === 1 && pkIndex?.name)+ ) {const pkFieldNames = primaryKeyFields.map((f) => f.name).join(', ');- sqlScript += `\n PRIMARY KEY (${pkFieldNames})`;+ if (pkIndex?.name) {+ sqlScript += `\n CONSTRAINT ${pkIndex.name} PRIMARY KEY (${pkFieldNames})`;+ } else {+ sqlScript += `\n PRIMARY KEY (${pkFieldNames})`;+ }}sqlScript += '\n);\n';@@ -349,12 +361,33 @@ export const exportBaseSQL = ({// Generate SQL for indexestable.indexes.forEach((index) => {- const fieldNames = index.fieldIds- .map(- (fieldId) =>- table.fields.find((field) => field.id === fieldId)?.name+ // Skip the primary key index (it's already handled as a constraint)+ if (index.isPrimaryKey) {+ return;+ }++ // Get the fields for this index+ const indexFields = index.fieldIds+ .map((fieldId) => table.fields.find((f) => f.id === fieldId))+ .filter(+ (field): field is NonNullable<typeof field> =>+ field !== undefined+ );++ // Skip if this index exactly matches the primary key fields+ // This prevents creating redundant indexes for composite primary keys+ if (+ primaryKeyFields.length > 0 &&+ primaryKeyFields.length === indexFields.length &&+ primaryKeyFields.every((pk) =>+ indexFields.some((field) => field.id === pk.id))- .filter(Boolean)+ ) {+ return; // Skip this index as it's redundant with the primary key+ }++ const fieldNames = indexFields+ .map((field) => field.name).join(', ');if (fieldNames) {diff --git a/src/lib/dbml/dbml-export/__tests__/composite-pk-export.test.ts b/src/lib/dbml/dbml-export/__tests__/composite-pk-export.test.tsnew file mode 100644index 00000000..d78fa169--- /dev/null+++ b/src/lib/dbml/dbml-export/__tests__/composite-pk-export.test.ts@@ -0,0 +1,114 @@+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 } from '@/lib/utils';++describe('Composite Primary Key Name Export', () => {+ it('should export composite primary key with name in DBML', () => {+ const diagram: Diagram = {+ id: generateId(),+ name: 'Test',+ databaseType: DatabaseType.POSTGRESQL,+ createdAt: new Date(),+ updatedAt: new Date(),+ tables: [+ {+ id: generateId(),+ name: 'users_master_table',+ schema: 'landlord',+ x: 0,+ y: 0,+ color: '#FFF',+ isView: false,+ createdAt: Date.now(),+ fields: [+ {+ id: generateId(),+ name: 'master_user_id',+ type: { id: 'bigint', name: 'bigint' },+ nullable: false,+ primaryKey: true,+ unique: false,+ createdAt: Date.now(),+ },+ {+ id: generateId(),+ name: 'tenant_id',+ type: { id: 'bigint', name: 'bigint' },+ nullable: false,+ primaryKey: true,+ unique: false,+ createdAt: Date.now(),+ },+ {+ id: generateId(),+ name: 'tenant_user_id',+ type: { id: 'bigint', name: 'bigint' },+ nullable: false,+ primaryKey: true,+ unique: false,+ createdAt: Date.now(),+ },+ {+ id: generateId(),+ name: 'enabled',+ type: { id: 'boolean', name: 'boolean' },+ nullable: true,+ primaryKey: false,+ unique: false,+ createdAt: Date.now(),+ },+ ],+ indexes: [+ {+ id: generateId(),+ name: 'users_master_table_index_1',+ unique: true,+ fieldIds: ['dummy1', 'dummy2'], // Will be replaced+ createdAt: Date.now(),+ },+ ],+ },+ ],+ relationships: [],+ };++ // Fix field IDs in the index and add PK index+ const table = diagram.tables![0];+ const masterUserIdField = table.fields.find(+ (f) => f.name === 'master_user_id'+ );+ const tenantIdField = table.fields.find((f) => f.name === 'tenant_id');+ const tenantUserIdField = table.fields.find(+ (f) => f.name === 'tenant_user_id'+ );+ table.indexes[0].fieldIds = [tenantIdField!.id, tenantUserIdField!.id];++ // Add the PK index with name+ table.indexes.push({+ id: generateId(),+ name: 'moshe',+ unique: true,+ isPrimaryKey: true,+ fieldIds: [+ masterUserIdField!.id,+ tenantIdField!.id,+ tenantUserIdField!.id,+ ],+ createdAt: Date.now(),+ });++ const result = generateDBMLFromDiagram(diagram);++ // Check that the DBML contains the composite PK with name+ expect(result.standardDbml).toContain(+ '(master_user_id, tenant_id, tenant_user_id) [pk, name: "moshe"]'+ );++ // Check that the unique index is also present+ expect(result.standardDbml).toContain(+ '(tenant_id, tenant_user_id) [unique, name: "users_master_table_index_1"]'+ );+ });+});diff --git a/src/lib/dbml/dbml-export/__tests__/dbml-export-issue-fix.test.ts b/src/lib/dbml/dbml-export/__tests__/dbml-export-issue-fix.test.tsindex 7b4f4815..213cc063 100644--- a/src/lib/dbml/dbml-export/__tests__/dbml-export-issue-fix.test.ts+++ b/src/lib/dbml/dbml-export/__tests__/dbml-export-issue-fix.test.ts@@ -1383,12 +1383,9 @@ Ref "fk_0_table_2_id_fk":"table_1"."id" < "table_2"."id"const result = generateDBMLFromDiagram(diagram);// Check that the inline DBML has proper indentation+ // Note: indexes on primary key fields should be filtered outexpect(result.inlineDbml).toContain(`Table "table_1" {"id" bigint [pk, not null]-- Indexes {- id [name: "index_1"]- }}`);expect(result.inlineDbml).toContain(`Table "table_2" {diff --git a/src/lib/dbml/dbml-export/dbml-export.ts b/src/lib/dbml/dbml-export/dbml-export.tsindex f49a54d0..2a70efbf 100644--- a/src/lib/dbml/dbml-export/dbml-export.ts+++ b/src/lib/dbml/dbml-export/dbml-export.ts@@ -605,6 +605,45 @@ const fixTableBracketSyntax = (dbml: string): string => {);};+// Restore composite primary key names in the DBML+const restoreCompositePKNames = (dbml: string, tables: DBTable[]): string => {+ if (!tables || tables.length === 0) return dbml;++ let result = dbml;++ tables.forEach((table) => {+ // Check if this table has a PK index with a name+ const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);+ if (pkIndex?.name) {+ const primaryKeyFields = table.fields.filter((f) => f.primaryKey);+ if (primaryKeyFields.length >= 1) {+ // Build the column list for the composite PK+ const columnList = primaryKeyFields+ .map((f) => f.name)+ .join(', ');++ // Build the table identifier pattern+ const tableIdentifier = table.schema+ ? `"${table.schema.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"\\."${table.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"`+ : `"${table.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}"`;++ // Pattern to match the composite PK index line+ // Match patterns like: (col1, col2, col3) [pk]+ const pkPattern = new RegExp(+ `(Table ${tableIdentifier} \\{[^}]*?Indexes \\{[^}]*?)(\\(${columnList.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\) \\[pk\\])`,+ 'gs'+ );++ // Replace with the named version+ const replacement = `$1(${columnList}) [pk, name: "${pkIndex.name}"]`;+ result = result.replace(pkPattern, replacement);+ }+ }+ });++ return result;+};+// Restore schema information that may have been stripped by the DBML importerconst restoreTableSchemas = (dbml: string, tables: DBTable[]): string => {if (!tables || tables.length === 0) return dbml;@@ -870,14 +909,16 @@ export function generateDBMLFromDiagram(diagram: Diagram): DBMLExportResult {...table,name: safeTableName,fields: processedFields,- indexes: (table.indexes || []).map((index) => ({- ...index,- name: index.name- ? /[^\w]/.test(index.name)- ? `"${index.name.replace(/"/g, '\\"')}"`- : index.name- : `idx_${Math.random().toString(36).substring(2, 8)}`,- })),+ indexes: (table.indexes || [])+ .filter((index) => !index.isPrimaryKey) // Filter out PK indexes as they're handled separately+ .map((index) => ({+ ...index,+ name: index.name+ ? /[^\w]/.test(index.name)+ ? `"${index.name.replace(/"/g, '\\"')}"`+ : index.name+ : `idx_${Math.random().toString(36).substring(2, 8)}`,+ })),};};@@ -939,6 +980,9 @@ export function generateDBMLFromDiagram(diagram: Diagram): DBMLExportResult {// Restore schema information that may have been stripped by DBML importerstandard = restoreTableSchemas(standard, uniqueTables);+ // Restore composite primary key names+ standard = restoreCompositePKNames(standard, uniqueTables);+// Prepend Enum DBML to the standard outputif (enumsDBML) {standard = enumsDBML + '\n\n' + standard;diff --git a/src/lib/dbml/dbml-import/__tests__/composite-pk-name.test.ts b/src/lib/dbml/dbml-import/__tests__/composite-pk-name.test.tsnew file mode 100644index 00000000..a2fe3e5d--- /dev/null+++ b/src/lib/dbml/dbml-import/__tests__/composite-pk-name.test.ts@@ -0,0 +1,190 @@+import { describe, it, expect } from 'vitest';+import { importDBMLToDiagram } from '../dbml-import';+import { exportPostgreSQL } from '@/lib/data/export-metadata/export-per-type/postgresql';+import { exportMySQL } from '@/lib/data/export-metadata/export-per-type/mysql';+import { exportMSSQL } from '@/lib/data/export-metadata/export-per-type/mssql';+import { DatabaseType } from '@/lib/domain/database-type';++describe('Composite Primary Key with Name', () => {+ it('should preserve composite primary key name in DBML import and SQL export', async () => {+ const dbmlContent = `+Table "landlord"."users_master_table" {+ "master_user_id" bigint [not null]+ "tenant_id" bigint [not null]+ "tenant_user_id" bigint [not null]+ "enabled" boolean++ Indexes {+ (master_user_id, tenant_id, tenant_user_id) [pk, name: "idx_users_master_table_master_user_id_tenant_id_tenant_user_id"]+ (tenant_id, tenant_user_id) [unique, name: "index_1"]+ }+}+`;++ // Import DBML+ const diagram = await importDBMLToDiagram(dbmlContent, {+ databaseType: DatabaseType.POSTGRESQL,+ });++ // Check that the composite PK name was captured+ expect(diagram.tables).toBeDefined();+ const table = diagram.tables![0];++ // Check for the PK index+ const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);+ expect(pkIndex).toBeDefined();+ expect(pkIndex!.name).toBe(+ 'idx_users_master_table_master_user_id_tenant_id_tenant_user_id'+ );++ // Check that fields are marked as primary keys+ const pkFields = table.fields.filter((f) => f.primaryKey);+ expect(pkFields).toHaveLength(3);+ expect(pkFields.map((f) => f.name)).toEqual([+ 'master_user_id',+ 'tenant_id',+ 'tenant_user_id',+ ]);++ // Check that we have both the PK index and the unique index+ expect(table.indexes).toHaveLength(2);+ const uniqueIndex = table.indexes.find((idx) => !idx.isPrimaryKey);+ expect(uniqueIndex!.name).toBe('index_1');+ expect(uniqueIndex!.unique).toBe(true);+ });++ it('should export composite primary key with CONSTRAINT name in PostgreSQL', async () => {+ const dbmlContent = `+Table "users" {+ "id" bigint [not null]+ "tenant_id" bigint [not null]++ Indexes {+ (id, tenant_id) [pk, name: "pk_users_composite"]+ }+}+`;++ const diagram = await importDBMLToDiagram(dbmlContent, {+ databaseType: DatabaseType.POSTGRESQL,+ });++ const sqlScript = exportPostgreSQL({ diagram });++ // Check that the SQL contains the named constraint+ expect(sqlScript).toContain(+ 'CONSTRAINT "pk_users_composite" PRIMARY KEY ("id", "tenant_id")'+ );+ expect(sqlScript).not.toContain('PRIMARY KEY ("id", "tenant_id"),'); // Should not have unnamed PK+ });++ it('should export composite primary key with CONSTRAINT name in MySQL', async () => {+ const dbmlContent = `+Table "orders" {+ "order_id" int [not null]+ "product_id" int [not null]++ Indexes {+ (order_id, product_id) [pk, name: "orders_order_product_pk"]+ }+}+`;++ const diagram = await importDBMLToDiagram(dbmlContent, {+ databaseType: DatabaseType.MYSQL,+ });++ const sqlScript = exportMySQL({ diagram });++ // Check that the SQL contains the named constraint+ expect(sqlScript).toContain(+ 'CONSTRAINT `orders_order_product_pk` PRIMARY KEY (`order_id`, `product_id`)'+ );+ });++ it('should export composite primary key with CONSTRAINT name in MSSQL', async () => {+ const dbmlContent = `+Table "products" {+ "category_id" int [not null]+ "product_id" int [not null]++ Indexes {+ (category_id, product_id) [pk, name: "pk_products"]+ }+}+`;++ const diagram = await importDBMLToDiagram(dbmlContent, {+ databaseType: DatabaseType.SQL_SERVER,+ });++ const sqlScript = exportMSSQL({ diagram });++ // Check that the SQL contains the named constraint+ expect(sqlScript).toContain(+ 'CONSTRAINT [pk_products] PRIMARY KEY ([category_id], [product_id])'+ );+ });++ it('should merge duplicate PK index with name', async () => {+ const dbmlContent = `+Table "test" {+ "a" int [not null]+ "b" int [not null]++ Indexes {+ (a, b) [pk]+ (a, b) [name: "test_pk_name"]+ }+}+`;++ const diagram = await importDBMLToDiagram(dbmlContent, {+ databaseType: DatabaseType.POSTGRESQL,+ });++ expect(diagram.tables).toBeDefined();+ const table = diagram.tables![0];++ // Should capture the name from the duplicate index+ const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);+ expect(pkIndex).toBeDefined();+ expect(pkIndex!.name).toBe('test_pk_name');++ // Should only have the PK index+ expect(table.indexes).toHaveLength(1);++ // Fields should be marked as primary keys+ expect(table.fields.filter((f) => f.primaryKey)).toHaveLength(2);+ });++ it('should handle composite PK without name', async () => {+ const dbmlContent = `+Table "simple" {+ "x" int [not null]+ "y" int [not null]++ Indexes {+ (x, y) [pk]+ }+}+`;++ const diagram = await importDBMLToDiagram(dbmlContent, {+ databaseType: DatabaseType.POSTGRESQL,+ });++ expect(diagram.tables).toBeDefined();+ const table = diagram.tables![0];++ // PK index should not exist for composite PK without name+ const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);+ expect(pkIndex).toBeDefined();++ const sqlScript = exportPostgreSQL({ diagram });++ // Should have unnamed PRIMARY KEY+ expect(sqlScript).toContain('PRIMARY KEY ("x", "y")');+ expect(sqlScript).toContain('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 7c5a3292..c81be0a1 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@@ -177,7 +177,7 @@ Table ranks {expect(wizardsTable?.fields).toHaveLength(11);// Check indexes- expect(wizardsTable?.indexes).toHaveLength(2);+ expect(wizardsTable?.indexes).toHaveLength(3);const emailIndex = wizardsTable?.indexes.find((idx) =>idx.name.includes('email'));@@ -920,7 +920,7 @@ Note dragon_note {expect(hoardsTable).toBeDefined();// Verify all indexes are imported correctly- expect(hoardsTable?.indexes).toHaveLength(3); // Should have 3 indexes as defined in DBML+ expect(hoardsTable?.indexes).toHaveLength(4); // 3 from DBML + 1 implicit PK index// Verify named indexesconst uniqueDragonIndex = hoardsTable?.indexes.find(@@ -1119,7 +1119,7 @@ Table "public_3"."comments" {).toBe('timestamp');// Check posts indexes thoroughly- expect(postsTable?.indexes).toHaveLength(2);+ expect(postsTable?.indexes).toHaveLength(3);// Index 1: Composite unique index on (content, user_id)const compositeIndex = postsTable?.indexes.find(@@ -1154,7 +1154,7 @@ Table "public_3"."comments" {// Check comments tableexpect(commentsTable?.fields).toHaveLength(5);- expect(commentsTable?.indexes).toHaveLength(1);+ expect(commentsTable?.indexes).toHaveLength(2);// Index: Unique index on idconst idIndex = commentsTable?.indexes.find(diff --git a/src/lib/dbml/dbml-import/dbml-import.ts b/src/lib/dbml/dbml-import/dbml-import.tsindex 8d590f5a..10098b47 100644--- a/src/lib/dbml/dbml-import/dbml-import.ts+++ b/src/lib/dbml/dbml-import/dbml-import.ts@@ -9,7 +9,7 @@ import { findDataTypeDataById } 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';-import type { DBIndex } from '@/lib/domain';+import { getTableIndexesWithPrimaryKey, type DBIndex } from '@/lib/domain';import {DBCustomTypeKind,type DBCustomType,@@ -100,6 +100,7 @@ interface DBMLIndex {columns: (string | DBMLIndexColumn)[];unique?: boolean;name?: string;+ pk?: boolean; // Primary key index flag}interface DBMLTable {@@ -387,15 +388,19 @@ export const importDBMLToDiagram = async ();}- // Generate a consistent index name+ // For PK indexes, only use the name if explicitly provided+ // For regular indexes, generate a default name if neededconst indexName =dbmlIndex.name ||- `idx_${table.name}_${indexColumns.join('_')}`;+ (!dbmlIndex.pk+ ? `idx_${table.name}_${indexColumns.join('_')}`+ : undefined);return {columns: indexColumns,unique: dbmlIndex.unique || false,name: indexName,+ pk: Boolean(dbmlIndex.pk) || false,};}) || [],});@@ -484,29 +489,126 @@ export const importDBMLToDiagram = async (};});- // Convert DBML indexes to ChartDB indexes- const indexes: DBIndex[] =- table.indexes?.map((dbmlIndex) => {- const fieldIds = dbmlIndex.columns.map((columnName) => {+ // Process composite primary keys from indexes with [pk] attribute+ let compositePKFields: string[] = [];+ let compositePKIndexName: string | undefined;++ // Find PK indexes and mark fields as primary keys+ table.indexes?.forEach((dbmlIndex) => {+ if (dbmlIndex.pk) {+ // Extract column names from the columns array+ compositePKFields = dbmlIndex.columns.map((col) =>+ typeof col === 'string' ? col : col.value+ );+ // Only store the name if it was explicitly provided (not undefined)+ if (dbmlIndex.name) {+ compositePKIndexName = dbmlIndex.name;+ }+ // Mark fields as primary keys+ dbmlIndex.columns.forEach((col) => {+ const columnName =+ typeof col === 'string' ? col : col.value;const field = fields.find((f) => f.name === columnName);- if (!field) {- throw new Error(- `Index references non-existent column: ${columnName}`- );+ if (field) {+ field.primaryKey = true;}- return field.id;});+ }+ });- return {- id: generateId(),- name:- dbmlIndex.name ||- `idx_${table.name}_${(dbmlIndex.columns as string[]).join('_')}`,- fieldIds,- unique: dbmlIndex.unique || false,- createdAt: Date.now(),- };- }) || [];+ // If we found a PK without a name, look for a duplicate index with just a name+ if (compositePKFields.length > 0 && !compositePKIndexName) {+ table.indexes?.forEach((dbmlIndex) => {+ if (+ !dbmlIndex.pk &&+ dbmlIndex.name &&+ dbmlIndex.columns.length === compositePKFields.length+ ) {+ // Check if columns match+ const indexColumns = dbmlIndex.columns.map((col) =>+ typeof col === 'string' ? col : col.value+ );+ if (+ indexColumns.every(+ (col, i) => col === compositePKFields[i]+ )+ ) {+ compositePKIndexName = dbmlIndex.name;+ }+ }+ });+ }++ // Convert DBML indexes to ChartDB indexes (excluding PK indexes and their duplicates)+ const indexes: DBIndex[] =+ table.indexes+ ?.filter((dbmlIndex) => {+ // Skip PK indexes - we'll handle them separately+ if (dbmlIndex.pk) return false;++ // Skip duplicate indexes that match the composite PK+ // (when user has both [pk] and [name: "..."] on same fields)+ if (+ compositePKFields.length > 0 &&+ dbmlIndex.columns.length ===+ compositePKFields.length &&+ dbmlIndex.columns.every((col, i) => {+ const colName =+ typeof col === 'string' ? col : col.value;+ return colName === compositePKFields[i];+ })+ ) {+ return false;+ }++ return true;+ })+ .map((dbmlIndex) => {+ const fieldIds = dbmlIndex.columns.map((columnName) => {+ const field = fields.find(+ (f) => f.name === columnName+ );+ if (!field) {+ throw new Error(+ `Index references non-existent column: ${columnName}`+ );+ }+ return field.id;+ });++ return {+ id: generateId(),+ name:+ dbmlIndex.name ||+ `idx_${table.name}_${(dbmlIndex.columns as string[]).join('_')}`,+ fieldIds,+ unique: dbmlIndex.unique || false,+ createdAt: Date.now(),+ };+ }) || [];++ // Add PK as an index if it exists and has a name+ // Only create the PK index if there's an explicit name for it+ if (compositePKFields.length >= 1 && compositePKIndexName) {+ const pkFieldIds = compositePKFields.map((columnName) => {+ const field = fields.find((f) => f.name === columnName);+ if (!field) {+ throw new Error(+ `PK references non-existent column: ${columnName}`+ );+ }+ return field.id;+ });++ indexes.push({+ id: generateId(),+ name: compositePKIndexName,+ fieldIds: pkFieldIds,+ unique: true,+ isPrimaryKey: true,+ createdAt: Date.now(),+ });+ }// Extract table note/commentlet tableComment: string | undefined;@@ -521,7 +623,7 @@ export const importDBMLToDiagram = async (}}- return {+ const tableToReturn: DBTable = {id: generateId(),name: table.name.replace(/['"]/g, ''),schema:@@ -540,6 +642,13 @@ export const importDBMLToDiagram = async (createdAt: Date.now(),comments: tableComment,} satisfies DBTable;++ return {+ ...tableToReturn,+ indexes: getTableIndexesWithPrimaryKey({+ table: tableToReturn,+ }),+ };});// Create relationships using the refsdiff --git a/src/lib/domain/__tests__/composite-pk-metadata-import.test.ts b/src/lib/domain/__tests__/composite-pk-metadata-import.test.tsnew file mode 100644index 00000000..252ff579--- /dev/null+++ b/src/lib/domain/__tests__/composite-pk-metadata-import.test.ts@@ -0,0 +1,192 @@+import { describe, it, expect } from 'vitest';+import { createTablesFromMetadata } from '../db-table';+import { DatabaseType } from '../database-type';+import type { DatabaseMetadata } from '@/lib/data/import-metadata/metadata-types/database-metadata';++describe('Composite Primary Key Name from Metadata Import', () => {+ it('should capture composite primary key name from metadata indexes', () => {+ const metadata: DatabaseMetadata = {+ database_name: 'test_db',+ version: '',+ fk_info: [],+ pk_info: [+ {+ schema: 'landlord',+ table: 'users_master_table',+ column: 'master_user_id',+ pk_def: 'PRIMARY KEY (master_user_id, tenant_id, tenant_user_id)',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ column: 'tenant_id',+ pk_def: 'PRIMARY KEY (master_user_id, tenant_id, tenant_user_id)',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ column: 'tenant_user_id',+ pk_def: 'PRIMARY KEY (master_user_id, tenant_id, tenant_user_id)',+ },+ ],+ columns: [+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'master_user_id',+ ordinal_position: 1,+ type: 'bigint',+ character_maximum_length: null,+ precision: null,+ nullable: false,+ default: '',+ collation: '',+ comment: '',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'tenant_id',+ ordinal_position: 2,+ type: 'bigint',+ character_maximum_length: null,+ precision: null,+ nullable: false,+ default: '',+ collation: '',+ comment: '',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'tenant_user_id',+ ordinal_position: 3,+ type: 'bigint',+ character_maximum_length: null,+ precision: null,+ nullable: false,+ default: '',+ collation: '',+ comment: '',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'enabled',+ ordinal_position: 4,+ type: 'boolean',+ character_maximum_length: null,+ precision: null,+ nullable: true,+ default: '',+ collation: '',+ comment: '',+ },+ ],+ indexes: [+ // The composite PK index named "moshe"+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'moshe',+ column: 'master_user_id',+ index_type: 'btree',+ cardinality: 0,+ size: 8192,+ unique: true,+ column_position: 1,+ direction: 'asc',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'moshe',+ column: 'tenant_id',+ index_type: 'btree',+ cardinality: 0,+ size: 8192,+ unique: true,+ column_position: 2,+ direction: 'asc',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'moshe',+ column: 'tenant_user_id',+ index_type: 'btree',+ cardinality: 0,+ size: 8192,+ unique: true,+ column_position: 3,+ direction: 'asc',+ },+ // Another unique index+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'users_master_table_index_1',+ column: 'tenant_id',+ index_type: 'btree',+ cardinality: 0,+ size: 8192,+ unique: true,+ column_position: 1,+ direction: 'asc',+ },+ {+ schema: 'landlord',+ table: 'users_master_table',+ name: 'users_master_table_index_1',+ column: 'tenant_user_id',+ index_type: 'btree',+ cardinality: 0,+ size: 8192,+ unique: true,+ column_position: 2,+ direction: 'asc',+ },+ ],+ tables: [+ {+ schema: 'landlord',+ table: 'users_master_table',+ rows: 0,+ type: 'BASE TABLE',+ engine: '',+ collation: '',+ comment: '',+ },+ ],+ views: [],+ custom_types: [],+ };++ const tables = createTablesFromMetadata({+ databaseMetadata: metadata,+ databaseType: DatabaseType.POSTGRESQL,+ });++ expect(tables).toHaveLength(1);+ const table = tables[0];++ // Check that the composite PK name was captured as "moshe" in the PK index+ const pkIndex = table.indexes.find((idx) => idx.isPrimaryKey);+ expect(pkIndex).toBeDefined();+ expect(pkIndex!.name).toBe('moshe');++ // Check that primary key fields are marked correctly+ const pkFields = table.fields.filter((f) => f.primaryKey);+ expect(pkFields).toHaveLength(3);+ expect(pkFields.map((f) => f.name).sort()).toEqual([+ 'master_user_id',+ 'tenant_id',+ 'tenant_user_id',+ ]);++ // Check that we have both the PK index and the unique index+ expect(table.indexes).toHaveLength(2);+ const uniqueIndex = table.indexes.find((idx) => !idx.isPrimaryKey);+ expect(uniqueIndex!.name).toBe('users_master_table_index_1');+ });+});diff --git a/src/lib/domain/db-index.ts b/src/lib/domain/db-index.tsindex 5c160928..b9a8c900 100644--- a/src/lib/domain/db-index.ts+++ b/src/lib/domain/db-index.ts@@ -3,6 +3,7 @@ import type { AggregatedIndexInfo } from '../data/import-metadata/metadata-typesimport { generateId } from '../utils';import type { DBField } from './db-field';import { DatabaseType } from './database-type';+import type { DBTable } from './db-table';export const INDEX_TYPES = ['btree',@@ -29,6 +30,7 @@ export interface DBIndex {fieldIds: string[];createdAt: number;type?: IndexType | null;+ isPrimaryKey?: boolean | null;}export const dbIndexSchema: z.ZodType<DBIndex> = z.object({@@ -38,6 +40,7 @@ export const dbIndexSchema: z.ZodType<DBIndex> = z.object({fieldIds: z.array(z.string()),createdAt: z.number(),type: z.enum(INDEX_TYPES).optional(),+ isPrimaryKey: z.boolean().or(z.null()).optional(),});export const createIndexesFromMetadata = ({@@ -64,3 +67,51 @@ export const createIndexesFromMetadata = ({export const databaseIndexTypes: { [key in DatabaseType]?: IndexType[] } = {[DatabaseType.POSTGRESQL]: ['btree', 'hash'],};++export const getTablePrimaryKeyIndex = ({+ table,+}: {+ table: DBTable;+}): DBIndex | null => {+ const primaryKeyFields = table.fields.filter((f) => f.primaryKey);+ const existingPKIndex = table.indexes.find((idx) => idx.isPrimaryKey);++ if (primaryKeyFields.length === 0) {+ return null;+ }++ const pkFieldIds = primaryKeyFields.map((f) => f.id);++ if (existingPKIndex) {+ return {+ ...existingPKIndex,+ fieldIds: pkFieldIds,+ };+ } else {+ // Create new PK index for primary key(s)+ const pkIndex: DBIndex = {+ id: generateId(),+ name: `pk_${table.name}_${primaryKeyFields.map((f) => f.name).join('_')}`,+ fieldIds: pkFieldIds,+ unique: true,+ isPrimaryKey: true,+ createdAt: Date.now(),+ };++ return pkIndex;+ }+};++export const getTableIndexesWithPrimaryKey = ({+ table,+}: {+ table: DBTable;+}): DBIndex[] => {+ const primaryKeyIndex = getTablePrimaryKeyIndex({ table });+ const indexesWithoutPKIndex = table.indexes.filter(+ (idx) => !idx.isPrimaryKey+ );+ return primaryKeyIndex+ ? [primaryKeyIndex, ...indexesWithoutPKIndex]+ : indexesWithoutPKIndex;+};diff --git a/src/lib/domain/db-table.ts b/src/lib/domain/db-table.tsindex ecf0de01..4879f469 100644--- a/src/lib/domain/db-table.ts+++ b/src/lib/domain/db-table.ts@@ -203,11 +203,57 @@ export const createTablesFromMetadata = ({tableSchema,});+ // Check for composite primary key and find matching index name+ const primaryKeyFields = fields.filter((f) => f.primaryKey);+ let pkMatchingIndexName: string | undefined;+ let pkIndex: DBIndex | undefined;++ if (primaryKeyFields.length >= 1) {+ // We have a composite primary key, look for an index that matches all PK columns+ const pkFieldNames = primaryKeyFields.map((f) => f.name).sort();++ // Find an index that matches the primary key columns exactly+ const matchingIndex = aggregatedIndexes.find((index) => {+ const indexColumnNames = index.columns+ .map((c) => c.name)+ .sort();+ return (+ indexColumnNames.length === pkFieldNames.length &&+ indexColumnNames.every((col, i) => col === pkFieldNames[i])+ );+ });++ if (matchingIndex) {+ pkMatchingIndexName = matchingIndex.name;+ // Create a special PK index+ pkIndex = {+ id: generateId(),+ name: matchingIndex.name,+ unique: true,+ fieldIds: primaryKeyFields.map((f) => f.id),+ createdAt: Date.now(),+ isPrimaryKey: true,+ };+ }+ }++ // Filter out the index that matches the composite PK (to avoid duplication)+ const filteredAggregatedIndexes = pkMatchingIndexName+ ? aggregatedIndexes.filter(+ (idx) => idx.name !== pkMatchingIndexName+ )+ : aggregatedIndexes;+const dbIndexes = createIndexesFromMetadata({- aggregatedIndexes,+ aggregatedIndexes: filteredAggregatedIndexes,fields,});+ // Add the PK index if it exists+ if (pkIndex) {+ dbIndexes.push(pkIndex);+ }+// Determine if the current table is a view by checking against pre-computed setsconst viewKey = generateTableKey({schemaName: tableSchema,diff --git a/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-index/table-index.tsx b/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-index/table-index.tsxindex 5d006b22..dbf754f7 100644--- a/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-index/table-index.tsx+++ b/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-index/table-index.tsx@@ -1,5 +1,5 @@import React, { useCallback, useMemo } from 'react';-import { Ellipsis, Trash2 } from 'lucide-react';+import { Ellipsis, Trash2, KeyRound } from 'lucide-react';import { Button } from '@/components/button/button';import {databaseIndexTypes,@@ -106,29 +106,45 @@ export const TableIndex: React.FC<TableIndexProps> = ({'side_panel.tables_section.table.no_types_found')}keepOrder+ disabled={index.isPrimaryKey ?? false}/><div className="flex shrink-0 gap-1">- <Tooltip>- <TooltipTrigger asChild>- <span>- <TableIndexToggle- pressed={index.unique}- onPressedChange={(value) =>- updateIndex({- unique: !!value,- })- }- >- U- </TableIndexToggle>- </span>- </TooltipTrigger>- <TooltipContent>- {t(- 'side_panel.tables_section.table.index_actions.unique'- )}- </TooltipContent>- </Tooltip>+ {index.isPrimaryKey ? (+ <Tooltip>+ <TooltipTrigger asChild>+ <span>+ <TableIndexToggle pressed={true} disabled>+ <KeyRound className="h-3.5" />+ </TableIndexToggle>+ </span>+ </TooltipTrigger>+ <TooltipContent>+ {t('side_panel.tables_section.table.primary_key')}+ </TooltipContent>+ </Tooltip>+ ) : (+ <Tooltip>+ <TooltipTrigger asChild>+ <span>+ <TableIndexToggle+ pressed={index.unique}+ onPressedChange={(value) =>+ updateIndex({+ unique: !!value,+ })+ }+ >+ U+ </TableIndexToggle>+ </span>+ </TooltipTrigger>+ <TooltipContent>+ {t(+ 'side_panel.tables_section.table.index_actions.unique'+ )}+ </TooltipContent>+ </Tooltip>+ )}<Popover><PopoverTrigger asChild><Button@@ -164,52 +180,56 @@ export const TableIndex: React.FC<TableIndexProps> = ({}/></div>- <div className="mt-2 flex items-center justify-between">- <Label- htmlFor="width"- className="text-subtitle"- >- {t(- 'side_panel.tables_section.table.index_actions.unique'- )}- </Label>- <Checkbox- checked={index.unique}- onCheckedChange={(value) =>- updateIndex({- unique: !!value,- })- }- />- </div>- {indexTypeOptions.length > 0 ? (- <div className="mt-2 flex flex-col gap-2">- <Label- htmlFor="indexType"- className="text-subtitle"+ {!index.isPrimaryKey ? (+ <>+ <div className="mt-2 flex items-center justify-between">+ <Label+ htmlFor="width"+ className="text-subtitle"+ >+ {t(+ 'side_panel.tables_section.table.index_actions.unique'+ )}+ </Label>+ <Checkbox+ checked={index.unique}+ onCheckedChange={(value) =>+ updateIndex({+ unique: !!value,+ })+ }+ />+ </div>+ {indexTypeOptions.length > 0 ? (+ <div className="mt-2 flex flex-col gap-2">+ <Label+ htmlFor="indexType"+ className="text-subtitle"+ >+ {t(+ 'side_panel.tables_section.table.index_actions.index_type'+ )}+ </Label>+ <SelectBox+ options={indexTypeOptions}+ value={index.type || 'btree'}+ onChange={updateIndexType}+ />+ </div>+ ) : null}+ <Separator orientation="horizontal" />+ <Button+ variant="outline"+ className="flex gap-2 !text-red-700"+ onClick={removeIndex}>+ <Trash2 className="size-3.5 text-red-700" />{t(- 'side_panel.tables_section.table.index_actions.index_type'+ 'side_panel.tables_section.table.index_actions.delete_index')}- </Label>- <SelectBox- options={indexTypeOptions}- value={index.type || 'btree'}- onChange={updateIndexType}- />- </div>+ </Button>+ </>) : null}- <Separator orientation="horizontal" />- <Button- variant="outline"- className="flex gap-2 !text-red-700"- onClick={removeIndex}- >- <Trash2 className="size-3.5 text-red-700" />- {t(- 'side_panel.tables_section.table.index_actions.delete_index'- )}- </Button></div></PopoverContent></Popover>diff --git a/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-list-item-content.tsx b/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-list-item-content.tsxindex 406f8d72..309562ee 100644--- a/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-list-item-content.tsx+++ b/src/pages/editor-page/side-panel/tables-section/table-list/table-list-item/table-list-item-content/table-list-item-content.tsx@@ -224,19 +224,27 @@ export const TableListItemContent: React.FC<TableListItemContentProps> = ({</div></AccordionTrigger><AccordionContent className="pb-0 pt-1">- {table.indexes.map((index) => (- <TableIndex- key={index.id}- index={index}- removeIndex={() =>- removeIndex(table.id, index.id)- }- updateIndex={(attrs: Partial<DBIndex>) =>- updateIndex(table.id, index.id, attrs)- }- fields={table.fields}- />- ))}+ {[...table.indexes]+ .sort((a, b) => {+ // Sort PK indexes first+ if (a.isPrimaryKey && !b.isPrimaryKey)+ return -1;+ if (!a.isPrimaryKey && b.isPrimaryKey) return 1;+ return 0;+ })+ .map((index) => (+ <TableIndex+ key={index.id}+ index={index}+ removeIndex={() =>+ removeIndex(table.id, index.id)+ }+ updateIndex={(attrs: Partial<DBIndex>) =>+ updateIndex(table.id, index.id, attrs)+ }+ fields={table.fields}+ />+ ))}<div className="flex justify-start p-1"><Buttonvariant="ghost"