@restforgejs/platform 4.2.8 → 4.3.2

package/generators/tests/unit/lib/dbschema-kit/validator/type-compatibility-validator.test.js

@@ -1,440 +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 { validateTypeCompatibility } = require('../../../../../lib/dbschema-kit/validator/type-compatibility-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;
-}
-
-// Run cross-model first so `rel.target` is resolved to qualified form,
-// matching production validator ordering.
-function setupModels(models) {
-  validateCrossModel(models);
-  return models;
-}
-
-test('type-compat: belongsTo dengan source string:36 dan target string:36 → 0 issues', () => {
-  const models = setupModels(new Map([
-    ['category', makeModel('category', {
-      fields: { category_id: { type: 'string', length: 36, pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    })],
-    ['product', makeModel('product', {
-      fields: {
-        product_id: { type: 'string', length: 36, pk: true, notnull: true },
-        category_id: { type: 'string', length: 36, notnull: true }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'category',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })]
-  ]));
-  assert.deepStrictEqual(validateTypeCompatibility(models), []);
-});
-
-test('type-compat: integer ke string → fk-type-mismatch error', () => {
-  const models = setupModels(new Map([
-    ['category', makeModel('category', {
-      fields: { category_id: { type: 'string', length: 36, pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    })],
-    ['product', makeModel('product', {
-      fields: {
-        product_id: { type: 'string', length: 36, pk: true, notnull: true },
-        category_id: { type: 'integer', notnull: true }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'category',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'error');
-  assert.strictEqual(issues[0].code, 'fk-type-mismatch');
-  assert.strictEqual(issues[0].table, 'product');
-  assert.strictEqual(issues[0].field, 'category_id');
-  assert.strictEqual(issues[0].relation, 'category');
-  assert.match(
-    issues[0].message,
-    /^Table 'product': relation 'category' localKey 'category_id' type 'integer' does not match target field type 'string'$/
-  );
-});
-
-test('type-compat: string:36 ke string:50 → fk-length-mismatch warning', () => {
-  const models = setupModels(new Map([
-    ['category', makeModel('category', {
-      fields: { category_id: { type: 'string', length: 50, pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    })],
-    ['product', makeModel('product', {
-      fields: {
-        product_id: { type: 'string', length: 36, pk: true, notnull: true },
-        category_id: { type: 'string', length: 36 }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'category',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'warning');
-  assert.strictEqual(issues[0].code, 'fk-length-mismatch');
-  assert.match(issues[0].message, /length 36 does not match target length 50/);
-});
-
-test('type-compat: decimal:15,2 ke decimal:10,2 → fk-precision-mismatch warning', () => {
-  const models = setupModels(new Map([
-    ['account', makeModel('account', {
-      fields: { account_id: { type: 'decimal', precision: 10, scale: 2, pk: true, notnull: true } },
-      primaryKey: ['account_id']
-    })],
-    ['payment', makeModel('payment', {
-      fields: {
-        payment_id: { type: 'string', length: 36, pk: true, notnull: true },
-        account_ref: { type: 'decimal', precision: 15, scale: 2 }
-      },
-      primaryKey: ['payment_id'],
-      relations: {
-        account: {
-          type: 'belongsTo',
-          target: 'account',
-          localKey: 'account_ref',
-          references: 'account_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'warning');
-  assert.strictEqual(issues[0].code, 'fk-precision-mismatch');
-  assert.match(issues[0].message, /precision 15 does not match target precision 10/);
-});
-
-test('type-compat: decimal:10,2 ke decimal:10,4 → fk-scale-mismatch warning', () => {
-  const models = setupModels(new Map([
-    ['account', makeModel('account', {
-      fields: { account_id: { type: 'decimal', precision: 10, scale: 4, pk: true, notnull: true } },
-      primaryKey: ['account_id']
-    })],
-    ['payment', makeModel('payment', {
-      fields: {
-        payment_id: { type: 'string', length: 36, pk: true, notnull: true },
-        account_ref: { type: 'decimal', precision: 10, scale: 2 }
-      },
-      primaryKey: ['payment_id'],
-      relations: {
-        account: {
-          type: 'belongsTo',
-          target: 'account',
-          localKey: 'account_ref',
-          references: 'account_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'warning');
-  assert.strictEqual(issues[0].code, 'fk-scale-mismatch');
-  assert.match(issues[0].message, /scale 2 does not match target scale 4/);
-});
-
-test('type-compat: decimal mismatch precision dan scale sekaligus → 2 warnings', () => {
-  const models = setupModels(new Map([
-    ['account', makeModel('account', {
-      fields: { account_id: { type: 'decimal', precision: 10, scale: 4, pk: true, notnull: true } },
-      primaryKey: ['account_id']
-    })],
-    ['payment', makeModel('payment', {
-      fields: {
-        payment_id: { type: 'string', length: 36, pk: true, notnull: true },
-        account_ref: { type: 'decimal', precision: 15, scale: 2 }
-      },
-      primaryKey: ['payment_id'],
-      relations: {
-        account: {
-          type: 'belongsTo',
-          target: 'account',
-          localKey: 'account_ref',
-          references: 'account_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 2);
-  const codes = issues.map((i) => i.code).sort();
-  assert.deepStrictEqual(codes, ['fk-precision-mismatch', 'fk-scale-mismatch']);
-});
-
-test('type-compat: self-reference dengan tipe identik → 0 issues', () => {
-  const models = setupModels(new Map([
-    ['employee', makeModel('employee', {
-      fields: {
-        employee_id: { type: 'string', length: 36, pk: true, notnull: true },
-        manager_id: { type: 'string', length: 36 }
-      },
-      primaryKey: ['employee_id'],
-      relations: {
-        manager: {
-          type: 'belongsTo',
-          target: 'employee',
-          localKey: 'manager_id',
-          references: 'employee_id'
-        }
-      }
-    })]
-  ]));
-  assert.deepStrictEqual(validateTypeCompatibility(models), []);
-});
-
-test('type-compat: composite PK target — validate localKey vs salah satu PK column', () => {
-  // inventory_balance has composite PK (item_product_id, warehouse_id, period_date)
-  // stock_movement.item_product_id (integer) → inventory_balance.item_product_id (uuid)
-  // mismatch type detected on the referenced column
-  const models = setupModels(new Map([
-    ['inventory_balance', makeModel('inventory_balance', {
-      fields: {
-        item_product_id: { type: 'uuid', notnull: true },
-        warehouse_id: { type: 'uuid', notnull: true },
-        period_date: { type: 'date', notnull: true }
-      },
-      primaryKey: ['item_product_id', 'warehouse_id', 'period_date']
-    })],
-    ['stock_movement', makeModel('stock_movement', {
-      fields: {
-        stock_movement_id: { type: 'uuid', pk: true, notnull: true },
-        item_product_id: { type: 'integer' }
-      },
-      primaryKey: ['stock_movement_id'],
-      relations: {
-        balance: {
-          type: 'belongsTo',
-          target: 'inventory_balance',
-          localKey: 'item_product_id',
-          references: 'item_product_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'fk-type-mismatch');
-});
-
-test('type-compat: hasMany skip, tidak emit issue meskipun ada type mismatch di inverse', () => {
-  const models = setupModels(new Map([
-    ['supplier', makeModel('supplier', {
-      fields: { supplier_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['supplier_id'],
-      relations: {
-        // hasMany: FK column lives on child, not source. Skip type compat here.
-        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' }
-      },
-      primaryKey: ['stock_inbound_id']
-    })]
-  ]));
-  assert.deepStrictEqual(validateTypeCompatibility(models), []);
-});
-
-test('type-compat: hasOne skip (inverse side, FK lives on child)', () => {
-  const models = setupModels(new Map([
-    ['user', makeModel('user', {
-      fields: { user_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['user_id'],
-      relations: {
-        profile: {
-          type: 'hasOne',
-          target: 'user_profile',
-          localKey: 'user_id',
-          references: 'user_id'
-        }
-      }
-    })],
-    ['user_profile', makeModel('user_profile', {
-      fields: {
-        user_profile_id: { type: 'uuid', pk: true, notnull: true },
-        user_id: { type: 'uuid' }
-      },
-      primaryKey: ['user_profile_id']
-    })]
-  ]));
-  assert.deepStrictEqual(validateTypeCompatibility(models), []);
-});
-
-test('type-compat: empty Map return 0 issues', () => {
-  assert.deepStrictEqual(validateTypeCompatibility(new Map()), []);
-});
-
-test('type-compat: multi-schema qualified target ter-resolve dan divalidasi', () => {
-  const models = setupModels(new Map([
-    ['inventory.category', makeModel('category', {
-      schemaName: 'inventory',
-      fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    })],
-    ['inventory.product', makeModel('product', {
-      schemaName: 'inventory',
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'string', length: 36 }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'inventory.category',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'fk-type-mismatch');
-  assert.strictEqual(issues[0].table, 'inventory.product');
-});
-
-test('type-compat: Issue di-decorate dengan file path bila _filePath ada di model', () => {
-  const models = setupModels(new Map([
-    ['category', makeModel('category', {
-      fields: { category_id: { type: 'uuid', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    })],
-    ['product', makeModel('product', {
-      filePath: '/abs/schema/product.js',
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'integer' }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'category',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].file, '/abs/schema/product.js');
-});
-
-test('type-compat: type sama tapi salah satu sisi tidak specify length → emit length-mismatch warning', () => {
-  // string + length undefined vs string + length 36 → meaningful divergence
-  const models = setupModels(new Map([
-    ['category', makeModel('category', {
-      fields: { category_id: { type: 'string', length: 36, pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    })],
-    ['product', makeModel('product', {
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'string' } // length omitted
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'category',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })]
-  ]));
-  const issues = validateTypeCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'fk-length-mismatch');
-  assert.match(issues[0].message, /length \(unspecified\) does not match target length 36/);
-});
-
-test('type-compat: kedua sisi tidak specify length → 0 issues', () => {
-  const models = setupModels(new Map([
-    ['category', makeModel('category', {
-      fields: { category_id: { type: 'string', pk: true, notnull: true } },
-      primaryKey: ['category_id']
-    })],
-    ['product', makeModel('product', {
-      fields: {
-        product_id: { type: 'uuid', pk: true, notnull: true },
-        category_id: { type: 'string' }
-      },
-      primaryKey: ['product_id'],
-      relations: {
-        category: {
-          type: 'belongsTo',
-          target: 'category',
-          localKey: 'category_id',
-          references: 'category_id'
-        }
-      }
-    })]
-  ]));
-  assert.deepStrictEqual(validateTypeCompatibility(models), []);
-});

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

@@ -1,172 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const {
-  SCHEMA_VERSION,
-  reportHuman,
-  reportJson,
-  getExitCode
-} = require('../../../../../lib/dbschema-kit/validator/validator-reporter');
-
-function captureConsole(fn) {
-  const stdoutLines = [];
-  const stderrLines = [];
-  const origLog = console.log;
-  const origError = console.error;
-  const origWarn = console.warn;
-  console.log = (...args) => stdoutLines.push(args.join(' '));
-  console.error = (...args) => stderrLines.push(args.join(' '));
-  console.warn = (...args) => stderrLines.push(args.join(' '));
-  try {
-    fn();
-  } finally {
-    console.log = origLog;
-    console.error = origError;
-    console.warn = origWarn;
-  }
-  return { stdoutLines, stderrLines };
-}
-
-// =====================================================
-// reportJson
-// =====================================================
-
-test('reportJson: empty issues returns valid report with zero counts', () => {
-  const report = reportJson([], 5);
-  assert.strictEqual(report.schemaVersion, SCHEMA_VERSION);
-  assert.deepStrictEqual(report.summary, {
-    modelsLoaded: 5,
-    errorCount: 0,
-    warningCount: 0
-  });
-  assert.deepStrictEqual(report.issues, []);
-});
-
-test('reportJson: issues counted by severity in summary', () => {
-  const issues = [
-    { severity: 'error', code: 'a', message: 'm1' },
-    { severity: 'error', code: 'b', message: 'm2' },
-    { severity: 'warning', code: 'c', message: 'm3' }
-  ];
-  const report = reportJson(issues, 10);
-  assert.strictEqual(report.summary.modelsLoaded, 10);
-  assert.strictEqual(report.summary.errorCount, 2);
-  assert.strictEqual(report.summary.warningCount, 1);
-  assert.strictEqual(report.issues.length, 3);
-});
-
-test('reportJson: optional fields (file, table, field, relation) only emitted when present', () => {
-  const issues = [
-    {
-      severity: 'error',
-      code: 'a',
-      message: 'm1',
-      table: 'demo.product',
-      relation: 'supplier'
-    }
-  ];
-  const report = reportJson(issues, 1);
-  const issue = report.issues[0];
-  assert.strictEqual(issue.table, 'demo.product');
-  assert.strictEqual(issue.relation, 'supplier');
-  assert.ok(!('field' in issue), 'field should be omitted when undefined');
-  assert.ok(!('file' in issue), 'file should be omitted when undefined');
-});
-
-test('reportJson: output is JSON-serialisable', () => {
-  const issues = [{ severity: 'error', code: 'a', message: 'm' }];
-  const report = reportJson(issues, 1);
-  const serialised = JSON.stringify(report);
-  const parsed = JSON.parse(serialised);
-  assert.deepStrictEqual(parsed, report);
-});
-
-// =====================================================
-// getExitCode
-// =====================================================
-
-test('getExitCode: 0 issues → exit 0', () => {
-  assert.strictEqual(getExitCode([], false), 0);
-  assert.strictEqual(getExitCode([], true), 0);
-});
-
-test('getExitCode: at least one error → exit 1', () => {
-  const issues = [{ severity: 'error', code: 'a', message: 'm' }];
-  assert.strictEqual(getExitCode(issues, false), 1);
-  assert.strictEqual(getExitCode(issues, true), 1);
-});
-
-test('getExitCode: warning only + strictWarnings=false → exit 0', () => {
-  const issues = [{ severity: 'warning', code: 'a', message: 'm' }];
-  assert.strictEqual(getExitCode(issues, false), 0);
-});
-
-test('getExitCode: warning only + strictWarnings=true → exit 1', () => {
-  const issues = [{ severity: 'warning', code: 'a', message: 'm' }];
-  assert.strictEqual(getExitCode(issues, true), 1);
-});
-
-test('getExitCode: error + warning → exit 1 regardless of strictWarnings', () => {
-  const issues = [
-    { severity: 'error', code: 'a', message: 'm1' },
-    { severity: 'warning', code: 'b', message: 'm2' }
-  ];
-  assert.strictEqual(getExitCode(issues, false), 1);
-  assert.strictEqual(getExitCode(issues, true), 1);
-});
-
-// =====================================================
-// reportHuman
-// =====================================================
-
-test('reportHuman: 0 issues prints summary "N models loaded, 0 errors."', () => {
-  const { stdoutLines } = captureConsole(() => reportHuman([], 12));
-  // Last non-blank stdout line is the summary
-  const summary = stdoutLines.filter((line) => line !== '').pop();
-  assert.strictEqual(summary, '12 models loaded, 0 errors.');
-});
-
-test('reportHuman: 1 model uses singular noun', () => {
-  const { stdoutLines } = captureConsole(() => reportHuman([], 1));
-  const summary = stdoutLines.filter((line) => line !== '').pop();
-  assert.strictEqual(summary, '1 model loaded, 0 errors.');
-});
-
-test('reportHuman: errors printed to stderr with cross prefix', () => {
-  const issues = [
-    { severity: 'error', code: 'a', message: 'something broke' }
-  ];
-  const { stderrLines } = captureConsole(() => reportHuman(issues, 3));
-  const issueLine = stderrLines.find((line) => line.startsWith('✗'));
-  assert.strictEqual(issueLine, '✗ something broke');
-  const summary = stderrLines.filter((line) => line !== '').pop();
-  assert.strictEqual(summary, '3 models loaded, 1 error.');
-});
-
-test('reportHuman: warnings printed with warn prefix and counted in summary', () => {
-  const issues = [
-    { severity: 'warning', code: 'a', message: 'be careful' },
-    { severity: 'warning', code: 'b', message: 'check that' }
-  ];
-  const { stdoutLines, stderrLines } = captureConsole(() => reportHuman(issues, 5));
-  // Warnings go to stderr (alongside errors)
-  assert.ok(stderrLines.some((line) => line === '⚠ be careful'));
-  assert.ok(stderrLines.some((line) => line === '⚠ check that'));
-  // No errors → summary goes to stdout
-  const summary = stdoutLines.filter((line) => line !== '').pop();
-  assert.strictEqual(summary, '5 models loaded, 0 errors, 2 warnings.');
-});
-
-test('reportHuman: mixed error + warning — both prefixes printed, summary includes both counts', () => {
-  const issues = [
-    { severity: 'error', code: 'a', message: 'broke' },
-    { severity: 'warning', code: 'b', message: 'risky' }
-  ];
-  const { stderrLines } = captureConsole(() => reportHuman(issues, 4));
-  assert.ok(stderrLines.some((line) => line === '✗ broke'));
-  assert.ok(stderrLines.some((line) => line === '⚠ risky'));
-  const summary = stderrLines.filter((line) => line !== '').pop();
-  assert.strictEqual(summary, '4 models loaded, 1 error, 1 warning.');
-});