Skip to content

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

fix: add tests for diff (#930)

Guy Ben-Aharon47a7a73a137b
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
new file mode 100644
index 00000000..b0b3521a
--- /dev/null
+++ b/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts
@@ -0,0 +1,662 @@
+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 { DatabaseType } from '@/lib/domain/database-type';
+import type { TableDiffChanged } from '../../table-diff';
+import type { FieldDiffChanged } from '../../field-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',
+ sourceTableId: 'table-1',
+ targetTableId: 'table-2',
+ sourceFieldId: 'field-1',
+ targetFieldId: 'field-2',
+ type: 'one-to-many',
+ ...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;
+}
+
+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);
+ });
+ });
+
+ 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('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');
+ });
+
+ 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');
+ });
+ });
+
+ 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);
+ });
+ });
+
+ 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('Complex Scenarios', () => {
+ 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);
+ });
+
+ it('should handle diagrams with undefined collections', () => {
+ const diagram1 = createMockDiagram({
+ tables: undefined,
+ relationships: undefined,
+ areas: undefined,
+ });
+ const diagram2 = createMockDiagram({
+ tables: [createMockTable({ id: 'table-1' })],
+ relationships: [createMockRelationship({ id: 'rel-1' })],
+ areas: [createMockArea({ id: 'area-1' })],
+ });
+
+ const result = generateDiff({
+ diagram: diagram1,
+ newDiagram: diagram2,
+ options: {
+ includeAreas: 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);
+ });
+ });
+});
diff --git a/src/lib/domain/diff/diff-check/diff-check.ts b/src/lib/domain/diff/diff-check/diff-check.ts
index a9dee324..a530178f 100644
--- a/src/lib/domain/diff/diff-check/diff-check.ts
+++ b/src/lib/domain/diff/diff-check/diff-check.ts
@@ -1,6 +1,9 @@
import type { Diagram } from '@/lib/domain/diagram';
import type { DBField } from '@/lib/domain/db-field';
import type { DBIndex } from '@/lib/domain/db-index';
+import type { DBTable } from '@/lib/domain/db-table';
+import type { DBRelationship } from '@/lib/domain/db-relationship';
+import type { Area } from '@/lib/domain/area';
import type { ChartDBDiff, DiffMap, DiffObject } from '@/lib/domain/diff/diff';
import type {
FieldDiff,
@@ -43,20 +46,22 @@ export interface GenerateDiffOptions {
relationships?: RelationshipDiff['type'][];
areas?: AreaDiff['type'][];
};
+ matchers?: {
+ table?: (table: DBTable, tables: DBTable[]) => DBTable | undefined;
+ field?: (field: DBField, fields: DBField[]) => DBField | undefined;
+ index?: (index: DBIndex, indexes: DBIndex[]) => DBIndex | undefined;
+ relationship?: (
+ relationship: DBRelationship,
+ relationships: DBRelationship[]
+ ) => DBRelationship | undefined;
+ area?: (area: Area, areas: Area[]) => Area | undefined;
+ };
}
export function generateDiff({
diagram,
newDiagram,
- options = {
- includeTables: true,
- includeFields: true,
- includeIndexes: true,
- includeRelationships: true,
- includeAreas: false,
- attributes: {},
- changeTypes: {},
- },
+ options = {},
}: {
diagram: Diagram;
newDiagram: Diagram;
@@ -67,20 +72,41 @@ export function generateDiff({
changedFields: Map<string, boolean>;
changedAreas: Map<string, boolean>;
} {
+ // Merge with default options
+ const mergedOptions: GenerateDiffOptions = {
+ includeTables: options.includeTables ?? true,
+ includeFields: options.includeFields ?? true,
+ includeIndexes: options.includeIndexes ?? true,
+ includeRelationships: options.includeRelationships ?? true,
+ includeAreas: options.includeAreas ?? false,
+ attributes: options.attributes ?? {},
+ changeTypes: options.changeTypes ?? {},
+ matchers: options.matchers ?? {},
+ };
+
const newDiffs = new Map<string, ChartDBDiff>();
const changedTables = new Map<string, boolean>();
const changedFields = new Map<string, boolean>();
const changedAreas = new Map<string, boolean>();
+ // Use provided matchers or default ones
+ const tableMatcher = mergedOptions.matchers?.table ?? defaultTableMatcher;
+ const fieldMatcher = mergedOptions.matchers?.field ?? defaultFieldMatcher;
+ const indexMatcher = mergedOptions.matchers?.index ?? defaultIndexMatcher;
+ const relationshipMatcher =
+ mergedOptions.matchers?.relationship ?? defaultRelationshipMatcher;
+ const areaMatcher = mergedOptions.matchers?.area ?? defaultAreaMatcher;
+
// Compare tables
- if (options.includeTables) {
+ if (mergedOptions.includeTables) {
compareTables({
diagram,
newDiagram,
diffMap: newDiffs,
changedTables,
- attributes: options.attributes?.tables,
- changeTypes: options.changeTypes?.tables,
+ attributes: mergedOptions.attributes?.tables,
+ changeTypes: mergedOptions.changeTypes?.tables,
+ tableMatcher,
});
}
@@ -91,28 +117,33 @@ export function generateDiff({
diffMap: newDiffs,
changedTables,
changedFields,
- options,
+ options: mergedOptions,
+ tableMatcher,
+ fieldMatcher,
+ indexMatcher,
});
// Compare relationships
- if (options.includeRelationships) {
+ if (mergedOptions.includeRelationships) {
compareRelationships({
diagram,
newDiagram,
diffMap: newDiffs,
- changeTypes: options.changeTypes?.relationships,
+ changeTypes: mergedOptions.changeTypes?.relationships,
+ relationshipMatcher,
});
}
// Compare areas if enabled
- if (options.includeAreas) {
+ if (mergedOptions.includeAreas) {
compareAreas({
diagram,
newDiagram,
diffMap: newDiffs,
changedAreas,
- attributes: options.attributes?.areas,
- changeTypes: options.changeTypes?.areas,
+ attributes: mergedOptions.attributes?.areas,
+ changeTypes: mergedOptions.changeTypes?.areas,
+ areaMatcher,
});
}
@@ -127,6 +158,7 @@ function compareTables({
changedTables,
attributes,
changeTypes,
+ tableMatcher,
}: {
diagram: Diagram;
newDiagram: Diagram;
@@ -134,6 +166,7 @@ function compareTables({
changedTables: Map<string, boolean>;
attributes?: TableDiffAttribute[];
changeTypes?: TableDiff['type'][];
+ tableMatcher: (table: DBTable, tables: DBTable[]) => DBTable | undefined;
}) {
const oldTables = diagram.tables || [];
const newTables = newDiagram.tables || [];
@@ -149,7 +182,7 @@ function compareTables({
// Check for added tables
if (typesToCheck.includes('added')) {
for (const newTable of newTables) {
- if (!oldTables.find((t) => t.id === newTable.id)) {
+ if (!tableMatcher(newTable, oldTables)) {
diffMap.set(
getDiffMapKey({
diffObject: 'table',
@@ -169,7 +202,7 @@ function compareTables({
// Check for removed tables
if (typesToCheck.includes('removed')) {
for (const oldTable of oldTables) {
- if (!newTables.find((t) => t.id === oldTable.id)) {
+ if (!tableMatcher(oldTable, newTables)) {
diffMap.set(
getDiffMapKey({
diffObject: 'table',
@@ -189,7 +222,7 @@ function compareTables({
// Check for table name, comments and color changes
if (typesToCheck.includes('changed')) {
for (const oldTable of oldTables) {
- const newTable = newTables.find((t) => t.id === oldTable.id);
+ const newTable = tableMatcher(oldTable, newTables);
if (!newTable) continue;
@@ -321,6 +354,9 @@ function compareTableContents({
changedTables,
changedFields,
options,
+ tableMatcher,
+ fieldMatcher,
+ indexMatcher,
}: {
diagram: Diagram;
newDiagram: Diagram;
@@ -328,13 +364,16 @@ function compareTableContents({
changedTables: Map<string, boolean>;
changedFields: Map<string, boolean>;
options?: GenerateDiffOptions;
+ tableMatcher: (table: DBTable, tables: DBTable[]) => DBTable | undefined;
+ fieldMatcher: (field: DBField, fields: DBField[]) => DBField | undefined;
+ indexMatcher: (index: DBIndex, indexes: DBIndex[]) => DBIndex | undefined;
}) {
const oldTables = diagram.tables || [];
const newTables = newDiagram.tables || [];
// For each table that exists in both diagrams
for (const oldTable of oldTables) {
- const newTable = newTables.find((t) => t.id === oldTable.id);
+ const newTable = tableMatcher(oldTable, newTables);
if (!newTable) continue;
// Compare fields
@@ -348,6 +387,7 @@ function compareTableContents({
changedFields,
attributes: options?.attributes?.fields,
changeTypes: options?.changeTypes?.fields,
+ fieldMatcher,
});
}
@@ -360,6 +400,7 @@ function compareTableContents({
diffMap,
changedTables,
changeTypes: options?.changeTypes?.indexes,
+ indexMatcher,
});
}
}
@@ -375,6 +416,7 @@ function compareFields({
changedFields,
attributes,
changeTypes,
+ fieldMatcher,
}: {
tableId: string;
oldFields: DBField[];
@@ -384,6 +426,7 @@ function compareFields({
changedFields: Map<string, boolean>;
attributes?: FieldDiffAttribute[];
changeTypes?: FieldDiff['type'][];
+ fieldMatcher: (field: DBField, fields: DBField[]) => DBField | undefined;
}) {
// If changeTypes is empty array, don't check any changes
if (changeTypes && changeTypes.length === 0) {
@@ -395,7 +438,7 @@ function compareFields({
// Check for added fields
if (typesToCheck.includes('added')) {
for (const newField of newFields) {
- if (!oldFields.find((f) => f.id === newField.id)) {
+ if (!fieldMatcher(newField, oldFields)) {
diffMap.set(
getDiffMapKey({
diffObject: 'field',
@@ -417,7 +460,7 @@ function compareFields({
// Check for removed fields
if (typesToCheck.includes('removed')) {
for (const oldField of oldFields) {
- if (!newFields.find((f) => f.id === oldField.id)) {
+ if (!fieldMatcher(oldField, newFields)) {
diffMap.set(
getDiffMapKey({
diffObject: 'field',
@@ -440,7 +483,7 @@ function compareFields({
// Check for field changes
if (typesToCheck.includes('changed')) {
for (const oldField of oldFields) {
- const newField = newFields.find((f) => f.id === oldField.id);
+ const newField = fieldMatcher(oldField, newFields);
if (!newField) continue;
// Compare basic field properties
@@ -586,6 +629,7 @@ function compareIndexes({
diffMap,
changedTables,
changeTypes,
+ indexMatcher,
}: {
tableId: string;
oldIndexes: DBIndex[];
@@ -593,6 +637,7 @@ function compareIndexes({
diffMap: DiffMap;
changedTables: Map<string, boolean>;
changeTypes?: IndexDiff['type'][];
+ indexMatcher: (index: DBIndex, indexes: DBIndex[]) => DBIndex | undefined;
}) {
// If changeTypes is empty array, don't check any changes
if (changeTypes && changeTypes.length === 0) {
@@ -604,7 +649,7 @@ function compareIndexes({
// Check for added indexes
if (typesToCheck.includes('added')) {
for (const newIndex of newIndexes) {
- if (!oldIndexes.find((i) => i.id === newIndex.id)) {
+ if (!indexMatcher(newIndex, oldIndexes)) {
diffMap.set(
getDiffMapKey({
diffObject: 'index',
@@ -625,7 +670,7 @@ function compareIndexes({
// Check for removed indexes
if (typesToCheck.includes('removed')) {
for (const oldIndex of oldIndexes) {
- if (!newIndexes.find((i) => i.id === oldIndex.id)) {
+ if (!indexMatcher(oldIndex, newIndexes)) {
diffMap.set(
getDiffMapKey({
diffObject: 'index',
@@ -650,11 +695,16 @@ function compareRelationships({
newDiagram,
diffMap,
changeTypes,
+ relationshipMatcher,
}: {
diagram: Diagram;
newDiagram: Diagram;
diffMap: DiffMap;
changeTypes?: RelationshipDiff['type'][];
+ relationshipMatcher: (
+ relationship: DBRelationship,
+ relationships: DBRelationship[]
+ ) => DBRelationship | undefined;
}) {
// If changeTypes is empty array, don't check any changes
if (changeTypes && changeTypes.length === 0) {
@@ -669,7 +719,7 @@ function compareRelationships({
// Check for added relationships
if (typesToCheck.includes('added')) {
for (const newRelationship of newRelationships) {
- if (!oldRelationships.find((r) => r.id === newRelationship.id)) {
+ if (!relationshipMatcher(newRelationship, oldRelationships)) {
diffMap.set(
getDiffMapKey({
diffObject: 'relationship',
@@ -688,7 +738,7 @@ function compareRelationships({
// Check for removed relationships
if (typesToCheck.includes('removed')) {
for (const oldRelationship of oldRelationships) {
- if (!newRelationships.find((r) => r.id === oldRelationship.id)) {
+ if (!relationshipMatcher(oldRelationship, newRelationships)) {
diffMap.set(
getDiffMapKey({
diffObject: 'relationship',
@@ -713,6 +763,7 @@ function compareAreas({
changedAreas,
attributes,
changeTypes,
+ areaMatcher,
}: {
diagram: Diagram;
newDiagram: Diagram;
@@ -720,6 +771,7 @@ function compareAreas({
changedAreas: Map<string, boolean>;
attributes?: AreaDiffAttribute[];
changeTypes?: AreaDiff['type'][];
+ areaMatcher: (area: Area, areas: Area[]) => Area | undefined;
}) {
const oldAreas = diagram.areas || [];
const newAreas = newDiagram.areas || [];
@@ -735,7 +787,7 @@ function compareAreas({
// Check for added areas
if (typesToCheck.includes('added')) {
for (const newArea of newAreas) {
- if (!oldAreas.find((a) => a.id === newArea.id)) {
+ if (!areaMatcher(newArea, oldAreas)) {
diffMap.set(
getDiffMapKey({
diffObject: 'area',
@@ -755,7 +807,7 @@ function compareAreas({
// Check for removed areas
if (typesToCheck.includes('removed')) {
for (const oldArea of oldAreas) {
- if (!newAreas.find((a) => a.id === oldArea.id)) {
+ if (!areaMatcher(oldArea, newAreas)) {
diffMap.set(
getDiffMapKey({
diffObject: 'area',
@@ -775,7 +827,7 @@ function compareAreas({
// Check for area name and color changes
if (typesToCheck.includes('changed')) {
for (const oldArea of oldAreas) {
- const newArea = newAreas.find((a) => a.id === oldArea.id);
+ const newArea = areaMatcher(oldArea, newAreas);
if (!newArea) continue;
@@ -869,3 +921,35 @@ function compareAreas({
}
}
}
+
+const defaultTableMatcher = (
+ table: DBTable,
+ tables: DBTable[]
+): DBTable | undefined => {
+ return tables.find((t) => t.id === table.id);
+};
+
+const defaultFieldMatcher = (
+ field: DBField,
+ fields: DBField[]
+): DBField | undefined => {
+ return fields.find((f) => f.id === field.id);
+};
+
+const defaultIndexMatcher = (
+ index: DBIndex,
+ indexes: DBIndex[]
+): DBIndex | undefined => {
+ return indexes.find((i) => i.id === index.id);
+};
+
+const defaultRelationshipMatcher = (
+ relationship: DBRelationship,
+ relationships: DBRelationship[]
+): DBRelationship | undefined => {
+ return relationships.find((r) => r.id === relationship.id);
+};
+
+const defaultAreaMatcher = (area: Area, areas: Area[]): Area | undefined => {
+ return areas.find((a) => a.id === area.id);
+};