Database diagrams editor that allows you to visualize and design your DB with a single query.
TypeScript databasedbdb-migrationeditorerdmariadbmssqlmysqlpostgresqlreactreact-flowschema-migrationssqlsqlitetypescriptvisualizationxyflow
import { describe, it, expect } from 'vitest';
import { generateDiff } from '../diff-check';
import type { Diagram } from '@/lib/domain/diagram';
import type { DBTable } from '@/lib/domain/db-table';
import type { DBField } from '@/lib/domain/db-field';
import type { DBIndex } from '@/lib/domain/db-index';
import type { DBRelationship } from '@/lib/domain/db-relationship';
import type { Area } from '@/lib/domain/area';
import type { Note } from '@/lib/domain/note';
import { DatabaseType } from '@/lib/domain/database-type';
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';
import type { RelationshipDiffChanged } from '../../relationship-diff';
// Helper function to create a mock diagram
function createMockDiagram(overrides?: Partial<Diagram>): Diagram {
return {
id: 'diagram-1',
name: 'Test Diagram',
databaseType: DatabaseType.POSTGRESQL,
tables: [],
relationships: [],
areas: [],
createdAt: new Date(),
updatedAt: new Date(),
...overrides,
};
}
// Helper function to create a mock table
function createMockTable(overrides?: Partial<DBTable>): DBTable {
return {
id: 'table-1',
name: 'users',
fields: [],
indexes: [],
x: 0,
y: 0,
...overrides,
} as DBTable;
}
// Helper function to create a mock field
function createMockField(overrides?: Partial<DBField>): DBField {
return {
id: 'field-1',
name: 'id',
type: { id: 'integer', name: 'integer' },
primaryKey: false,
nullable: true,
unique: false,
...overrides,
} as DBField;
}
// Helper function to create a mock relationship
function createMockRelationship(
overrides?: Partial<DBRelationship>
): DBRelationship {
return {
id: 'rel-1',
name: 'fk_default',
sourceTableId: 'table-1',
targetTableId: 'table-2',
sourceFieldId: 'field-1',
targetFieldId: 'field-2',
sourceCardinality: 'one',
targetCardinality: 'many',
createdAt: Date.now(),
...overrides,
} as DBRelationship;
}
// Helper function to create a mock area
function createMockArea(overrides?: Partial<Area>): Area {
return {
id: 'area-1',
name: 'Main Area',
x: 0,
y: 0,
width: 100,
height: 100,
color: 'blue',
...overrides,
} as Area;
}
// Helper function to create a mock note
function createMockNote(overrides?: Partial<Note>): Note {
return {
id: 'note-1',
content: 'Test note content',
x: 0,
y: 0,
width: 200,
height: 150,
color: '#3b82f6',
...overrides,
} 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', () => {
const oldDiagram = createMockDiagram({ tables: [] });
const newDiagram = createMockDiagram({
tables: [createMockTable()],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('table-table-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('added');
expect(result.changedTables.has('table-1')).toBe(true);
});
it('should detect removed tables', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable()],
});
const newDiagram = createMockDiagram({ tables: [] });
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('table-table-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('removed');
expect(result.changedTables.has('table-1')).toBe(true);
});
it('should detect table name changes', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ name: 'users' })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ name: 'customers' })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('table-name-table-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as TableDiffChanged)?.attribute).toBe('name');
});
it('should detect table position changes', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ x: 0, y: 0 })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ x: 100, y: 200 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
attributes: {
tables: ['name', 'comments', 'color', 'x', 'y'],
},
},
});
expect(result.diffMap.size).toBe(2);
expect(result.diffMap.has('table-x-table-1')).toBe(true);
expect(result.diffMap.has('table-y-table-1')).toBe(true);
});
it('should detect table width changes', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ width: 150 })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ width: 250 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
attributes: {
tables: ['width'],
},
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('table-width-table-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as TableDiffChanged)?.attribute).toBe('width');
expect((diff as TableDiffChanged)?.oldValue).toBe(150);
expect((diff as TableDiffChanged)?.newValue).toBe(250);
});
it('should detect multiple table dimension changes', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ x: 0, y: 0, width: 100 })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ x: 50, y: 75, width: 200 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
attributes: {
tables: ['x', 'y', 'width'],
},
},
});
expect(result.diffMap.size).toBe(3);
expect(result.diffMap.has('table-x-table-1')).toBe(true);
expect(result.diffMap.has('table-y-table-1')).toBe(true);
expect(result.diffMap.has('table-width-table-1')).toBe(true);
const widthDiff = result.diffMap.get('table-width-table-1');
expect(widthDiff?.type).toBe('changed');
expect((widthDiff as TableDiffChanged)?.oldValue).toBe(100);
expect((widthDiff as TableDiffChanged)?.newValue).toBe(200);
});
});
describe('Field Diffing', () => {
it('should detect added fields', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ fields: [] })],
});
const newDiagram = createMockDiagram({
tables: [
createMockTable({
fields: [createMockField()],
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('field-field-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('added');
expect(result.changedFields.has('field-1')).toBe(true);
});
it('should detect removed fields', () => {
const oldDiagram = createMockDiagram({
tables: [
createMockTable({
fields: [createMockField()],
}),
],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ fields: [] })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('field-field-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('removed');
});
it('should detect field type changes', () => {
const oldDiagram = createMockDiagram({
tables: [
createMockTable({
fields: [
createMockField({
type: { id: 'integer', name: 'integer' },
}),
],
}),
],
});
const newDiagram = createMockDiagram({
tables: [
createMockTable({
fields: [
createMockField({
type: { id: 'varchar', name: 'varchar' },
}),
],
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('field-type-field-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as FieldDiffChanged)?.attribute).toBe('type');
});
});
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 not detect index type change when both are undefined/null (use database default)', () => {
const oldDiagram = createMockDiagram({
databaseType: DatabaseType.POSTGRESQL,
tables: [
createMockTable({
indexes: [createMockIndex({ type: undefined })],
}),
],
});
const newDiagram = createMockDiagram({
databaseType: DatabaseType.POSTGRESQL,
tables: [
createMockTable({
indexes: [createMockIndex({ type: null })],
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.has('index-type-index-1')).toBe(false);
});
it('should not detect index type change when one is undefined and the other is the database default', () => {
const oldDiagram = createMockDiagram({
databaseType: DatabaseType.POSTGRESQL,
tables: [
createMockTable({
indexes: [createMockIndex({ type: undefined })],
}),
],
});
const newDiagram = createMockDiagram({
databaseType: DatabaseType.POSTGRESQL,
tables: [
createMockTable({
indexes: [createMockIndex({ type: 'btree' })],
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
// btree is the default for PostgreSQL, so undefined vs 'btree' should be equal
expect(result.diffMap.has('index-type-index-1')).toBe(false);
});
it('should detect index type change when one is undefined and the other differs from database default', () => {
const oldDiagram = createMockDiagram({
databaseType: DatabaseType.POSTGRESQL,
tables: [
createMockTable({
indexes: [createMockIndex({ type: undefined })],
}),
],
});
const newDiagram = createMockDiagram({
databaseType: DatabaseType.POSTGRESQL,
tables: [
createMockTable({
indexes: [createMockIndex({ type: 'hash' })],
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
// undefined defaults to 'btree' for PostgreSQL, so undefined vs 'hash' should be different
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');
});
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: [] });
const newDiagram = createMockDiagram({
relationships: [createMockRelationship()],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('added');
expect(result.changedRelationships.has('rel-1')).toBe(true);
});
it('should detect removed relationships', () => {
const oldDiagram = createMockDiagram({
relationships: [createMockRelationship()],
});
const newDiagram = createMockDiagram({ relationships: [] });
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('removed');
expect(result.changedRelationships.has('rel-1')).toBe(true);
});
it('should detect relationship name changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ name: 'fk_old_name' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ name: 'fk_new_name' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-name-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe('name');
expect((diff as RelationshipDiffChanged)?.oldValue).toBe(
'fk_old_name'
);
expect((diff as RelationshipDiffChanged)?.newValue).toBe(
'fk_new_name'
);
expect(result.changedRelationships.has('rel-1')).toBe(true);
});
it('should detect relationship sourceCardinality changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceCardinality: 'one' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceCardinality: 'many' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get(
'relationship-sourceCardinality-rel-1'
);
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'sourceCardinality'
);
expect((diff as RelationshipDiffChanged)?.oldValue).toBe('one');
expect((diff as RelationshipDiffChanged)?.newValue).toBe('many');
});
it('should detect relationship targetCardinality changes', () => {
// Use (many, many) -> (many, one) to test targetCardinality change detection
// This is NOT equivalent since source is 'many' in both cases
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'many',
targetCardinality: 'many',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'many',
targetCardinality: 'one',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get(
'relationship-targetCardinality-rel-1'
);
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'targetCardinality'
);
expect((diff as RelationshipDiffChanged)?.oldValue).toBe('many');
expect((diff as RelationshipDiffChanged)?.newValue).toBe('one');
});
it('should NOT detect cardinality changes between (one,one) and (one,many) as they produce same DDL', () => {
// (one,one) -> (one,many): source stays 'one', equivalent from DDL perspective
const oldDiagram1 = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'one',
targetCardinality: 'one',
}),
],
});
const newDiagram1 = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'one',
targetCardinality: 'many',
}),
],
});
const result1 = generateDiff({
diagram: oldDiagram1,
newDiagram: newDiagram1,
});
// Should NOT detect any cardinality changes
expect(
result1.diffMap.has('relationship-sourceCardinality-rel-1')
).toBe(false);
expect(
result1.diffMap.has('relationship-targetCardinality-rel-1')
).toBe(false);
expect(result1.diffMap.size).toBe(0);
// (one,many) -> (one,one): reverse direction, also equivalent
const oldDiagram2 = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'one',
targetCardinality: 'many',
}),
],
});
const newDiagram2 = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'one',
targetCardinality: 'one',
}),
],
});
const result2 = generateDiff({
diagram: oldDiagram2,
newDiagram: newDiagram2,
});
expect(
result2.diffMap.has('relationship-sourceCardinality-rel-1')
).toBe(false);
expect(
result2.diffMap.has('relationship-targetCardinality-rel-1')
).toBe(false);
expect(result2.diffMap.size).toBe(0);
});
it('should still detect cardinality changes that produce different DDL', () => {
// (one,one) -> (many,one): source changes from 'one' to 'many', real change
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'one',
targetCardinality: 'one',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
sourceCardinality: 'many',
targetCardinality: 'one',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
// Should detect the sourceCardinality change
expect(
result.diffMap.has('relationship-sourceCardinality-rel-1')
).toBe(true);
expect(result.diffMap.size).toBe(1);
});
it('should detect multiple relationship attribute changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_old',
sourceCardinality: 'one',
targetCardinality: 'many',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_new',
sourceCardinality: 'many',
targetCardinality: 'one',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(3);
expect(result.diffMap.has('relationship-name-rel-1')).toBe(true);
expect(
result.diffMap.has('relationship-sourceCardinality-rel-1')
).toBe(true);
expect(
result.diffMap.has('relationship-targetCardinality-rel-1')
).toBe(true);
});
it('should only check specified relationship attributes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_old',
sourceCardinality: 'one',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_new',
sourceCardinality: 'many',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
attributes: {
relationships: ['name'], // Only check name changes
},
},
});
expect(result.diffMap.size).toBe(1);
expect(result.diffMap.has('relationship-name-rel-1')).toBe(true);
expect(
result.diffMap.has('relationship-sourceCardinality-rel-1')
).toBe(false);
});
it('should only check specified relationship change types', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ id: 'rel-1', name: 'fk_old' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
// Use different sourceFieldId to ensure it's a truly different relationship
createMockRelationship({
id: 'rel-2',
name: 'fk_new',
sourceFieldId: 'field-3',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
changeTypes: {
relationships: ['added'], // Only check for added relationships
},
},
});
// Should only detect added relationship (rel-2)
const addedRelationships = Array.from(
result.diffMap.values()
).filter(
(diff) =>
diff.type === 'added' && diff.object === 'relationship'
);
expect(addedRelationships.length).toBe(1);
// Should not detect removed relationship (rel-1)
const removedRelationships = Array.from(
result.diffMap.values()
).filter(
(diff) =>
diff.type === 'removed' && diff.object === 'relationship'
);
expect(removedRelationships.length).toBe(0);
});
it('should use custom relationship matcher', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
id: 'rel-1',
name: 'fk_users_orders',
sourceCardinality: 'one',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
id: 'rel-2',
name: 'fk_users_orders',
sourceCardinality: 'many',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
matchers: {
relationship: (rel, rels) =>
rels.find((r) => r.name === rel.name),
},
},
});
// With name-based matching, rel-1 should match rel-2 by name
// and detect the sourceCardinality change
const cardinalityChange = result.diffMap.get(
'relationship-sourceCardinality-rel-1'
);
expect(cardinalityChange).toBeDefined();
expect(cardinalityChange?.type).toBe('changed');
expect(
(cardinalityChange as RelationshipDiffChanged)?.attribute
).toBe('sourceCardinality');
expect(
(cardinalityChange as RelationshipDiffChanged)?.oldValue
).toBe('one');
expect(
(cardinalityChange as RelationshipDiffChanged)?.newValue
).toBe('many');
});
it('should not detect changes when relationships are unchanged', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_users_orders',
sourceCardinality: 'one',
targetCardinality: 'many',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_users_orders',
sourceCardinality: 'one',
targetCardinality: 'many',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(0);
expect(result.changedRelationships.size).toBe(0);
});
it('should detect relationship sourceSchema changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceSchema: 'public' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceSchema: 'private' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-sourceSchema-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'sourceSchema'
);
expect((diff as RelationshipDiffChanged)?.oldValue).toBe('public');
expect((diff as RelationshipDiffChanged)?.newValue).toBe('private');
});
it('should detect relationship targetSchema changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ targetSchema: 'schema_a' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ targetSchema: 'schema_b' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-targetSchema-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'targetSchema'
);
});
it('should detect relationship sourceTableId changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceTableId: 'table-1' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceTableId: 'table-3' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-sourceTableId-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'sourceTableId'
);
expect((diff as RelationshipDiffChanged)?.oldValue).toBe('table-1');
expect((diff as RelationshipDiffChanged)?.newValue).toBe('table-3');
});
it('should detect relationship targetTableId changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ targetTableId: 'table-2' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ targetTableId: 'table-4' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-targetTableId-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'targetTableId'
);
});
it('should detect relationship sourceFieldId changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceFieldId: 'field-1' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ sourceFieldId: 'field-5' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-sourceFieldId-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'sourceFieldId'
);
expect((diff as RelationshipDiffChanged)?.oldValue).toBe('field-1');
expect((diff as RelationshipDiffChanged)?.newValue).toBe('field-5');
});
it('should detect relationship targetFieldId changes', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({ targetFieldId: 'field-2' }),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({ targetFieldId: 'field-6' }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('relationship-targetFieldId-rel-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as RelationshipDiffChanged)?.attribute).toBe(
'targetFieldId'
);
});
it('should detect all relationship attribute changes simultaneously', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_old',
sourceSchema: 'public',
sourceTableId: 'table-1',
targetSchema: 'public',
targetTableId: 'table-2',
sourceFieldId: 'field-1',
targetFieldId: 'field-2',
sourceCardinality: 'one',
targetCardinality: 'many',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_new',
sourceSchema: 'private',
sourceTableId: 'table-3',
targetSchema: 'private',
targetTableId: 'table-4',
sourceFieldId: 'field-5',
targetFieldId: 'field-6',
sourceCardinality: 'many',
targetCardinality: 'one',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
expect(result.diffMap.size).toBe(9);
expect(result.diffMap.has('relationship-name-rel-1')).toBe(true);
expect(result.diffMap.has('relationship-sourceSchema-rel-1')).toBe(
true
);
expect(result.diffMap.has('relationship-sourceTableId-rel-1')).toBe(
true
);
expect(result.diffMap.has('relationship-targetSchema-rel-1')).toBe(
true
);
expect(result.diffMap.has('relationship-targetTableId-rel-1')).toBe(
true
);
expect(result.diffMap.has('relationship-sourceFieldId-rel-1')).toBe(
true
);
expect(result.diffMap.has('relationship-targetFieldId-rel-1')).toBe(
true
);
expect(
result.diffMap.has('relationship-sourceCardinality-rel-1')
).toBe(true);
expect(
result.diffMap.has('relationship-targetCardinality-rel-1')
).toBe(true);
});
it('should filter relationship attributes correctly', () => {
const oldDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_old',
sourceSchema: 'public',
sourceTableId: 'table-1',
sourceCardinality: 'one',
}),
],
});
const newDiagram = createMockDiagram({
relationships: [
createMockRelationship({
name: 'fk_new',
sourceSchema: 'private',
sourceTableId: 'table-3',
sourceCardinality: 'many',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
attributes: {
relationships: ['name', 'sourceCardinality'], // Only check these
},
},
});
expect(result.diffMap.size).toBe(2);
expect(result.diffMap.has('relationship-name-rel-1')).toBe(true);
expect(
result.diffMap.has('relationship-sourceCardinality-rel-1')
).toBe(true);
// Should not detect sourceSchema or sourceTableId changes
expect(result.diffMap.has('relationship-sourceSchema-rel-1')).toBe(
false
);
expect(result.diffMap.has('relationship-sourceTableId-rel-1')).toBe(
false
);
});
});
describe('Area Diffing', () => {
it('should detect added areas when includeAreas is true', () => {
const oldDiagram = createMockDiagram({ areas: [] });
const newDiagram = createMockDiagram({
areas: [createMockArea()],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeAreas: true,
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('area-area-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('added');
expect(result.changedAreas.has('area-1')).toBe(true);
});
it('should not detect area changes when includeAreas is false', () => {
const oldDiagram = createMockDiagram({ areas: [] });
const newDiagram = createMockDiagram({
areas: [createMockArea()],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeAreas: false,
},
});
expect(result.diffMap.size).toBe(0);
});
it('should detect area width changes', () => {
const oldDiagram = createMockDiagram({
areas: [createMockArea({ width: 100 })],
});
const newDiagram = createMockDiagram({
areas: [createMockArea({ width: 200 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeAreas: true,
attributes: {
areas: ['width'],
},
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('area-width-area-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as AreaDiffChanged)?.attribute).toBe('width');
expect((diff as AreaDiffChanged)?.oldValue).toBe(100);
expect((diff as AreaDiffChanged)?.newValue).toBe(200);
});
it('should detect area height changes', () => {
const oldDiagram = createMockDiagram({
areas: [createMockArea({ height: 100 })],
});
const newDiagram = createMockDiagram({
areas: [createMockArea({ height: 300 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeAreas: true,
attributes: {
areas: ['height'],
},
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('area-height-area-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as AreaDiffChanged)?.attribute).toBe('height');
expect((diff as AreaDiffChanged)?.oldValue).toBe(100);
expect((diff as AreaDiffChanged)?.newValue).toBe(300);
});
it('should detect multiple area dimension changes', () => {
const oldDiagram = createMockDiagram({
areas: [
createMockArea({ x: 0, y: 0, width: 100, height: 100 }),
],
});
const newDiagram = createMockDiagram({
areas: [
createMockArea({ x: 50, y: 50, width: 200, height: 300 }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeAreas: true,
attributes: {
areas: ['x', 'y', 'width', 'height'],
},
},
});
expect(result.diffMap.size).toBe(4);
expect(result.diffMap.has('area-x-area-1')).toBe(true);
expect(result.diffMap.has('area-y-area-1')).toBe(true);
expect(result.diffMap.has('area-width-area-1')).toBe(true);
expect(result.diffMap.has('area-height-area-1')).toBe(true);
});
});
describe('Note Diffing', () => {
it('should detect added notes when includeNotes is true', () => {
const oldDiagram = createMockDiagram({ notes: [] });
const newDiagram = createMockDiagram({
notes: [createMockNote()],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('note-note-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('added');
expect(result.changedNotes.has('note-1')).toBe(true);
});
it('should not detect note changes when includeNotes is false', () => {
const oldDiagram = createMockDiagram({ notes: [] });
const newDiagram = createMockDiagram({
notes: [createMockNote()],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: false,
},
});
expect(result.diffMap.size).toBe(0);
expect(result.changedNotes.size).toBe(0);
});
it('should detect removed notes', () => {
const oldDiagram = createMockDiagram({
notes: [createMockNote()],
});
const newDiagram = createMockDiagram({ notes: [] });
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('note-note-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('removed');
expect(result.changedNotes.has('note-1')).toBe(true);
});
it('should detect note content changes', () => {
const oldDiagram = createMockDiagram({
notes: [createMockNote({ content: 'Old content' })],
});
const newDiagram = createMockDiagram({
notes: [createMockNote({ content: 'New content' })],
});
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');
expect((diff as NoteDiffChanged)?.oldValue).toBe('Old content');
expect((diff as NoteDiffChanged)?.newValue).toBe('New content');
});
it('should detect note color changes', () => {
const oldDiagram = createMockDiagram({
notes: [createMockNote({ color: '#3b82f6' })],
});
const newDiagram = createMockDiagram({
notes: [createMockNote({ color: '#ef4444' })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('note-color-note-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as NoteDiffChanged)?.attribute).toBe('color');
expect((diff as NoteDiffChanged)?.oldValue).toBe('#3b82f6');
expect((diff as NoteDiffChanged)?.newValue).toBe('#ef4444');
});
it('should detect note position changes', () => {
const oldDiagram = createMockDiagram({
notes: [createMockNote({ x: 0, y: 0 })],
});
const newDiagram = createMockDiagram({
notes: [createMockNote({ x: 100, y: 200 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
attributes: {
notes: ['content', 'color', 'x', 'y'],
},
},
});
expect(result.diffMap.size).toBe(2);
expect(result.diffMap.has('note-x-note-1')).toBe(true);
expect(result.diffMap.has('note-y-note-1')).toBe(true);
const xDiff = result.diffMap.get('note-x-note-1');
expect((xDiff as NoteDiffChanged)?.oldValue).toBe(0);
expect((xDiff as NoteDiffChanged)?.newValue).toBe(100);
});
it('should detect note width changes', () => {
const oldDiagram = createMockDiagram({
notes: [createMockNote({ width: 200 })],
});
const newDiagram = createMockDiagram({
notes: [createMockNote({ width: 300 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
attributes: {
notes: ['width'],
},
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('note-width-note-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as NoteDiffChanged)?.attribute).toBe('width');
expect((diff as NoteDiffChanged)?.oldValue).toBe(200);
expect((diff as NoteDiffChanged)?.newValue).toBe(300);
});
it('should detect note height changes', () => {
const oldDiagram = createMockDiagram({
notes: [createMockNote({ height: 150 })],
});
const newDiagram = createMockDiagram({
notes: [createMockNote({ height: 250 })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
attributes: {
notes: ['height'],
},
},
});
expect(result.diffMap.size).toBe(1);
const diff = result.diffMap.get('note-height-note-1');
expect(diff).toBeDefined();
expect(diff?.type).toBe('changed');
expect((diff as NoteDiffChanged)?.attribute).toBe('height');
expect((diff as NoteDiffChanged)?.oldValue).toBe(150);
expect((diff as NoteDiffChanged)?.newValue).toBe(250);
});
it('should detect multiple note dimension changes', () => {
const oldDiagram = createMockDiagram({
notes: [
createMockNote({ x: 0, y: 0, width: 200, height: 150 }),
],
});
const newDiagram = createMockDiagram({
notes: [
createMockNote({ x: 50, y: 75, width: 300, height: 250 }),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
attributes: {
notes: ['x', 'y', 'width', 'height'],
},
},
});
expect(result.diffMap.size).toBe(4);
expect(result.diffMap.has('note-x-note-1')).toBe(true);
expect(result.diffMap.has('note-y-note-1')).toBe(true);
expect(result.diffMap.has('note-width-note-1')).toBe(true);
expect(result.diffMap.has('note-height-note-1')).toBe(true);
const widthDiff = result.diffMap.get('note-width-note-1');
expect((widthDiff as NoteDiffChanged)?.oldValue).toBe(200);
expect((widthDiff as NoteDiffChanged)?.newValue).toBe(300);
const heightDiff = result.diffMap.get('note-height-note-1');
expect((heightDiff as NoteDiffChanged)?.oldValue).toBe(150);
expect((heightDiff as NoteDiffChanged)?.newValue).toBe(250);
});
it('should detect multiple notes with different changes', () => {
const oldDiagram = createMockDiagram({
notes: [
createMockNote({ id: 'note-1', content: 'Note 1' }),
createMockNote({ id: 'note-2', content: 'Note 2' }),
createMockNote({ id: 'note-3', content: 'Note 3' }),
],
});
const newDiagram = createMockDiagram({
notes: [
createMockNote({
id: 'note-1',
content: 'Note 1 Updated',
}), // Changed
createMockNote({ id: 'note-2', content: 'Note 2' }), // Unchanged
// note-3 removed
createMockNote({ id: 'note-4', content: 'Note 4' }), // Added
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
},
});
// Should detect: 1 content change, 1 removal, 1 addition
expect(result.diffMap.has('note-content-note-1')).toBe(true); // Changed
expect(result.diffMap.has('note-note-3')).toBe(true); // Removed
expect(result.diffMap.has('note-note-4')).toBe(true); // Added
expect(result.changedNotes.has('note-1')).toBe(true);
expect(result.changedNotes.has('note-3')).toBe(true);
expect(result.changedNotes.has('note-4')).toBe(true);
});
it('should use custom note matcher', () => {
const oldDiagram = createMockDiagram({
notes: [
createMockNote({
id: 'note-1',
content: 'Unique content',
color: '#3b82f6',
}),
],
});
const newDiagram = createMockDiagram({
notes: [
createMockNote({
id: 'note-2',
content: 'Unique content',
color: '#ef4444',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
matchers: {
note: (note, notes) =>
notes.find((n) => n.content === note.content),
},
},
});
// With content-based matching, note-1 should match note-2 by content
// and detect the color change
const colorChange = result.diffMap.get('note-color-note-1');
expect(colorChange).toBeDefined();
expect(colorChange?.type).toBe('changed');
expect((colorChange as NoteDiffChanged)?.attribute).toBe('color');
expect((colorChange as NoteDiffChanged)?.oldValue).toBe('#3b82f6');
expect((colorChange as NoteDiffChanged)?.newValue).toBe('#ef4444');
});
it('should only check specified note change types', () => {
const oldDiagram = createMockDiagram({
notes: [createMockNote({ id: 'note-1', content: 'Note 1' })],
});
const newDiagram = createMockDiagram({
notes: [createMockNote({ id: 'note-2', content: 'Note 2' })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
changeTypes: {
notes: ['added'], // Only check for added notes
},
},
});
// Should only detect added note (note-2)
const addedNotes = Array.from(result.diffMap.values()).filter(
(diff) => diff.type === 'added' && diff.object === 'note'
);
expect(addedNotes.length).toBe(1);
// Should not detect removed note (note-1)
const removedNotes = Array.from(result.diffMap.values()).filter(
(diff) => diff.type === 'removed' && diff.object === 'note'
);
expect(removedNotes.length).toBe(0);
});
it('should only check specified note attributes', () => {
const oldDiagram = createMockDiagram({
notes: [
createMockNote({
id: 'note-1',
content: 'Old content',
color: '#3b82f6',
x: 0,
y: 0,
}),
],
});
const newDiagram = createMockDiagram({
notes: [
createMockNote({
id: 'note-1',
content: 'New content',
color: '#ef4444',
x: 100,
y: 200,
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeNotes: true,
attributes: {
notes: ['content'], // Only check content changes
},
},
});
// Should only detect content change
const contentChanges = Array.from(result.diffMap.values()).filter(
(diff) =>
diff.type === 'changed' &&
diff.attribute === 'content' &&
diff.object === 'note'
);
expect(contentChanges.length).toBe(1);
// Should not detect color or position changes
const otherChanges = Array.from(result.diffMap.values()).filter(
(diff) =>
diff.type === 'changed' &&
(diff.attribute === 'color' ||
diff.attribute === 'x' ||
diff.attribute === 'y') &&
diff.object === 'note'
);
expect(otherChanges.length).toBe(0);
});
});
describe('Custom Matchers', () => {
it('should use custom table matcher to match by name', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-1', name: 'users' })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-2', name: 'users' })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
matchers: {
table: (table, tables) =>
tables.find((t) => t.name === table.name),
},
},
});
// Should not detect any changes since tables match by name
expect(result.diffMap.size).toBe(0);
});
it('should detect changes when custom matcher finds no match', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-1', name: 'users' })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-2', name: 'customers' })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
matchers: {
table: (table, tables) =>
tables.find((t) => t.name === table.name),
},
},
});
// Should detect both added and removed since names don't match
expect(result.diffMap.size).toBe(2);
expect(result.diffMap.has('table-table-1')).toBe(true); // removed
expect(result.diffMap.has('table-table-2')).toBe(true); // added
});
it('should use custom field matcher to match by name', () => {
const field1 = createMockField({
id: 'field-1',
name: 'email',
nullable: true,
});
const field2 = createMockField({
id: 'field-2',
name: 'email',
nullable: false,
});
const oldDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-1', fields: [field1] })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-1', fields: [field2] })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
matchers: {
field: (field, fields) =>
fields.find((f) => f.name === field.name),
},
},
});
// With name-based matching, field-1 should match field-2 by name
// and detect the nullable change
const nullableChange = result.diffMap.get('field-nullable-field-1');
expect(nullableChange).toBeDefined();
expect(nullableChange?.type).toBe('changed');
expect((nullableChange as FieldDiffChanged)?.attribute).toBe(
'nullable'
);
});
it('should use case-insensitive custom matcher', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-1', name: 'Users' })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-2', name: 'users' })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
matchers: {
table: (table, tables) =>
tables.find(
(t) =>
t.name.toLowerCase() ===
table.name.toLowerCase()
),
},
},
});
// With case-insensitive name matching, the tables are matched
// but the name case difference is still detected as a change
expect(result.diffMap.size).toBe(1);
const nameChange = result.diffMap.get('table-name-table-1');
expect(nameChange).toBeDefined();
expect(nameChange?.type).toBe('changed');
expect((nameChange as TableDiffChanged)?.attribute).toBe('name');
expect((nameChange as TableDiffChanged)?.oldValue).toBe('Users');
expect((nameChange as TableDiffChanged)?.newValue).toBe('users');
});
});
describe('Filtering Options', () => {
it('should only check specified change types', () => {
const oldDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-1', name: 'users' })],
});
const newDiagram = createMockDiagram({
tables: [createMockTable({ id: 'table-2', name: 'products' })],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
changeTypes: {
tables: ['added'], // Only check for added tables
},
},
});
// Should only detect added table (table-2)
const addedTables = Array.from(result.diffMap.values()).filter(
(diff) => diff.type === 'added' && diff.object === 'table'
);
expect(addedTables.length).toBe(1);
// Should not detect removed table (table-1)
const removedTables = Array.from(result.diffMap.values()).filter(
(diff) => diff.type === 'removed' && diff.object === 'table'
);
expect(removedTables.length).toBe(0);
});
it('should only check specified attributes', () => {
const oldDiagram = createMockDiagram({
tables: [
createMockTable({
id: 'table-1',
name: 'users',
color: 'blue',
comments: 'old comment',
}),
],
});
const newDiagram = createMockDiagram({
tables: [
createMockTable({
id: 'table-1',
name: 'customers',
color: 'red',
comments: 'new comment',
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
attributes: {
tables: ['name'], // Only check name changes
},
},
});
// Should only detect name change
const nameChanges = Array.from(result.diffMap.values()).filter(
(diff) =>
diff.type === 'changed' &&
diff.attribute === 'name' &&
diff.object === 'table'
);
expect(nameChanges.length).toBe(1);
// Should not detect color or comments changes
const otherChanges = Array.from(result.diffMap.values()).filter(
(diff) =>
diff.type === 'changed' &&
(diff.attribute === 'color' ||
diff.attribute === 'comments') &&
diff.object === 'table'
);
expect(otherChanges.length).toBe(0);
});
it('should respect include flags', () => {
const oldDiagram = createMockDiagram({
tables: [
createMockTable({
fields: [createMockField()],
indexes: [{ id: 'idx-1', name: 'idx' } as DBIndex],
}),
],
});
const newDiagram = createMockDiagram({
tables: [
createMockTable({
fields: [],
indexes: [],
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeFields: false,
includeIndexes: true,
},
});
// Should only detect index removal, not field removal
expect(result.diffMap.has('index-idx-1')).toBe(true);
expect(result.diffMap.has('field-field-1')).toBe(false);
});
});
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({
tables: [
createMockTable({
id: 'table-1',
x: 0,
y: 0,
width: 100,
}),
],
areas: [
createMockArea({
id: 'area-1',
x: 0,
y: 0,
width: 200,
height: 150,
}),
],
notes: [
createMockNote({
id: 'note-1',
x: 0,
y: 0,
width: 300,
height: 200,
}),
],
});
const newDiagram = createMockDiagram({
tables: [
createMockTable({
id: 'table-1',
x: 10,
y: 20,
width: 120,
}),
],
areas: [
createMockArea({
id: 'area-1',
x: 25,
y: 35,
width: 250,
height: 175,
}),
],
notes: [
createMockNote({
id: 'note-1',
x: 40,
y: 50,
width: 350,
height: 225,
}),
],
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
options: {
includeAreas: true,
includeNotes: true,
attributes: {
tables: ['x', 'y', 'width'],
areas: ['x', 'y', 'width', 'height'],
notes: ['x', 'y', 'width', 'height'],
},
},
});
// Table dimensional changes
expect(result.diffMap.has('table-x-table-1')).toBe(true);
expect(result.diffMap.has('table-y-table-1')).toBe(true);
expect(result.diffMap.has('table-width-table-1')).toBe(true);
// Area dimensional changes
expect(result.diffMap.has('area-x-area-1')).toBe(true);
expect(result.diffMap.has('area-y-area-1')).toBe(true);
expect(result.diffMap.has('area-width-area-1')).toBe(true);
expect(result.diffMap.has('area-height-area-1')).toBe(true);
// Note dimensional changes
expect(result.diffMap.has('note-x-note-1')).toBe(true);
expect(result.diffMap.has('note-y-note-1')).toBe(true);
expect(result.diffMap.has('note-width-note-1')).toBe(true);
expect(result.diffMap.has('note-height-note-1')).toBe(true);
// Verify the correct values
const tableWidthDiff = result.diffMap.get('table-width-table-1');
expect((tableWidthDiff as TableDiffChanged)?.oldValue).toBe(100);
expect((tableWidthDiff as TableDiffChanged)?.newValue).toBe(120);
const areaWidthDiff = result.diffMap.get('area-width-area-1');
expect((areaWidthDiff as AreaDiffChanged)?.oldValue).toBe(200);
expect((areaWidthDiff as AreaDiffChanged)?.newValue).toBe(250);
const areaHeightDiff = result.diffMap.get('area-height-area-1');
expect((areaHeightDiff as AreaDiffChanged)?.oldValue).toBe(150);
expect((areaHeightDiff as AreaDiffChanged)?.newValue).toBe(175);
const noteWidthDiff = result.diffMap.get('note-width-note-1');
expect((noteWidthDiff as NoteDiffChanged)?.oldValue).toBe(300);
expect((noteWidthDiff as NoteDiffChanged)?.newValue).toBe(350);
const noteHeightDiff = result.diffMap.get('note-height-note-1');
expect((noteHeightDiff as NoteDiffChanged)?.oldValue).toBe(200);
expect((noteHeightDiff as NoteDiffChanged)?.newValue).toBe(225);
});
it('should handle multiple simultaneous changes', () => {
const oldDiagram = createMockDiagram({
tables: [
createMockTable({
id: 'table-1',
name: 'users',
fields: [
createMockField({ id: 'field-1', name: 'id' }),
createMockField({ id: 'field-2', name: 'email' }),
],
}),
createMockTable({
id: 'table-2',
name: 'products',
}),
],
relationships: [createMockRelationship()],
});
const newDiagram = createMockDiagram({
tables: [
createMockTable({
id: 'table-1',
name: 'customers', // Changed name
fields: [
createMockField({ id: 'field-1', name: 'id' }),
// Removed field-2
createMockField({ id: 'field-3', name: 'name' }), // Added field
],
}),
// Removed table-2
createMockTable({
id: 'table-3',
name: 'orders', // Added table
}),
],
relationships: [], // Removed relationship
});
const result = generateDiff({
diagram: oldDiagram,
newDiagram,
});
// Verify all changes are detected
expect(result.diffMap.has('table-name-table-1')).toBe(true); // Table name change
expect(result.diffMap.has('field-field-2')).toBe(true); // Removed field
expect(result.diffMap.has('field-field-3')).toBe(true); // Added field
expect(result.diffMap.has('table-table-2')).toBe(true); // Removed table
expect(result.diffMap.has('table-table-3')).toBe(true); // Added table
expect(result.diffMap.has('relationship-rel-1')).toBe(true); // Removed relationship
});
it('should handle empty diagrams', () => {
const emptyDiagram1 = createMockDiagram();
const emptyDiagram2 = createMockDiagram();
const result = generateDiff({
diagram: emptyDiagram1,
newDiagram: emptyDiagram2,
});
expect(result.diffMap.size).toBe(0);
expect(result.changedTables.size).toBe(0);
expect(result.changedFields.size).toBe(0);
expect(result.changedAreas.size).toBe(0);
expect(result.changedNotes.size).toBe(0);
});
it('should handle diagrams with undefined collections', () => {
const diagram1 = createMockDiagram({
tables: undefined,
relationships: undefined,
areas: undefined,
notes: undefined,
});
const diagram2 = createMockDiagram({
tables: [createMockTable({ id: 'table-1' })],
relationships: [createMockRelationship({ id: 'rel-1' })],
areas: [createMockArea({ id: 'area-1' })],
notes: [createMockNote({ id: 'note-1' })],
});
const result = generateDiff({
diagram: diagram1,
newDiagram: diagram2,
options: {
includeAreas: true,
includeNotes: true,
},
});
// Should detect all as added
expect(result.diffMap.has('table-table-1')).toBe(true);
expect(result.diffMap.has('relationship-rel-1')).toBe(true);
expect(result.diffMap.has('area-area-1')).toBe(true);
expect(result.diffMap.has('note-note-1')).toBe(true);
});
});
});