@restforgejs/platform 4.1.1 → 4.3.1

package/generators/tests/unit/lib/dbschema-kit/statement-splitter.test.js

@@ -1,165 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { splitStatements } = require('../../../../lib/dbschema-kit/statement-splitter');
-
-test('splitter: DDL multi-statement Postgres → array tanpa comment dan blank line', () => {
-  const ddl = [
-    '-- ============================================================',
-    '-- Generated by dbschema:generate-ddl',
-    '-- ============================================================',
-    '',
-    '-- DROP section',
-    'DROP TABLE IF EXISTS supplier CASCADE;',
-    'DROP TABLE IF EXISTS category CASCADE;',
-    '',
-    '-- CREATE TABLE section',
-    'CREATE TABLE category (',
-    '    category_id UUID NOT NULL,',
-    '    PRIMARY KEY (category_id)',
-    ');'
-  ].join('\n');
-
-  const result = splitStatements(ddl, 'postgres');
-  assert.strictEqual(result.length, 3);
-  assert.strictEqual(result[0], 'DROP TABLE IF EXISTS supplier CASCADE');
-  assert.strictEqual(result[1], 'DROP TABLE IF EXISTS category CASCADE');
-  assert.match(result[2], /^CREATE TABLE category \(/);
-  assert.match(result[2], /PRIMARY KEY \(category_id\)/);
-  // tidak boleh berakhir dengan ;
-  assert.ok(!result[2].endsWith(';'));
-});
-
-test('splitter: trailing semicolon dihapus dari setiap statement', () => {
-  const ddl = 'CREATE INDEX idx_a ON foo (a);\nCREATE INDEX idx_b ON foo (b);\n';
-  const result = splitStatements(ddl, 'postgres');
-  assert.strictEqual(result.length, 2);
-  assert.strictEqual(result[0], 'CREATE INDEX idx_a ON foo (a)');
-  assert.strictEqual(result[1], 'CREATE INDEX idx_b ON foo (b)');
-});
-
-test('splitter: skip baris comment (-- ...)', () => {
-  const ddl = [
-    '-- comment line 1',
-    'CREATE TABLE foo (id UUID);',
-    '-- comment line 2',
-    'CREATE TABLE bar (id UUID);'
-  ].join('\n');
-
-  const result = splitStatements(ddl, 'postgres');
-  assert.strictEqual(result.length, 2);
-  assert.strictEqual(result[0], 'CREATE TABLE foo (id UUID)');
-  assert.strictEqual(result[1], 'CREATE TABLE bar (id UUID)');
-});
-
-test('splitter: skip baris kosong sebagai separator antar statement', () => {
-  const ddl = [
-    'CREATE TABLE foo (id UUID);',
-    '',
-    '',
-    'CREATE TABLE bar (id UUID);'
-  ].join('\n');
-
-  const result = splitStatements(ddl, 'postgres');
-  assert.strictEqual(result.length, 2);
-});
-
-test('splitter: multi-line CREATE TABLE tetap utuh sebagai satu element', () => {
-  const ddl = [
-    'CREATE TABLE category (',
-    '    category_id UUID NOT NULL,',
-    '    category_name VARCHAR(100) NOT NULL,',
-    '    CONSTRAINT pk_category PRIMARY KEY (category_id)',
-    ');'
-  ].join('\n');
-
-  const result = splitStatements(ddl, 'postgres');
-  assert.strictEqual(result.length, 1);
-  assert.match(result[0], /^CREATE TABLE category \(/);
-  assert.match(result[0], /category_id UUID NOT NULL,/);
-  assert.match(result[0], /CONSTRAINT pk_category PRIMARY KEY \(category_id\)/);
-  assert.ok(!result[0].endsWith(';'));
-});
-
-test('splitter: Oracle PL/SQL block treated as single statement, terminator / di-strip', () => {
-  const ddl = [
-    'BEGIN',
-    "    EXECUTE IMMEDIATE 'DROP TABLE category CASCADE CONSTRAINTS';",
-    'EXCEPTION',
-    '    WHEN OTHERS THEN',
-    '        IF SQLCODE != -942 THEN RAISE; END IF;',
-    'END;',
-    '/',
-    'BEGIN',
-    "    EXECUTE IMMEDIATE 'DROP TABLE supplier CASCADE CONSTRAINTS';",
-    'EXCEPTION',
-    '    WHEN OTHERS THEN',
-    '        IF SQLCODE != -942 THEN RAISE; END IF;',
-    'END;',
-    '/'
-  ].join('\n');
-
-  const result = splitStatements(ddl, 'oracle');
-  assert.strictEqual(result.length, 2);
-  assert.match(result[0], /^BEGIN/);
-  assert.match(result[0], /EXECUTE IMMEDIATE 'DROP TABLE category/);
-  assert.match(result[0], /END;$/);
-  assert.ok(!result[0].includes('\n/'), 'terminator / harus dihapus');
-  assert.ok(!result[0].endsWith('/'));
-  assert.match(result[1], /EXECUTE IMMEDIATE 'DROP TABLE supplier/);
-});
-
-test('splitter: MySQL identifier dengan backtick tetap intact dalam statement', () => {
-  const ddl = [
-    'CREATE TABLE `order` (',
-    '    `id` BIGINT NOT NULL,',
-    '    PRIMARY KEY (`id`)',
-    ');'
-  ].join('\n');
-
-  const result = splitStatements(ddl, 'mysql');
-  assert.strictEqual(result.length, 1);
-  assert.match(result[0], /CREATE TABLE `order`/);
-  assert.match(result[0], /`id` BIGINT NOT NULL/);
-  assert.match(result[0], /PRIMARY KEY \(`id`\)/);
-});
-
-test('splitter: input kosong → array kosong', () => {
-  assert.deepStrictEqual(splitStatements('', 'postgres'), []);
-  assert.deepStrictEqual(splitStatements('   \n\n\n', 'postgres'), []);
-  assert.deepStrictEqual(splitStatements('-- comment only\n\n', 'postgres'), []);
-});
-
-test('splitter: Oracle mixed PL/SQL + CREATE TABLE statements', () => {
-  const ddl = [
-    'BEGIN',
-    "    EXECUTE IMMEDIATE 'DROP TABLE category CASCADE CONSTRAINTS';",
-    'EXCEPTION',
-    '    WHEN OTHERS THEN',
-    '        IF SQLCODE != -942 THEN RAISE; END IF;',
-    'END;',
-    '/',
-    '',
-    '-- CREATE TABLE section',
-    'CREATE TABLE category (',
-    '    category_id VARCHAR2(36) NOT NULL,',
-    '    CONSTRAINT pk_category PRIMARY KEY (category_id)',
-    ');'
-  ].join('\n');
-
-  const result = splitStatements(ddl, 'oracle');
-  assert.strictEqual(result.length, 2);
-  assert.match(result[0], /^BEGIN/);
-  assert.match(result[1], /^CREATE TABLE category/);
-});
-
-test('splitter: invalid dialect → throw error', () => {
-  assert.throws(() => splitStatements('SELECT 1;', 'mssql'), /invalid dialect/);
-});
-
-test('splitter: ddl bukan string → throw error', () => {
-  assert.throws(() => splitStatements(null, 'postgres'), /must be a string/);
-  assert.throws(() => splitStatements(42, 'postgres'), /must be a string/);
-});

package/generators/tests/unit/lib/dbschema-kit/topological-sort.test.js

@@ -1,135 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { topologicalSort } = require('../../../../lib/dbschema-kit/topological-sort');
-
-function makeModel(tableName, relations = {}) {
-  const rels = {};
-  for (const [relName, target] of Object.entries(relations)) {
-    rels[relName] = {
-      type: 'belongsTo',
-      target,
-      localKey: `${target}_id`,
-      references: `${target}_id`
-    };
-  }
-  return { tableName, fields: {}, primaryKey: [`${tableName}_id`], indexes: [], uniques: [], relations: rels, checks: [] };
-}
-
-test('topological-sort: linear dependency A → B → C menghasilkan urutan [A, B, C]', () => {
-  const models = new Map();
-  models.set('a', makeModel('a'));
-  models.set('b', makeModel('b', { parentA: 'a' }));
-  models.set('c', makeModel('c', { parentB: 'b' }));
-
-  const order = topologicalSort(models);
-  assert.deepStrictEqual(order, ['a', 'b', 'c']);
-});
-
-test('topological-sort: multi-parent A,B → C, A dan B muncul sebelum C dengan urutan deterministik', () => {
-  const models = new Map();
-  models.set('b', makeModel('b'));
-  models.set('a', makeModel('a'));
-  models.set('c', makeModel('c', { parentA: 'a', parentB: 'b' }));
-
-  const order = topologicalSort(models);
-  // A dan B muncul lebih dulu (alphabetical), C terakhir
-  assert.deepStrictEqual(order, ['a', 'b', 'c']);
-  // C muncul setelah A dan B
-  const cIdx = order.indexOf('c');
-  assert.ok(order.indexOf('a') < cIdx);
-  assert.ok(order.indexOf('b') < cIdx);
-});
-
-test('topological-sort: tiga tabel tanpa dependency menghasilkan urutan alfabetis', () => {
-  const models = new Map();
-  models.set('zebra', makeModel('zebra'));
-  models.set('apple', makeModel('apple'));
-  models.set('mango', makeModel('mango'));
-
-  const order = topologicalSort(models);
-  assert.deepStrictEqual(order, ['apple', 'mango', 'zebra']);
-});
-
-test('topological-sort: diamond A→B, A→C, B→D, C→D menempatkan A pertama dan D terakhir', () => {
-  const models = new Map();
-  models.set('a', makeModel('a'));
-  models.set('b', makeModel('b', { p: 'a' }));
-  models.set('c', makeModel('c', { p: 'a' }));
-  models.set('d', makeModel('d', { p1: 'b', p2: 'c' }));
-
-  const order = topologicalSort(models);
-  assert.strictEqual(order[0], 'a');
-  assert.strictEqual(order[order.length - 1], 'd');
-  // B dan C muncul setelah A dan sebelum D
-  assert.ok(order.indexOf('b') > order.indexOf('a'));
-  assert.ok(order.indexOf('c') > order.indexOf('a'));
-  assert.ok(order.indexOf('d') > order.indexOf('b'));
-  assert.ok(order.indexOf('d') > order.indexOf('c'));
-});
-
-test('topological-sort: circular dependency A→B, B→A melempar error dengan nama tabel', () => {
-  const models = new Map();
-  models.set('a', makeModel('a', { rel: 'b' }));
-  models.set('b', makeModel('b', { rel: 'a' }));
-
-  assert.throws(() => topologicalSort(models), /Circular dependency.*a.*b|Circular dependency.*b.*a/);
-});
-
-test('topological-sort: map kosong menghasilkan array kosong', () => {
-  const models = new Map();
-  const order = topologicalSort(models);
-  assert.deepStrictEqual(order, []);
-});
-
-test('topological-sort: self-reference (A→A) melempar circular dependency error', () => {
-  const models = new Map();
-  models.set('a', makeModel('a', { self: 'a' }));
-
-  assert.throws(() => topologicalSort(models), /Circular dependency.*a/);
-});
-
-test('topological-sort: panggil dua kali dengan input identik menghasilkan output identik (determinisme)', () => {
-  const models = new Map();
-  models.set('c', makeModel('c', { p: 'a' }));
-  models.set('a', makeModel('a'));
-  models.set('b', makeModel('b', { p: 'a' }));
-  models.set('d', makeModel('d', { p1: 'b', p2: 'c' }));
-
-  const r1 = topologicalSort(models);
-  const r2 = topologicalSort(models);
-  assert.deepStrictEqual(r1, r2);
-});
-
-test('topological-sort: input bukan Map melempar error', () => {
-  assert.throws(() => topologicalSort({}), /must be a Map/);
-  assert.throws(() => topologicalSort([]), /must be a Map/);
-  assert.throws(() => topologicalSort(null), /must be a Map/);
-});
-
-test('topological-sort: relasi bukan belongsTo (hasOne/hasMany) tidak menambah dependency', () => {
-  const models = new Map();
-  models.set('a', { tableName: 'a', fields: {}, primaryKey: ['a_id'], indexes: [], uniques: [], relations: {
-    children: { type: 'hasMany', target: 'b', localKey: 'a_id', references: 'a_id' }
-  }, checks: [] });
-  models.set('b', makeModel('b'));
-
-  const order = topologicalSort(models);
-  // A → hasMany → B; A tidak depend pada B (karena hasMany bukan belongsTo)
-  // B juga tidak depend pada A; keduanya in-degree 0 → alphabetical
-  assert.deepStrictEqual(order, ['a', 'b']);
-});
-
-test('topological-sort: multiple FK ke parent yang sama hanya dihitung satu kali (in-degree)', () => {
-  const models = new Map();
-  models.set('a', makeModel('a'));
-  models.set('b', { tableName: 'b', fields: {}, primaryKey: ['b_id'], indexes: [], uniques: [], relations: {
-    rel1: { type: 'belongsTo', target: 'a', localKey: 'a_id_1', references: 'a_id' },
-    rel2: { type: 'belongsTo', target: 'a', localKey: 'a_id_2', references: 'a_id' }
-  }, checks: [] });
-
-  const order = topologicalSort(models);
-  assert.deepStrictEqual(order, ['a', 'b']);
-});

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

@@ -1,373 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { validateCheckCompatibility } = require('../../../../../lib/dbschema-kit/validator/check-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;
-}
-
-function mapOf(model) {
-  const map = new Map();
-  map.set(model.qualifiedName, model);
-  return map;
-}
-
-// =====================================================
-// Valid scenarios
-// =====================================================
-
-test('check-compat: empty Map → 0 issues', () => {
-  assert.deepStrictEqual(validateCheckCompatibility(new Map()), []);
-});
-
-test('check-compat: model tanpa checks → 0 issues', () => {
-  const models = mapOf(makeModel('product', {
-    fields: { product_id: { type: 'uuid', pk: true, notnull: true } }
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-test('check-compat: string field + in dengan string array → 0 issues', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      status: { type: 'string', length: 20 }
-    },
-    checks: [
-      { field: 'status', op: 'in', value: ['active', 'inactive', 'archived'] }
-    ]
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-test('check-compat: integer field + gt numeric → 0 issues', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      price: { type: 'integer' }
-    },
-    checks: [
-      { field: 'price', op: 'gt', value: 0 }
-    ]
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-test('check-compat: timestamp field + eq dengan ISO string → 0 issues', () => {
-  const models = mapOf(makeModel('audit_log', {
-    fields: {
-      audit_log_id: { type: 'uuid', pk: true, notnull: true },
-      occurred_at: { type: 'timestamp' }
-    },
-    checks: [
-      { field: 'occurred_at', op: 'eq', value: '2026-01-01T00:00:00Z' }
-    ]
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-test('check-compat: timestamp field + eq dengan epoch number → 0 issues', () => {
-  const models = mapOf(makeModel('audit_log', {
-    fields: {
-      audit_log_id: { type: 'uuid', pk: true, notnull: true },
-      occurred_at: { type: 'timestamp' }
-    },
-    checks: [
-      { field: 'occurred_at', op: 'eq', value: 1735689600000 }
-    ]
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-test('check-compat: decimal field + gte float → 0 issues', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      weight: { type: 'decimal', precision: 10, scale: 2 }
-    },
-    checks: [
-      { field: 'weight', op: 'gte', value: 0.5 }
-    ]
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-test('check-compat: json field + in dengan mixed types → 0 issues (JSON accepts any)', () => {
-  const models = mapOf(makeModel('event', {
-    fields: {
-      event_id: { type: 'uuid', pk: true, notnull: true },
-      payload: { type: 'json' }
-    },
-    checks: [
-      { field: 'payload', op: 'in', value: [1, 'two', { three: 3 }] }
-    ]
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-// =====================================================
-// Op-type incompatible errors
-// =====================================================
-
-test('check-compat: boolean field + gt → check-op-incompatible-with-type error', () => {
-  const models = mapOf(makeModel('user', {
-    fields: {
-      user_id: { type: 'uuid', pk: true, notnull: true },
-      is_active: { type: 'boolean' }
-    },
-    checks: [
-      { field: 'is_active', op: 'gt', value: 0 }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].severity, 'error');
-  assert.strictEqual(issues[0].code, 'check-op-incompatible-with-type');
-  assert.strictEqual(issues[0].field, 'is_active');
-  assert.match(issues[0].message, /operator 'gt' is not compatible/);
-  assert.match(issues[0].message, /type 'boolean'/);
-});
-
-test('check-compat: string field + lt → check-op-incompatible-with-type error', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      name: { type: 'string', length: 100 }
-    },
-    checks: [
-      { field: 'name', op: 'lt', value: 5 }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'check-op-incompatible-with-type');
-});
-
-test('check-compat: uuid field + gte → check-op-incompatible-with-type error', () => {
-  const models = mapOf(makeModel('event', {
-    fields: {
-      event_id: { type: 'uuid', pk: true, notnull: true },
-      reference_id: { type: 'uuid' }
-    },
-    checks: [
-      { field: 'reference_id', op: 'gte', value: 1 }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'check-op-incompatible-with-type');
-});
-
-test('check-compat: text field + lte → check-op-incompatible-with-type error', () => {
-  const models = mapOf(makeModel('article', {
-    fields: {
-      article_id: { type: 'uuid', pk: true, notnull: true },
-      body: { type: 'text' }
-    },
-    checks: [
-      { field: 'body', op: 'lte', value: 1000 }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'check-op-incompatible-with-type');
-});
-
-// =====================================================
-// Value-type mismatch errors
-// =====================================================
-
-test('check-compat: integer field + in dengan string array → check-value-type-mismatch error untuk setiap item', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      category_id: { type: 'integer' }
-    },
-    checks: [
-      { field: 'category_id', op: 'in', value: ['a', 'b'] }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 2);
-  for (const issue of issues) {
-    assert.strictEqual(issue.code, 'check-value-type-mismatch');
-    assert.strictEqual(issue.field, 'category_id');
-  }
-});
-
-test('check-compat: integer field + in dengan mixed array → error hanya untuk item non-integer', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      category_id: { type: 'integer' }
-    },
-    checks: [
-      { field: 'category_id', op: 'in', value: [1, 'two', 3, 4.5] }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  // Items at positions 1 ('two', wrong type) and 3 (4.5, not integer) → 2 errors
-  assert.strictEqual(issues.length, 2);
-  assert.match(issues[0].message, /position 1/);
-  assert.match(issues[0].message, /string 'two'/);
-  assert.match(issues[1].message, /position 3/);
-  assert.match(issues[1].message, /number 4\.5/);
-});
-
-test('check-compat: string field + eq dengan number → check-value-type-mismatch error', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      status: { type: 'string', length: 20 }
-    },
-    checks: [
-      { field: 'status', op: 'eq', value: 42 }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'check-value-type-mismatch');
-  assert.match(issues[0].message, /number 42/);
-});
-
-test('check-compat: boolean field + neq dengan string → check-value-type-mismatch error', () => {
-  const models = mapOf(makeModel('user', {
-    fields: {
-      user_id: { type: 'uuid', pk: true, notnull: true },
-      is_active: { type: 'boolean' }
-    },
-    checks: [
-      { field: 'is_active', op: 'neq', value: 'true' }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'check-value-type-mismatch');
-  assert.match(issues[0].message, /string 'true'/);
-});
-
-test('check-compat: integer field + in dengan float value → check-value-type-mismatch (not integer)', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      category_id: { type: 'integer' }
-    },
-    checks: [
-      { field: 'category_id', op: 'in', value: [1, 2.5, 3] }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'check-value-type-mismatch');
-  assert.match(issues[0].message, /position 1/);
-});
-
-test('check-compat: decimal field + in dengan integer dan float → 0 issues (decimal accepts both)', () => {
-  const models = mapOf(makeModel('product', {
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      weight: { type: 'decimal', precision: 10, scale: 2 }
-    },
-    checks: [
-      { field: 'weight', op: 'in', value: [1, 2.5, 3] }
-    ]
-  }));
-  assert.deepStrictEqual(validateCheckCompatibility(models), []);
-});
-
-// =====================================================
-// Op-incompat dan value-mismatch tidak double-report
-// =====================================================
-
-test('check-compat: boolean + gt + value string → hanya 1 issue (op-incompat saja), value check di-skip', () => {
-  const models = mapOf(makeModel('user', {
-    fields: {
-      user_id: { type: 'uuid', pk: true, notnull: true },
-      is_active: { type: 'boolean' }
-    },
-    checks: [
-      // schema-validator would actually reject value:'x' here, but assume it
-      // passes through to keep test focus on the op-incompat → no double-report rule.
-      { field: 'is_active', op: 'gt', value: 0 }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].code, 'check-op-incompatible-with-type');
-});
-
-// =====================================================
-// Issue decoration
-// =====================================================
-
-test('check-compat: Issue di-decorate dengan file path bila _filePath ada di model', () => {
-  const models = mapOf(makeModel('product', {
-    filePath: '/abs/schema/product.js',
-    fields: {
-      product_id: { type: 'uuid', pk: true, notnull: true },
-      status: { type: 'string', length: 20 }
-    },
-    checks: [
-      { field: 'status', op: 'eq', value: 42 }
-    ]
-  }));
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 1);
-  assert.strictEqual(issues[0].file, '/abs/schema/product.js');
-  assert.strictEqual(issues[0].table, 'product');
-});
-
-// =====================================================
-// Multi-table
-// =====================================================
-
-test('check-compat: 2 tabel masing-masing punya error → semua di-collect', () => {
-  const models = new Map();
-  models.set('a', makeModel('a', {
-    fields: {
-      a_id: { type: 'uuid', pk: true, notnull: true },
-      flag_a: { type: 'boolean' }
-    },
-    checks: [{ field: 'flag_a', op: 'gt', value: 0 }]
-  }));
-  models.set('b', makeModel('b', {
-    fields: {
-      b_id: { type: 'uuid', pk: true, notnull: true },
-      label: { type: 'string', length: 10 }
-    },
-    checks: [{ field: 'label', op: 'eq', value: 42 }]
-  }));
-
-  const issues = validateCheckCompatibility(models);
-  assert.strictEqual(issues.length, 2);
-  const codes = issues.map((i) => i.code).sort();
-  assert.deepStrictEqual(codes, ['check-op-incompatible-with-type', 'check-value-type-mismatch']);
-});