Skip to content

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

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.ts
index 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 diagram
function 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.ts
index 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.ts
index 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.ts
index 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;
+};