@restforgejs/platform 4.2.8 → 4.3.2

package/generators/tests/unit/lib/dbschema-kit/validator/enhanced-validate-integration.test.js

@@ -1,390 +0,0 @@
-'use strict';
-
-/**
- * End-to-end integration tests for dbschema:validate CLI.
- *
- * Drives the CLI as a subprocess against on-disk fixture folders so the
- * full pipeline (load → cross-model → type-compat → circular → check-compat
- * → naming) is exercised, including the reporter (human + JSON) and
- * exit-code semantics.
- *
- * Each test writes its fixture into a temp directory via fs.mkdtempSync to
- * keep tests isolated. No shared state between tests.
- */
-
-const test = require('node:test');
-const assert = require('node:assert');
-const fs = require('node:fs');
-const os = require('node:os');
-const path = require('node:path');
-const { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..');
-const CLI_SCRIPT = path.join(REPO_ROOT, 'cli', 'dbschema-validate.js');
-
-function runCli(args, options = {}) {
-  const result = spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-    encoding: 'utf8',
-    env: { ...process.env, NO_COLOR: '1' },
-    ...options
-  });
-  return {
-    stdout: result.stdout || '',
-    stderr: result.stderr || '',
-    code: result.status
-  };
-}
-
-function mktmp(name) {
-  return fs.mkdtempSync(path.join(os.tmpdir(), `dbsk-validate-int-${name}-`));
-}
-
-function writeSchema(dir, fileName, contents) {
-  fs.writeFileSync(path.join(dir, fileName), contents, 'utf8');
-}
-
-// =====================================================
-// Clean schema
-// =====================================================
-
-test('integration: clean schema → exit 0, 0 issues di JSON', () => {
-  const dir = mktmp('clean');
-  try {
-    writeSchema(dir, 'category.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('category', {
-        fields: { category_id: 'string:36 pk', name: 'string:100 notnull' }
-      });
-    `);
-    writeSchema(dir, 'product.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('product', {
-        fields: {
-          product_id: 'string:36 pk',
-          category_id: 'string:36 notnull',
-          price: 'decimal:15,2'
-        },
-        relations: {
-          category: { type: 'belongsTo', target: 'category', localKey: 'category_id', references: 'category_id' }
-        },
-        checks: [{ field: 'price', gte: 0 }]
-      });
-    `);
-
-    const result = runCli([dir, '--format', 'json']);
-    assert.strictEqual(result.code, 0, `expected exit 0. stderr: ${result.stderr}`);
-    const report = JSON.parse(result.stdout);
-    assert.strictEqual(report.schemaVersion, '1.0');
-    assert.strictEqual(report.summary.modelsLoaded, 2);
-    assert.strictEqual(report.summary.errorCount, 0);
-    assert.strictEqual(report.summary.warningCount, 0);
-    assert.deepStrictEqual(report.issues, []);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// =====================================================
-// Cross-model + type-compat in same run
-// =====================================================
-
-test('integration: schema dengan cross-model error dan FK type-mismatch → kedua kategori ter-collect', () => {
-  const dir = mktmp('multi-cat');
-  try {
-    writeSchema(dir, 'category.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('category', {
-        fields: { category_id: 'string:36 pk' }
-      });
-    `);
-    writeSchema(dir, 'product.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('product', {
-        fields: {
-          product_id: 'string:36 pk',
-          category_id: 'integer notnull',   // FK type mismatch with target
-          missing_ref: 'string:36'
-        },
-        relations: {
-          category: { type: 'belongsTo', target: 'category', localKey: 'category_id', references: 'category_id' },
-          missing: { type: 'belongsTo', target: 'nonexistent_table', localKey: 'missing_ref', references: 'id' }
-        }
-      });
-    `);
-
-    const result = runCli([dir, '--format', 'json']);
-    assert.strictEqual(result.code, 1);
-
-    const report = JSON.parse(result.stdout);
-    const codes = report.issues.map((i) => i.code).sort();
-    assert.ok(codes.includes('relation-unknown-target'), `missing relation-unknown-target. codes=${codes.join(',')}`);
-    assert.ok(codes.includes('fk-type-mismatch'), `missing fk-type-mismatch. codes=${codes.join(',')}`);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// =====================================================
-// Circular relation
-// =====================================================
-
-test('integration: mandatory cycle A ↔ B → circular-mandatory-relation error', () => {
-  const dir = mktmp('cycle');
-  try {
-    writeSchema(dir, 'a.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('a', {
-        fields: { a_id: 'string:36 pk', b_id: 'string:36 notnull' },
-        relations: { to_b: { type: 'belongsTo', target: 'b', localKey: 'b_id', references: 'b_id' } }
-      });
-    `);
-    writeSchema(dir, 'b.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('b', {
-        fields: { b_id: 'string:36 pk', a_id: 'string:36 notnull' },
-        relations: { to_a: { type: 'belongsTo', target: 'a', localKey: 'a_id', references: 'a_id' } }
-      });
-    `);
-
-    const result = runCli([dir, '--format', 'json']);
-    assert.strictEqual(result.code, 1);
-
-    const report = JSON.parse(result.stdout);
-    const cycle = report.issues.find((i) => i.code === 'circular-mandatory-relation');
-    assert.ok(cycle, 'expected circular-mandatory-relation issue');
-    assert.match(cycle.message, /a → b → a/);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// =====================================================
-// Check constraint compatibility
-// =====================================================
-
-test('integration: check constraint dengan op-type incompat → check-op-incompatible-with-type error', () => {
-  const dir = mktmp('check');
-  try {
-    writeSchema(dir, 'user.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('user', {
-        fields: { user_id: 'string:36 pk', is_active: 'boolean' },
-        checks: [{ field: 'is_active', gt: 0 }]
-      });
-    `);
-
-    const result = runCli([dir, '--format', 'json']);
-    assert.strictEqual(result.code, 1);
-
-    const report = JSON.parse(result.stdout);
-    const issue = report.issues.find((i) => i.code === 'check-op-incompatible-with-type');
-    assert.ok(issue, 'expected check-op-incompatible-with-type issue');
-    assert.strictEqual(issue.field, 'is_active');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// =====================================================
-// Naming convention (opt-in via --dialect)
-// =====================================================
-
-test('integration: schema "order" tanpa --dialect → 0 warning naming', () => {
-  const dir = mktmp('naming-default');
-  try {
-    writeSchema(dir, 'order.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('order', {
-        fields: { order_id: 'string:36 pk', total: 'decimal:15,2' }
-      });
-    `);
-
-    const result = runCli([dir, '--format', 'json', '--strict']);
-    assert.strictEqual(result.code, 0);
-
-    const report = JSON.parse(result.stdout);
-    const namingIssues = report.issues.filter((i) =>
-      i.code.startsWith('reserved-keyword') || i.code === 'identifier-too-long'
-    );
-    assert.strictEqual(namingIssues.length, 0, 'naming check must stay off without --dialect');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('integration: schema "order" dengan --dialect postgres --strict → reserved-keyword-table warning', () => {
-  const dir = mktmp('naming-pg');
-  try {
-    writeSchema(dir, 'order.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('order', {
-        fields: { order_id: 'string:36 pk', total: 'decimal:15,2' }
-      });
-    `);
-
-    const result = runCli([dir, '--format', 'json', '--dialect', 'postgres', '--strict']);
-    assert.strictEqual(result.code, 0, 'warning alone must not exit 1');
-
-    const report = JSON.parse(result.stdout);
-    const warning = report.issues.find((i) => i.code === 'reserved-keyword-table');
-    assert.ok(warning, 'expected reserved-keyword-table warning');
-    assert.strictEqual(warning.severity, 'warning');
-    assert.strictEqual(warning.table, 'order');
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// =====================================================
-// Strict / strict-warnings exit-code semantics
-// =====================================================
-
-test('integration: hanya warning + default → exit 0 (warning di-suppress)', () => {
-  const dir = mktmp('warn-default');
-  try {
-    // FK length mismatch → warning
-    writeSchema(dir, 'cat.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('cat', {
-        fields: { cat_id: 'string:50 pk' }
-      });
-    `);
-    writeSchema(dir, 'prod.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('prod', {
-        fields: { prod_id: 'string:36 pk', cat_id: 'string:36 notnull' },
-        relations: { cat: { type: 'belongsTo', target: 'cat', localKey: 'cat_id', references: 'cat_id' } }
-      });
-    `);
-
-    const result = runCli([dir]);
-    assert.strictEqual(result.code, 0, `expected exit 0. stderr: ${result.stderr}`);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('integration: hanya warning + --strict-warnings → exit 1', () => {
-  const dir = mktmp('warn-strict');
-  try {
-    writeSchema(dir, 'cat.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('cat', {
-        fields: { cat_id: 'string:50 pk' }
-      });
-    `);
-    writeSchema(dir, 'prod.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('prod', {
-        fields: { prod_id: 'string:36 pk', cat_id: 'string:36 notnull' },
-        relations: { cat: { type: 'belongsTo', target: 'cat', localKey: 'cat_id', references: 'cat_id' } }
-      });
-    `);
-
-    const result = runCli([dir, '--strict-warnings']);
-    assert.strictEqual(result.code, 1, `--strict-warnings must elevate warning to exit 1`);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// =====================================================
-// JSON contract — all 4 validator categories in one report
-// =====================================================
-
-test('integration: schema dengan violation di 4 kategori → semua ter-emit di JSON report', () => {
-  const dir = mktmp('all-cats');
-  try {
-    writeSchema(dir, 'a.js', `
-      'use strict';
-      // Mandatory self-reference → circular-mandatory-relation
-      module.exports = ({ defineModel }) => defineModel('a_self', {
-        fields: { a_id: 'string:36 pk', parent_id: 'string:36 notnull' },
-        relations: { parent: { type: 'belongsTo', target: 'a_self', localKey: 'parent_id', references: 'a_id' } }
-      });
-    `);
-    writeSchema(dir, 'b.js', `
-      'use strict';
-      // Unknown FK target → relation-unknown-target
-      module.exports = ({ defineModel }) => defineModel('b_orphan', {
-        fields: { b_id: 'string:36 pk', x_id: 'string:36 notnull' },
-        relations: { x: { type: 'belongsTo', target: 'nonexistent', localKey: 'x_id', references: 'id' } }
-      });
-    `);
-    writeSchema(dir, 'c.js', `
-      'use strict';
-      // FK type mismatch with d_master + check-op incompat
-      module.exports = ({ defineModel }) => defineModel('c_data', {
-        fields: {
-          c_id: 'string:36 pk',
-          d_id: 'integer notnull',   // mismatch: target is string:36
-          flag: 'boolean'
-        },
-        relations: { d: { type: 'belongsTo', target: 'd_master', localKey: 'd_id', references: 'd_id' } },
-        checks: [{ field: 'flag', gt: 0 }]
-      });
-    `);
-    writeSchema(dir, 'd.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('d_master', {
-        fields: { d_id: 'string:36 pk' }
-      });
-    `);
-
-    const result = runCli([dir, '--format', 'json']);
-    assert.strictEqual(result.code, 1);
-
-    const report = JSON.parse(result.stdout);
-    const codes = new Set(report.issues.map((i) => i.code));
-
-    assert.ok(codes.has('relation-unknown-target'), 'expected cross-model rule');
-    assert.ok(codes.has('fk-type-mismatch'), 'expected type-compat rule');
-    assert.ok(codes.has('circular-mandatory-relation'), 'expected circular rule');
-    assert.ok(codes.has('check-op-incompatible-with-type'), 'expected check-compat rule');
-
-    // JSON contract sanity check
-    for (const issue of report.issues) {
-      assert.ok(['error', 'warning'].includes(issue.severity));
-      assert.strictEqual(typeof issue.code, 'string');
-      assert.strictEqual(typeof issue.message, 'string');
-    }
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-// =====================================================
-// Usage errors (exit 2)
-// =====================================================
-
-test('integration: --dialect invalid → exit 2 dengan usage error', () => {
-  const dir = mktmp('usage-dialect');
-  try {
-    writeSchema(dir, 'a.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('a', { fields: { a_id: 'string:36 pk' } });
-    `);
-
-    const result = runCli([dir, '--dialect', 'mongodb']);
-    assert.strictEqual(result.code, 2);
-    assert.match(result.stderr, /Invalid dialect 'mongodb'/);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-test('integration: --format invalid → exit 2 dengan usage error', () => {
-  const dir = mktmp('usage-format');
-  try {
-    writeSchema(dir, 'a.js', `
-      'use strict';
-      module.exports = ({ defineModel }) => defineModel('a', { fields: { a_id: 'string:36 pk' } });
-    `);
-
-    const result = runCli([dir, '--format', 'xml']);
-    assert.strictEqual(result.code, 2);
-    assert.match(result.stderr, /Invalid format 'xml'/);
-  } finally {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});

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

@@ -1,306 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { validateNamingConventions } = require('../../../../../lib/dbschema-kit/validator/naming-convention-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 mapOf(model) {
-  const map = new Map();
-  map.set(model.qualifiedName, model);
-  return map;
-}
-
-// =====================================================
-// No-op scenarios
-// =====================================================
-
-test('naming: no dialect → 0 issues', () => {
-  const models = mapOf(makeModel('order', {
-    fields: { order_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  assert.deepStrictEqual(validateNamingConventions(models, null), []);
-  assert.deepStrictEqual(validateNamingConventions(models, undefined), []);
-  assert.deepStrictEqual(validateNamingConventions(models, ''), []);
-});
-
-test('naming: unsupported dialect → 0 issues', () => {
-  const models = mapOf(makeModel('order', {
-    fields: { order_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  assert.deepStrictEqual(validateNamingConventions(models, 'mongodb'), []);
-});
-
-test('naming: empty Map → 0 issues', () => {
-  assert.deepStrictEqual(validateNamingConventions(new Map(), 'postgres'), []);
-});
-
-test('naming: clean schema (no reserved, normal length) → 0 issues', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      product_name: { type: 'string', length: 100 }
-    }
-  }));
-  assert.deepStrictEqual(validateNamingConventions(models, 'postgres'), []);
-});
-
-// =====================================================
-// Reserved keyword — table
-// =====================================================
-
-test('naming: postgres table named "order" → reserved-keyword-table warning', () => {
-  const models = mapOf(makeModel('order', {
-    fields: { order_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'postgres');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'warning');
-  assert.strictEqual(issues[0].code, 'reserved-keyword-table');
-  assert.match(issues[0].message, /Table name 'order' is a reserved keyword in postgres/);
-});
-
-test('naming: mysql table named "key" → reserved-keyword-table warning', () => {
-  const models = mapOf(makeModel('key', {
-    fields: { key_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'mysql');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'reserved-keyword-table');
-});
-
-test('naming: oracle table named "user" → reserved-keyword-table warning', () => {
-  const models = mapOf(makeModel('user', {
-    fields: { user_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'oracle');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'reserved-keyword-table');
-});
-
-test('naming: sqlite table named "transaction" → reserved-keyword-table warning', () => {
-  const models = mapOf(makeModel('transaction', {
-    fields: { transaction_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'sqlite');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'reserved-keyword-table');
-});
-
-test('naming: case-insensitive comparison — table "ORDER" still flagged', () => {
-  // dbschema-kit normally enforces snake_case at single-model validation, so
-  // "ORDER" would never make it past defineModel. We still test the
-  // case-insensitive comparison here to guarantee the check is robust if
-  // upstream rules ever relax.
-  const models = mapOf(makeModel('ORDER', {
-    fields: { order_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'postgres');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'reserved-keyword-table');
-});
-
-// =====================================================
-// Reserved keyword — field
-// =====================================================
-
-test('naming: mysql field named "key" → reserved-keyword-field warning', () => {
-  const models = mapOf(makeModel('lookup', {
-    fields: {
-      lookup_id: { type: 'uuid', pk: true, notnull: true },
-      key: { type: 'string', length: 50 }
-    }
-  }));
-  const issues = validateNamingConventions(models, 'mysql');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'warning');
-  assert.strictEqual(issues[0].code, 'reserved-keyword-field');
-  assert.strictEqual(issues[0].field, 'key');
-  assert.match(issues[0].message, /reserved keyword in mysql/);
-});
-
-test('naming: postgres field named "user" → reserved-keyword-field warning', () => {
-  const models = mapOf(makeModel('audit_log', {
-    fields: {
-      audit_log_id: { type: 'uuid', pk: true, notnull: true },
-      user: { type: 'string', length: 50 }
-    }
-  }));
-  const issues = validateNamingConventions(models, 'postgres');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'reserved-keyword-field');
-  assert.strictEqual(issues[0].field, 'user');
-});
-
-test('naming: oracle field named "level" → reserved-keyword-field warning', () => {
-  const models = mapOf(makeModel('priority', {
-    fields: {
-      priority_id: { type: 'uuid', pk: true, notnull: true },
-      level: { type: 'integer' }
-    }
-  }));
-  const issues = validateNamingConventions(models, 'oracle');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'reserved-keyword-field');
-});
-
-// =====================================================
-// Identifier length limit
-// =====================================================
-
-test('naming: oracle table name 130 chars exceeds 128 limit → identifier-too-long warning', () => {
-  const longName = 't'.repeat(130);
-  const models = mapOf(makeModel(longName, {
-    fields: { id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'oracle');
-  // Both an identifier-too-long for the table itself
-  assert.ok(issues.some((i) => i.code === 'identifier-too-long' && !i.field));
-  const tableLengthIssue = issues.find((i) => i.code === 'identifier-too-long' && !i.field);
-  assert.match(tableLengthIssue.message, /length 130, exceeds oracle limit 128/);
-});
-
-test('naming: postgres table name 65 chars exceeds 63 limit → identifier-too-long warning', () => {
-  const longName = 't'.repeat(65);
-  const models = mapOf(makeModel(longName, {
-    fields: { id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'postgres');
-  const tooLong = issues.find((i) => i.code === 'identifier-too-long' && !i.field);
-  assert.ok(tooLong, 'expected identifier-too-long warning for table');
-  assert.match(tooLong.message, /length 65, exceeds postgres limit 63/);
-});
-
-test('naming: mysql field name 70 chars exceeds 64 limit → identifier-too-long warning', () => {
-  const longField = 'f'.repeat(70);
-  const models = mapOf(makeModel('payment', {
-    fields: {
-      payment_id: { type: 'uuid', pk: true, notnull: true },
-      [longField]: { type: 'string', length: 100 }
-    }
-  }));
-  const issues = validateNamingConventions(models, 'mysql');
-  const tooLong = issues.find((i) => i.code === 'identifier-too-long' && i.field === longField);
-  assert.ok(tooLong, 'expected identifier-too-long warning for field');
-  assert.match(tooLong.message, /length 70, exceeds mysql limit 64/);
-});
-
-test('naming: sqlite table 100 chars → identifier-too-long warning at sqlite limit', () => {
-  // SQLite is technically permissive but lib/dbschema-kit/dialect/sqlite.js
-  // sets maxIdentifierLength: 63 for cross-dialect portability.
-  const longName = 't'.repeat(100);
-  const models = mapOf(makeModel(longName, {
-    fields: { id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'sqlite');
-  assert.ok(issues.some((i) => i.code === 'identifier-too-long' && !i.field));
-});
-
-// =====================================================
-// Multiple issues per model
-// =====================================================
-
-test('naming: reserved table + reserved field → 2 warnings', () => {
-  const models = mapOf(makeModel('order', {
-    fields: {
-      order_id: { type: 'uuid', pk: true, notnull: true },
-      group: { type: 'string', length: 50 }
-    }
-  }));
-  const issues = validateNamingConventions(models, 'postgres');
-  assert.strictEqual(issues.length, 2);
-  const codes = issues.map((i) => i.code).sort();
-  assert.deepStrictEqual(codes, ['reserved-keyword-field', 'reserved-keyword-table']);
-});
-
-test('naming: reserved table + table also too long → 2 warnings (table)', () => {
-  // Combine a reserved token in a too-long identifier
-  const longName = 'order' + 'x'.repeat(60); // 65 chars, "order" prefix isn't a full-token match
-  const models = mapOf(makeModel(longName, {
-    fields: { id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  // Only identifier-too-long: 'orderxxx...' is not a reserved keyword
-  // (case-insensitive full-token match, not substring).
-  const issues = validateNamingConventions(models, 'postgres');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'identifier-too-long');
-});
-
-// =====================================================
-// Decoration
-// =====================================================
-
-test('naming: Issue di-decorate dengan file path bila _filePath ada di model', () => {
-  const models = mapOf(makeModel('order', {
-    filePath: '/abs/schema/order.js',
-    fields: { order_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'postgres');
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].file, '/abs/schema/order.js');
-  assert.strictEqual(issues[0].table, 'order');
-});
-
-// =====================================================
-// Multi-table
-// =====================================================
-
-test('naming: 2 tabel masing-masing punya reserved table → 2 warnings', () => {
-  const models = new Map();
-  models.set('order', makeModel('order', {
-    fields: { order_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  models.set('group', makeModel('group', {
-    fields: { group_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  const issues = validateNamingConventions(models, 'postgres');
-  assert.strictEqual(issues.length, 2);
-  for (const issue of issues) {
-    assert.strictEqual(issue.code, 'reserved-keyword-table');
-  }
-});
-
-// =====================================================
-// Non-reserved common identifiers
-// =====================================================
-
-test('naming: common safe identifiers (id, name, created_at, updated_at) not flagged in postgres', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      id: { type: 'uuid', pk: true, notnull: true },
-      name: { type: 'string', length: 100 },
-      created_at: { type: 'timestamp' },
-      updated_at: { type: 'timestamp' }
-    }
-  }));
-  assert.deepStrictEqual(validateNamingConventions(models, 'postgres'), []);
-});