Database diagrams editor that allows you to visualize and design your DB with a single query.
TypeScript databasedbdb-migrationeditorerdmariadbmssqlmysqlpostgresqlreactreact-flowschema-migrationssqlsqlitetypescriptvisualizationxyflow
fix: add index change diff (#1026)
Guy Ben-Aharona6d6482346cd
diff --git a/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts b/src/lib/domain/diff/diff-check/__tests__/diff-check.test.tsindex e5d0da2a..b04ae0b1 100644--- a/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts+++ b/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts@@ -12,6 +12,7 @@ import type { TableDiffChanged } from '../../table-diff';import type { FieldDiffChanged } from '../../field-diff';import type { AreaDiffChanged } from '../../area-diff';import type { NoteDiffChanged } from '../../note-diff';+import type { IndexDiffChanged } from '../../index-diff';// Helper function to create a mock diagramfunction createMockDiagram(overrides?: Partial<Diagram>): Diagram {@@ -97,6 +98,18 @@ function createMockNote(overrides?: Partial<Note>): Note {} as Note;}+// Helper function to create a mock index+function createMockIndex(overrides?: Partial<DBIndex>): DBIndex {+ return {+ id: 'index-1',+ name: 'idx_users_email',+ unique: false,+ fieldIds: ['field-1'],+ createdAt: Date.now(),+ ...overrides,+ } as DBIndex;+}+describe('generateDiff', () => {describe('Basic Table Diffing', () => {it('should detect added tables', () => {@@ -320,6 +333,412 @@ describe('generateDiff', () => {});});+ describe('Index Diffing', () => {+ it('should detect added indexes', () => {+ const oldDiagram = createMockDiagram({+ tables: [createMockTable({ indexes: [] })],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex()],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('index-index-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('added');+ expect(result.changedIndexes.has('index-1')).toBe(true);+ });++ it('should detect removed indexes', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex()],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [createMockTable({ indexes: [] })],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('index-index-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('removed');+ expect(result.changedIndexes.has('index-1')).toBe(true);+ });++ it('should detect index name changes', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex({ name: 'idx_old_name' })],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex({ name: 'idx_new_name' })],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('index-name-index-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ expect((diff as IndexDiffChanged)?.attribute).toBe('name');+ expect((diff as IndexDiffChanged)?.oldValue).toBe('idx_old_name');+ expect((diff as IndexDiffChanged)?.newValue).toBe('idx_new_name');+ expect(result.changedIndexes.has('index-1')).toBe(true);+ });++ it('should detect index unique changes', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex({ unique: false })],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex({ unique: true })],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('index-unique-index-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ expect((diff as IndexDiffChanged)?.attribute).toBe('unique');+ expect((diff as IndexDiffChanged)?.oldValue).toBe(false);+ expect((diff as IndexDiffChanged)?.newValue).toBe(true);+ });++ it('should detect index fieldIds changes', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex({ fieldIds: ['field-1'] })],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ fieldIds: ['field-1', 'field-2'],+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('index-fieldIds-index-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ expect((diff as IndexDiffChanged)?.attribute).toBe('fieldIds');+ expect((diff as IndexDiffChanged)?.oldValue).toEqual(['field-1']);+ expect((diff as IndexDiffChanged)?.newValue).toEqual([+ 'field-1',+ 'field-2',+ ]);+ });++ it('should detect index type changes', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex({ type: 'btree' })],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [createMockIndex({ type: 'hash' })],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('index-type-index-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ expect((diff as IndexDiffChanged)?.attribute).toBe('type');+ expect((diff as IndexDiffChanged)?.oldValue).toBe('btree');+ expect((diff as IndexDiffChanged)?.newValue).toBe('hash');+ });++ it('should detect multiple index attribute changes', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ name: 'idx_old',+ unique: false,+ type: 'btree',+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ name: 'idx_new',+ unique: true,+ type: 'hash',+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(3);+ expect(result.diffMap.has('index-name-index-1')).toBe(true);+ expect(result.diffMap.has('index-unique-index-1')).toBe(true);+ expect(result.diffMap.has('index-type-index-1')).toBe(true);+ });++ it('should only check specified index attributes', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ name: 'idx_old',+ unique: false,+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ name: 'idx_new',+ unique: true,+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ options: {+ attributes: {+ indexes: ['name'], // Only check name changes+ },+ },+ });++ expect(result.diffMap.size).toBe(1);+ expect(result.diffMap.has('index-name-index-1')).toBe(true);+ expect(result.diffMap.has('index-unique-index-1')).toBe(false);+ });++ it('should match indexes by name when IDs differ', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ id: 'index-old-id',+ name: 'idx_email',+ unique: false,+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ id: 'index-new-id',+ name: 'idx_email',+ unique: true,+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ // Should detect as change (matched by name), not add+remove+ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('index-unique-index-old-id');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ });++ it('should match indexes by fieldIds when IDs and names differ', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ id: 'index-old-id',+ name: 'idx_old_name',+ fieldIds: ['field-1', 'field-2'],+ unique: false,+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ id: 'index-new-id',+ name: 'idx_new_name',+ fieldIds: ['field-1', 'field-2'],+ unique: true,+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ // Should detect name and unique as changes (matched by fieldIds)+ expect(result.diffMap.size).toBe(2);+ expect(result.diffMap.has('index-name-index-old-id')).toBe(true);+ expect(result.diffMap.has('index-unique-index-old-id')).toBe(true);+ });++ it('should prioritize ID matching over name and fieldIds', () => {+ // Even if name and fieldIds match a different index,+ // ID matching takes priority+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ id: 'index-1',+ name: 'idx_email',+ fieldIds: ['field-1'],+ unique: false,+ }),+ createMockIndex({+ id: 'index-2',+ name: 'idx_other',+ fieldIds: ['field-2'],+ unique: false,+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ indexes: [+ createMockIndex({+ id: 'index-1',+ name: 'idx_renamed', // Name changed+ fieldIds: ['field-1'],+ unique: true, // Unique changed+ }),+ createMockIndex({+ id: 'index-2',+ name: 'idx_email', // Has old index-1's name+ fieldIds: ['field-2'],+ unique: false,+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ // index-1 should match by ID, detecting name and unique changes+ expect(result.diffMap.has('index-name-index-1')).toBe(true);+ expect(result.diffMap.has('index-unique-index-1')).toBe(true);++ // index-2 should match by ID, detecting only name change+ expect(result.diffMap.has('index-name-index-2')).toBe(true);++ // No added or removed indexes+ const added = Array.from(result.diffMap.values()).filter(+ (d) => d.type === 'added' && d.object === 'index'+ );+ const removed = Array.from(result.diffMap.values()).filter(+ (d) => d.type === 'removed' && d.object === 'index'+ );+ expect(added.length).toBe(0);+ expect(removed.length).toBe(0);+ });+ });+describe('Relationship Diffing', () => {it('should detect added relationships', () => {const oldDiagram = createMockDiagram({ relationships: [] });@@ -1125,6 +1544,513 @@ describe('generateDiff', () => {});});+ describe('Smart Comment Comparison', () => {+ describe('Table Comments', () => {+ it('should not detect change when comments differ only by newlines vs spaces', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments:+ '| Source: [DB].[schema].[table].[col] | Target: [DW].[reporting].[dim_items].[item_id] | Description: Primary key | Notes: none',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments:+ '| Source: [DB].[schema].[table].[col]\n| Target: [DW].[reporting].[dim_items].[item_id]\n| Description: Primary key\n| Notes: none',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ // Should not detect any changes+ expect(result.diffMap.size).toBe(0);+ expect(result.changedTables.size).toBe(0);+ });++ it('should not detect change when comments differ by multiple spaces', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments:+ 'Column description with extra spaces',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: 'Column description with extra spaces',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ });++ it('should not detect change when comments differ by tabs vs spaces', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: 'Key\tValue\tPairs',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: 'Key Value Pairs',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ });++ it('should not detect change when comments differ by leading/trailing whitespace', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: ' Table description ',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: 'Table description',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ });++ it('should detect change when comments have actual content differences', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: 'Old description',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: 'New description',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('table-comments-table-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ expect((diff as TableDiffChanged)?.attribute).toBe('comments');+ });++ it('should detect change when one comment is empty and other has content', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: '',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: 'New comment',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ });++ it('should not detect change when both comments are undefined', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: undefined,+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: undefined,+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ });++ it('should not detect change when one is undefined and other is whitespace-only', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: undefined,+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: ' ',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ });+ });++ describe('Field Comments', () => {+ it('should not detect change when field comments differ only by newlines vs spaces', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments:+ '| Type: FK | Ref: orders.id | Info: Order reference',+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments:+ '| Type: FK\n| Ref: orders.id\n| Info: Order reference',+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ expect(result.changedFields.size).toBe(0);+ });++ it('should not detect change when field comments differ by CRLF vs LF', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments: 'Line 1\r\nLine 2\r\nLine 3',+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments: 'Line 1\nLine 2\nLine 3',+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ });++ it('should detect change when field comments have actual content differences', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments: 'Primary key for users table',+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments: 'Unique identifier for customers',+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('field-comments-field-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ expect((diff as FieldDiffChanged)?.attribute).toBe('comments');+ });+ });++ describe('Note Content', () => {+ it('should not detect change when note content differs only by newlines vs spaces', () => {+ const oldDiagram = createMockDiagram({+ notes: [+ createMockNote({+ id: 'note-1',+ content:+ '# Title | Section 1 | Section 2 | Section 3',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ notes: [+ createMockNote({+ id: 'note-1',+ content:+ '# Title\n| Section 1\n| Section 2\n| Section 3',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ options: {+ includeNotes: true,+ },+ });++ expect(result.diffMap.size).toBe(0);+ expect(result.changedNotes.size).toBe(0);+ });++ it('should not detect change when note content differs by mixed whitespace', () => {+ const oldDiagram = createMockDiagram({+ notes: [+ createMockNote({+ id: 'note-1',+ content:+ 'Important\t\tnote\n\nwith mixed\r\n\r\nwhitespace',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ notes: [+ createMockNote({+ id: 'note-1',+ content: 'Important note with mixed whitespace',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ options: {+ includeNotes: true,+ },+ });++ expect(result.diffMap.size).toBe(0);+ });++ it('should detect change when note content has actual differences', () => {+ const oldDiagram = createMockDiagram({+ notes: [+ createMockNote({+ id: 'note-1',+ content: 'TODO: Implement feature X',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ notes: [+ createMockNote({+ id: 'note-1',+ content: 'DONE: Feature X implemented',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ options: {+ includeNotes: true,+ },+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('note-content-note-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ expect((diff as NoteDiffChanged)?.attribute).toBe('content');+ });+ });++ describe('Edge Cases', () => {+ it('should handle complex multi-line structured comments', () => {+ const structuredComment1 =+ '| Column: user_id | Type: INT | Nullable: NO | Default: AUTO_INCREMENT | FK: users.id | Description: Foreign key reference to users table';+ const structuredComment2 =+ '| Column: user_id\n| Type: INT\n| Nullable: NO\n| Default: AUTO_INCREMENT\n| FK: users.id\n| Description: Foreign key reference to users table';++ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments: structuredComment1,+ }),+ ],+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ fields: [+ createMockField({+ id: 'field-1',+ comments: structuredComment2,+ }),+ ],+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(0);+ });++ it('should preserve detection of actual word changes in multi-line comments', () => {+ const oldDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: '| Status: Active\n| Owner: Team A',+ }),+ ],+ });+ const newDiagram = createMockDiagram({+ tables: [+ createMockTable({+ id: 'table-1',+ comments: '| Status: Deprecated\n| Owner: Team B',+ }),+ ],+ });++ const result = generateDiff({+ diagram: oldDiagram,+ newDiagram,+ });++ expect(result.diffMap.size).toBe(1);+ const diff = result.diffMap.get('table-comments-table-1');+ expect(diff).toBeDefined();+ expect(diff?.type).toBe('changed');+ });+ });+ });+describe('Complex Scenarios', () => {it('should detect all dimensional changes for tables, areas, and notes', () => {const oldDiagram = createMockDiagram({diff --git a/src/lib/domain/diff/diff-check/diff-check.ts b/src/lib/domain/diff/diff-check/diff-check.tsindex 1b1d73f1..64e7c68d 100644--- a/src/lib/domain/diff/diff-check/diff-check.ts+++ b/src/lib/domain/diff/diff-check/diff-check.ts@@ -13,8 +13,9 @@ import type {import type { TableDiff, TableDiffAttribute } from '../table-diff';import type { AreaDiff, AreaDiffAttribute } from '../area-diff';import type { NoteDiff, NoteDiffAttribute } from '../note-diff';-import type { IndexDiff } from '../index-diff';+import type { IndexDiff, IndexDiffAttribute } from '../index-diff';import type { RelationshipDiff } from '../relationship-diff';+import { areBooleansEqual } from '@/lib/utils';export function getDiffMapKey({diffObject,@@ -113,12 +114,14 @@ export interface GenerateDiffOptions {attributes?: {tables?: TableDiffAttribute[];fields?: FieldDiffAttribute[];+ indexes?: IndexDiffAttribute[];areas?: AreaDiffAttribute[];notes?: NoteDiffAttribute[];};changedMaps?: {changedTablesAttributes?: TableDiffAttribute[];changedFieldsAttributes?: FieldDiffAttribute[];+ changedIndexesAttributes?: IndexDiffAttribute[];changedAreasAttributes?: AreaDiffAttribute[];changedNotesAttributes?: NoteDiffAttribute[];};@@ -155,6 +158,7 @@ export function generateDiff({diffMap: DiffMap;changedTables: Map<string, boolean>;changedFields: Map<string, boolean>;+ changedIndexes: Map<string, boolean>;changedAreas: Map<string, boolean>;changedNotes: Map<string, boolean>;} {@@ -175,6 +179,7 @@ export function generateDiff({const newDiffs = new Map<string, ChartDBDiff>();const changedTables = new Map<string, boolean>();const changedFields = new Map<string, boolean>();+ const changedIndexes = new Map<string, boolean>();const changedAreas = new Map<string, boolean>();const changedNotes = new Map<string, boolean>();@@ -209,11 +214,14 @@ export function generateDiff({diffMap: newDiffs,changedTables,changedFields,+ changedIndexes,options: mergedOptions,changedTablesAttributes:mergedOptions.changedMaps?.changedTablesAttributes,changedFieldsAttributes:mergedOptions.changedMaps?.changedFieldsAttributes,+ changedIndexesAttributes:+ mergedOptions.changedMaps?.changedIndexesAttributes,tableMatcher,fieldMatcher,indexMatcher,@@ -264,6 +272,7 @@ export function generateDiff({diffMap: newDiffs,changedTables,changedFields,+ changedIndexes,changedAreas,changedNotes,};@@ -510,9 +519,11 @@ function compareTableContents({diffMap,changedTables,changedFields,+ changedIndexes,options,changedTablesAttributes,changedFieldsAttributes,+ changedIndexesAttributes,tableMatcher,fieldMatcher,indexMatcher,@@ -522,9 +533,11 @@ function compareTableContents({diffMap: DiffMap;changedTables: Map<string, boolean>;changedFields: Map<string, boolean>;+ changedIndexes: Map<string, boolean>;options?: GenerateDiffOptions;changedTablesAttributes?: TableDiffAttribute[];changedFieldsAttributes?: FieldDiffAttribute[];+ changedIndexesAttributes?: IndexDiffAttribute[];tableMatcher: (table: DBTable, tables: DBTable[]) => DBTable | undefined;fieldMatcher: (field: DBField, fields: DBField[]) => DBField | undefined;indexMatcher: (index: DBIndex, indexes: DBIndex[]) => DBIndex | undefined;@@ -562,7 +575,10 @@ function compareTableContents({newIndexes: newTable.indexes,diffMap,changedTables,+ changedIndexes,+ attributes: options?.attributes?.indexes,changedTablesAttributes,+ changedIndexesAttributes,changeTypes: options?.changeTypes?.indexes,indexMatcher,});@@ -840,7 +856,10 @@ function compareIndexes({newIndexes,diffMap,changedTables,+ changedIndexes,+ attributes,changedTablesAttributes,+ changedIndexesAttributes,changeTypes,indexMatcher,}: {@@ -849,7 +868,10 @@ function compareIndexes({newIndexes: DBIndex[];diffMap: DiffMap;changedTables: Map<string, boolean>;+ changedIndexes: Map<string, boolean>;+ attributes?: IndexDiffAttribute[];changedTablesAttributes?: TableDiffAttribute[];+ changedIndexesAttributes?: IndexDiffAttribute[];changeTypes?: IndexDiff['type'][];indexMatcher: (index: DBIndex, indexes: DBIndex[]) => DBIndex | undefined;}) {@@ -859,7 +881,7 @@ function compareIndexes({}// If changeTypes is undefined, check all types- const typesToCheck = changeTypes ?? ['added', 'removed'];+ const typesToCheck = changeTypes ?? ['added', 'removed', 'changed'];// For structural changes (added/removed indexes), add to changedTables unless// changedTablesAttributes is explicitly set to empty array@@ -886,6 +908,7 @@ function compareIndexes({if (shouldAddToChangedTables) {changedTables.set(tableId, true);}+ changedIndexes.set(newIndex.id, true);}}}@@ -909,9 +932,139 @@ function compareIndexes({if (shouldAddToChangedTables) {changedTables.set(tableId, true);}+ changedIndexes.set(oldIndex.id, true);}}}++ // Check for index changes+ if (typesToCheck.includes('changed')) {+ for (const oldIndex of oldIndexes) {+ const newIndex = indexMatcher(oldIndex, newIndexes);+ if (!newIndex) continue;++ compareIndexProperties({+ tableId,+ oldIndex,+ newIndex,+ diffMap,+ changedTables,+ changedIndexes,+ attributes,+ changedTablesAttributes,+ changedIndexesAttributes,+ });+ }+ }+}++// Helper to compare fieldIds arrays+const areFieldIdsEqual = (+ oldFieldIds: string[],+ newFieldIds: string[]+): boolean => {+ if (oldFieldIds.length !== newFieldIds.length) {+ return false;+ }+ for (let i = 0; i < oldFieldIds.length; i++) {+ if (oldFieldIds[i] !== newFieldIds[i]) {+ return false;+ }+ }+ return true;+};++// Compare index properties+function compareIndexProperties({+ tableId,+ oldIndex,+ newIndex,+ diffMap,+ changedTables,+ changedIndexes,+ attributes,+ changedTablesAttributes,+ changedIndexesAttributes,+}: {+ tableId: string;+ oldIndex: DBIndex;+ newIndex: DBIndex;+ diffMap: DiffMap;+ changedTables: Map<string, boolean>;+ changedIndexes: Map<string, boolean>;+ attributes?: IndexDiffAttribute[];+ changedTablesAttributes?: TableDiffAttribute[];+ changedIndexesAttributes?: IndexDiffAttribute[];+}) {+ // If attributes are specified, only check those attributes+ const attributesToCheck: IndexDiffAttribute[] = attributes ?? [+ 'name',+ 'unique',+ 'fieldIds',+ 'type',+ ];++ const changedAttributes: IndexDiffAttribute[] = [];++ if (attributesToCheck.includes('name') && oldIndex.name !== newIndex.name) {+ changedAttributes.push('name');+ }++ if (+ attributesToCheck.includes('unique') &&+ oldIndex.unique !== newIndex.unique+ ) {+ changedAttributes.push('unique');+ }++ if (+ attributesToCheck.includes('fieldIds') &&+ !areFieldIdsEqual(oldIndex.fieldIds, newIndex.fieldIds)+ ) {+ changedAttributes.push('fieldIds');+ }++ if (attributesToCheck.includes('type') && oldIndex.type !== newIndex.type) {+ changedAttributes.push('type');+ }++ if (changedAttributes.length > 0) {+ // Track which attributes should trigger adding to changed maps+ const attributesThatTriggerChange = changedAttributes.filter((attr) =>+ shouldAddToChangedMap(attr, changedIndexesAttributes)+ );++ for (const attribute of changedAttributes) {+ diffMap.set(+ getDiffMapKey({+ diffObject: 'index',+ objectId: oldIndex.id,+ attribute,+ }),+ {+ object: 'index',+ type: 'changed',+ indexId: oldIndex.id,+ tableId,+ attribute,+ oldValue: oldIndex[attribute],+ newValue: newIndex[attribute],+ }+ );+ }++ // Only add to changed maps if at least one attribute should trigger a change+ if (attributesThatTriggerChange.length > 0) {+ // For changedTables, we need to check changedTablesAttributes+ if (changedTablesAttributes === undefined) {+ changedTables.set(tableId, true);+ } else if (changedTablesAttributes.length > 0) {+ changedTables.set(tableId, true);+ }++ changedIndexes.set(oldIndex.id, true);+ }+ }}// Compare relationships between diagrams@@ -1448,7 +1601,35 @@ const defaultIndexMatcher = (index: DBIndex,indexes: DBIndex[]): DBIndex | undefined => {- return indexes.find((i) => i.id === index.id);+ // Priority 1: Match by ID+ const byId = indexes.find((i) => i.id === index.id);+ if (byId) {+ return byId;+ }++ // Priority 2: Match by name (only if unique match)+ if (index.name) {+ const byName = indexes.filter(+ (i) =>+ i.name === index.name &&+ areBooleansEqual(i.isPrimaryKey, index.isPrimaryKey)+ );+ if (byName.length === 1) {+ return byName[0];+ }+ }++ // Priority 3: Match by fieldIds (only if unique match)+ const byFieldIds = indexes.filter(+ (i) =>+ areFieldIdsEqual(i.fieldIds, index.fieldIds) &&+ areBooleansEqual(i.isPrimaryKey, index.isPrimaryKey)+ );+ if (byFieldIds.length === 1) {+ return byFieldIds[0];+ }++ return undefined;};const defaultRelationshipMatcher = (diff --git a/src/lib/domain/diff/index-diff.ts b/src/lib/domain/diff/index-diff.tsindex 0bd42f5b..379e3ffa 100644--- a/src/lib/domain/diff/index-diff.ts+++ b/src/lib/domain/diff/index-diff.ts@@ -1,5 +1,14 @@import { z } from 'zod';-import type { DBIndex } from '../db-index';+import type { DBIndex, IndexType } from '../db-index';++export type IndexDiffAttribute = 'name' | 'unique' | 'fieldIds' | 'type';++export const indexDiffAttributeSchema: z.ZodType<IndexDiffAttribute> = z.union([+ z.literal('name'),+ z.literal('unique'),+ z.literal('fieldIds'),+ z.literal('type'),+]);export interface IndexDiffAdded<T = DBIndex> {object: 'index';@@ -33,7 +42,34 @@ export const indexDiffRemovedSchema: z.ZodType<IndexDiffRemoved> = z.object({tableId: z.string(),});-export type IndexDiff<T = DBIndex> = IndexDiffAdded<T> | IndexDiffRemoved;+export interface IndexDiffChanged {+ object: 'index';+ type: 'changed';+ indexId: string;+ tableId: string;+ attribute: IndexDiffAttribute;+ oldValue?: string | boolean | string[] | IndexType | null;+ newValue?: string | boolean | string[] | IndexType | null;+}++export const indexDiffChangedSchema: z.ZodType<IndexDiffChanged> = z.object({+ object: z.literal('index'),+ type: z.literal('changed'),+ indexId: z.string(),+ tableId: z.string(),+ attribute: indexDiffAttributeSchema,+ oldValue: z+ .union([z.string(), z.boolean(), z.array(z.string()), z.null()])+ .optional(),+ newValue: z+ .union([z.string(), z.boolean(), z.array(z.string()), z.null()])+ .optional(),+});++export type IndexDiff<T = DBIndex> =+ | IndexDiffAdded<T>+ | IndexDiffRemoved+ | IndexDiffChanged;export const createIndexDiffSchema = <T = DBIndex>(indexSchema: z.ZodType<T>@@ -41,5 +77,6 @@ export const createIndexDiffSchema = <T = DBIndex>(return z.union([createIndexDiffAddedSchema(indexSchema),indexDiffRemovedSchema,+ indexDiffChangedSchema,]) as z.ZodType<IndexDiff<T>>;};diff --git a/src/lib/utils/utils.ts b/src/lib/utils/utils.tsindex d5701290..1c3b13ba 100644--- a/src/lib/utils/utils.ts+++ b/src/lib/utils/utils.ts@@ -127,3 +127,12 @@ export function mergeRefs<T>(export const isStringEmpty = (str: string | undefined | null): boolean => {return !str || str.trim().length === 0;};++export const areBooleansEqual = (+ a: boolean | undefined | null,+ b: boolean | undefined | null+): boolean => {+ const boolA = a ?? false;+ const boolB = b ?? false;+ return boolA === boolB;+};