@restforgejs/platform 4.1.1 → 4.3.1

package/generators/tests/unit/lib/dbschema-kit/validator/circular-relation-validator.test.js

@@ -1,454 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { validateCrossModel } = require('../../../../../lib/dbschema-kit/validator/cross-model-validator');
-const { validateCircularRelations } = require('../../../../../lib/dbschema-kit/validator/circular-relation-validator');
-
-function makeModel(tableName, opts = {}) {
-  const schemaName = opts.schemaName || null;
-  const model = {
-    schemaName,
-    tableName,
-    qualifiedName: schemaName ? `${schemaName}.${tableName}` : tableName,
-    fields: opts.fields || {},
-    primaryKey: opts.primaryKey || [],
-    indexes: [],
-    uniques: [],
-    relations: opts.relations || {},
-    checks: opts.checks || [],
-    _meta: {
-      hasSinglePkShorthand: false,
-      hasCompositePrimaryKey: false,
-      autoGeneratedRelations: []
-    }
-  };
-  if (opts.filePath) {
-    Object.defineProperty(model, '_filePath', {
-      value: opts.filePath,
-      enumerable: false,
-      writable: false,
-      configurable: false
-    });
-  }
-  return model;
-}
-
-function setupModels(models) {
-  validateCrossModel(models);
-  return models;
-}
-
-// =====================================================
-// Linear / valid scenarios
-// =====================================================
-
-test('circular: linear A → B → C (no cycle) → 0 issues', () => {
-  const models = setupModels(new Map([
-    ['c', makeModel('c', {
-      fields: { c_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['c_id']
-    })],
-    ['b', makeModel('b', {
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        c_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        parent_c: { type: 'belongsTo', target: 'c', localKey: 'c_id', references: 'c_id' }
-      }
-    })],
-    ['a', makeModel('a', {
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        parent_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' }
-      }
-    })]
-  ]));
-  assert.deepStrictEqual(validateCircularRelations(models), []);
-});
-
-test('circular: empty Map → 0 issues', () => {
-  assert.deepStrictEqual(validateCircularRelations(new Map()), []);
-});
-
-test('circular: model dengan relations kosong → 0 issues', () => {
-  const models = setupModels(new Map([
-    ['solo', makeModel('solo', {
-      fields: { solo_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['solo_id']
-    })]
-  ]));
-  assert.deepStrictEqual(validateCircularRelations(models), []);
-});
-
-// =====================================================
-// Direct cycle (2 tables)
-// =====================================================
-
-test('circular: A ↔ B keduanya mandatory → circular-mandatory-relation error', () => {
-  const models = setupModels(new Map([
-    ['a', makeModel('a', {
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        partner_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' }
-      }
-    })],
-    ['b', makeModel('b', {
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        partner_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'error');
-  assert.strictEqual(issues[0].code, 'circular-mandatory-relation');
-  assert.match(issues[0].message, /a → b → a/);
-  assert.match(issues[0].message, /all relations mandatory/);
-});
-
-test('circular: A ↔ B salah satu nullable → circular-relation-nullable warning', () => {
-  const models = setupModels(new Map([
-    ['a', makeModel('a', {
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid' } // nullable
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        partner_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' }
-      }
-    })],
-    ['b', makeModel('b', {
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        partner_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'warning');
-  assert.strictEqual(issues[0].code, 'circular-relation-nullable');
-  assert.match(issues[0].message, /at least one nullable edge/);
-});
-
-// =====================================================
-// Indirect cycle (3 tables)
-// =====================================================
-
-test('circular: A → B → C → A semua mandatory → circular-mandatory-relation error', () => {
-  const models = setupModels(new Map([
-    ['a', makeModel('a', {
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        to_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' }
-      }
-    })],
-    ['b', makeModel('b', {
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        c_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        to_c: { type: 'belongsTo', target: 'c', localKey: 'c_id', references: 'c_id' }
-      }
-    })],
-    ['c', makeModel('c', {
-      fields: {
-        c_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['c_id'],
-      relations: {
-        to_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'circular-mandatory-relation');
-  assert.match(issues[0].message, /a → b → c → a/);
-});
-
-test('circular: A → B → C → A satu nullable → warning', () => {
-  const models = setupModels(new Map([
-    ['a', makeModel('a', {
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        to_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' }
-      }
-    })],
-    ['b', makeModel('b', {
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        c_id: { type: 'uuid' } // nullable
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        to_c: { type: 'belongsTo', target: 'c', localKey: 'c_id', references: 'c_id' }
-      }
-    })],
-    ['c', makeModel('c', {
-      fields: {
-        c_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['c_id'],
-      relations: {
-        to_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'warning');
-  assert.strictEqual(issues[0].code, 'circular-relation-nullable');
-});
-
-// =====================================================
-// Self-reference
-// =====================================================
-
-test('circular: self-reference nullable (employee.manager_id NULL) → 0 issues (common tree pattern)', () => {
-  const models = setupModels(new Map([
-    ['employee', makeModel('employee', {
-      fields: {
-        employee_id: { type: 'uuid', pk: true, notnull: true },
-        manager_id: { type: 'uuid' } // nullable
-      },
-      primaryKey: ['employee_id'],
-      relations: {
-        manager: { type: 'belongsTo', target: 'employee', localKey: 'manager_id', references: 'employee_id' }
-      }
-    })]
-  ]));
-  assert.deepStrictEqual(validateCircularRelations(models), []);
-});
-
-test('circular: self-reference mandatory (employee.manager_id NOT NULL) → circular-mandatory-relation error', () => {
-  const models = setupModels(new Map([
-    ['employee', makeModel('employee', {
-      fields: {
-        employee_id: { type: 'uuid', pk: true, notnull: true },
-        manager_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['employee_id'],
-      relations: {
-        manager: { type: 'belongsTo', target: 'employee', localKey: 'manager_id', references: 'employee_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'error');
-  assert.strictEqual(issues[0].code, 'circular-mandatory-relation');
-  assert.match(issues[0].message, /self-reference/);
-  assert.match(issues[0].message, /employee → employee/);
-});
-
-// =====================================================
-// Multiple cycles
-// =====================================================
-
-test('circular: A↔B dan A↔C semua mandatory → 2 cycles reported', () => {
-  const models = setupModels(new Map([
-    ['a', makeModel('a', {
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true },
-        c_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        to_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' },
-        to_c: { type: 'belongsTo', target: 'c', localKey: 'c_id', references: 'c_id' }
-      }
-    })],
-    ['b', makeModel('b', {
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        to_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })],
-    ['c', makeModel('c', {
-      fields: {
-        c_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['c_id'],
-      relations: {
-        to_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 2);
-  for (const issue of issues) {
-    assert.strictEqual(issue.code, 'circular-mandatory-relation');
-  }
-  // Ensure the two cycles are distinct
-  assert.notStrictEqual(issues[0].message, issues[1].message);
-});
-
-test('circular: tidak duplicate — A↔B detected sebagai 1 cycle meskipun DFS bisa start dari A atau B', () => {
-  const models = setupModels(new Map([
-    ['a', makeModel('a', {
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        to_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' }
-      }
-    })],
-    ['b', makeModel('b', {
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        to_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-});
-
-// =====================================================
-// Skip non-belongsTo
-// =====================================================
-
-test('circular: cycle melalui hasMany di-skip karena FK bukan di source', () => {
-  // supplier hasMany stock_inbound, stock_inbound belongsTo supplier
-  // hasMany side is NOT part of the graph (no FK column at supplier)
-  const models = setupModels(new Map([
-    ['supplier', makeModel('supplier', {
-      fields: { supplier_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['supplier_id'],
-      relations: {
-        inbounds: { type: 'hasMany', target: 'stock_inbound', localKey: 'supplier_id', references: 'supplier_id' }
-      }
-    })],
-    ['stock_inbound', makeModel('stock_inbound', {
-      fields: {
-        stock_inbound_id: { type: 'uuid', pk: true, notnull: true },
-        supplier_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['stock_inbound_id'],
-      relations: {
-        supplier: { type: 'belongsTo', target: 'supplier', localKey: 'supplier_id', references: 'supplier_id' }
-      }
-    })]
-  ]));
-  // Only one-way belongsTo edge: stock_inbound → supplier. No cycle.
-  assert.deepStrictEqual(validateCircularRelations(models), []);
-});
-
-// =====================================================
-// Decoration
-// =====================================================
-
-test('circular: Issue di-decorate dengan file path bila _filePath ada di model entry', () => {
-  const models = setupModels(new Map([
-    ['a', makeModel('a', {
-      filePath: '/abs/schema/a.js',
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        to_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' }
-      }
-    })],
-    ['b', makeModel('b', {
-      filePath: '/abs/schema/b.js',
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        to_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-  assert.ok(issues[0].file, 'Issue.file should be populated');
-  assert.match(issues[0].file, /\/abs\/schema\/[ab]\.js$/);
-  assert.ok(issues[0].table);
-});
-
-// =====================================================
-// Multi-schema
-// =====================================================
-
-test('circular: qualified multi-schema cycle terdeteksi dengan benar', () => {
-  const models = setupModels(new Map([
-    ['inventory.a', makeModel('a', {
-      schemaName: 'inventory',
-      fields: {
-        a_id: { type: 'uuid', pk: true, notnull: true },
-        b_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['a_id'],
-      relations: {
-        to_b: { type: 'belongsTo', target: 'audit.b', localKey: 'b_id', references: 'b_id' }
-      }
-    })],
-    ['audit.b', makeModel('b', {
-      schemaName: 'audit',
-      fields: {
-        b_id: { type: 'uuid', pk: true, notnull: true },
-        a_id: { type: 'uuid', notnull: true }
-      },
-      primaryKey: ['b_id'],
-      relations: {
-        to_a: { type: 'belongsTo', target: 'inventory.a', localKey: 'a_id', references: 'a_id' }
-      }
-    })]
-  ]));
-  const issues = validateCircularRelations(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'circular-mandatory-relation');
-  assert.match(issues[0].message, /audit\.b/);
-  assert.match(issues[0].message, /inventory\.a/);
-});