Skip to content

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

fix: cardinality diff handle (#1038)

Guy Ben-Aharona63d2b3f7447
diff --git a/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts b/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts
index 408fca34..a2eed36b 100644
--- a/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts
+++ b/src/lib/domain/diff/diff-check/__tests__/diff-check.test.ts
@@ -926,14 +926,22 @@ describe('generateDiff', () => {
});
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({ targetCardinality: 'many' }),
+ createMockRelationship({
+ sourceCardinality: 'many',
+ targetCardinality: 'many',
+ }),
],
});
const newDiagram = createMockDiagram({
relationships: [
- createMockRelationship({ targetCardinality: 'one' }),
+ createMockRelationship({
+ sourceCardinality: 'many',
+ targetCardinality: 'one',
+ }),
],
});
@@ -955,6 +963,102 @@ describe('generateDiff', () => {
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: [
diff --git a/src/lib/domain/diff/diff-check/diff-check.ts b/src/lib/domain/diff/diff-check/diff-check.ts
index 994ff00a..6fac168f 100644
--- a/src/lib/domain/diff/diff-check/diff-check.ts
+++ b/src/lib/domain/diff/diff-check/diff-check.ts
@@ -1290,19 +1290,46 @@ function compareRelationshipProperties({
) {
changedAttributes.push('targetFieldId');
}
+ // Check cardinality changes, but exclude changes that produce the same DDL.
+ // In DDL export, when source is 'one', the relationship direction stays consistent.
+ // Therefore (one, one) ↔ (one, many) are equivalent from DDL perspective.
+ const shouldCheckCardinality =
+ attributesToCheck.includes('sourceCardinality') ||
+ attributesToCheck.includes('targetCardinality');
+
+ if (shouldCheckCardinality) {
+ const oldSource = oldRelationship.sourceCardinality;
+ const oldTarget = oldRelationship.targetCardinality;
+ const newSource = newRelationship.sourceCardinality;
+ const newTarget = newRelationship.targetCardinality;
+
+ // Check if this is an "equivalent" cardinality change that produces the same DDL
+ // Equivalent pairs: (one, one) ↔ (many, one) - both put FK on source table
+ const isEquivalentCardinalityChange =
+ (oldSource === 'one' &&
+ oldTarget === 'one' &&
+ newTarget === 'many' &&
+ newSource === 'one') ||
+ (oldTarget === 'many' &&
+ oldSource === 'one' &&
+ newSource === 'one' &&
+ newTarget === 'one');
+
+ if (!isEquivalentCardinalityChange) {
+ if (
+ attributesToCheck.includes('sourceCardinality') &&
+ oldSource !== newSource
+ ) {
+ changedAttributes.push('sourceCardinality');
+ }
- if (
- attributesToCheck.includes('sourceCardinality') &&
- oldRelationship.sourceCardinality !== newRelationship.sourceCardinality
- ) {
- changedAttributes.push('sourceCardinality');
- }
-
- if (
- attributesToCheck.includes('targetCardinality') &&
- oldRelationship.targetCardinality !== newRelationship.targetCardinality
- ) {
- changedAttributes.push('targetCardinality');
+ if (
+ attributesToCheck.includes('targetCardinality') &&
+ oldTarget !== newTarget
+ ) {
+ changedAttributes.push('targetCardinality');
+ }
+ }
}
if (changedAttributes.length > 0) {