@restforgejs/platform 4.2.8 → 4.3.2

package/generators/tests/unit/lib/dbschema-kit/ir-builder.test.js

@@ -1,390 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { buildIR } = require('../../../../lib/dbschema-kit/ir-builder');
-
-// =====================================================
-// Happy path
-// =====================================================
-
-test('ir-builder: single field tanpa constraint', () => {
-  const ir = buildIR('foo', { fields: { id: 'uuid pk' } });
-  assert.strictEqual(ir.tableName, 'foo');
-  assert.deepStrictEqual(ir.fields.id, { type: 'uuid', pk: true, notnull: true });
-  assert.deepStrictEqual(ir.primaryKey, ['id']);
-  assert.deepStrictEqual(ir.indexes, []);
-  assert.deepStrictEqual(ir.uniques, []);
-  assert.deepStrictEqual(ir.relations, {});
-  assert.deepStrictEqual(ir.checks, []);
-  assert.strictEqual(ir._meta.hasSinglePkShorthand, true);
-  assert.strictEqual(ir._meta.hasCompositePrimaryKey, false);
-  assert.deepStrictEqual(ir._meta.autoGeneratedRelations, []);
-});
-
-test('ir-builder: field dengan multiple constraint mempertahankan property hasil parse', () => {
-  const ir = buildIR('foo', {
-    fields: {
-      id: 'uuid pk',
-      code: 'string:20 unique notnull'
-    }
-  });
-  assert.strictEqual(ir.fields.code.type, 'string');
-  assert.strictEqual(ir.fields.code.length, 20);
-  assert.strictEqual(ir.fields.code.unique, true);
-  assert.strictEqual(ir.fields.code.notnull, true);
-});
-
-test('ir-builder: composite primary key auto-marks notnull pada semua field', () => {
-  const ir = buildIR('inventory_balance', {
-    fields: {
-      a: 'uuid',
-      b: 'uuid',
-      c: 'date'
-    },
-    primaryKey: ['a', 'b']
-  });
-  assert.deepStrictEqual(ir.primaryKey, ['a', 'b']);
-  assert.strictEqual(ir.fields.a.notnull, true);
-  assert.strictEqual(ir.fields.b.notnull, true);
-  assert.strictEqual(ir.fields.c.notnull, undefined);
-  assert.strictEqual(ir._meta.hasCompositePrimaryKey, true);
-  assert.strictEqual(ir._meta.hasSinglePkShorthand, false);
-});
-
-test('ir-builder: single pk shorthand auto-marks notnull dan emit ke primaryKey array', () => {
-  const ir = buildIR('category', {
-    fields: { category_id: 'uuid pk' }
-  });
-  assert.deepStrictEqual(ir.primaryKey, ['category_id']);
-  assert.strictEqual(ir.fields.category_id.notnull, true);
-  assert.strictEqual(ir.fields.category_id.pk, true);
-});
-
-test('ir-builder: single column index', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', name: 'string:50' },
-    indexes: ['name']
-  });
-  assert.deepStrictEqual(ir.indexes, [{ columns: ['name'], composite: false }]);
-});
-
-test('ir-builder: composite index', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'string:20', b: 'string:20' },
-    indexes: [['a', 'b']]
-  });
-  assert.deepStrictEqual(ir.indexes, [{ columns: ['a', 'b'], composite: true }]);
-});
-
-test('ir-builder: mix single dan composite index', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', a: 'string:20', b: 'string:20', c: 'string:20' },
-    indexes: ['a', ['b', 'c']]
-  });
-  assert.deepStrictEqual(ir.indexes, [
-    { columns: ['a'], composite: false },
-    { columns: ['b', 'c'], composite: true }
-  ]);
-});
-
-test('ir-builder: composite unique', () => {
-  const ir = buildIR('stock_inbound_item', {
-    fields: { id: 'uuid pk', stock_inbound_id: 'uuid', line_number: 'integer' },
-    uniques: [['stock_inbound_id', 'line_number']]
-  });
-  assert.deepStrictEqual(ir.uniques, [{ columns: ['stock_inbound_id', 'line_number'] }]);
-});
-
-test('ir-builder: fk shorthand auto-promote ke relations entry', () => {
-  const ir = buildIR('item_product', {
-    fields: {
-      item_product_id: 'string:36 pk',
-      category_id: 'string:36 fk:category.category_id notnull'
-    }
-  });
-  assert.ok(ir.relations.category, 'relation `category` should exist');
-  assert.strictEqual(ir.relations.category.type, 'belongsTo');
-  assert.strictEqual(ir.relations.category.target, 'category');
-  assert.strictEqual(ir.relations.category.localKey, 'category_id');
-  assert.strictEqual(ir.relations.category.references, 'category_id');
-  assert.strictEqual(ir.relations.category._autoGenerated, true);
-  assert.strictEqual(ir.relations.category._sourceField, 'category_id');
-  assert.deepStrictEqual(ir._meta.autoGeneratedRelations, ['category']);
-});
-
-test('ir-builder: derivasi nama relation dari field berakhiran _id (strip suffix)', () => {
-  const ir = buildIR('item_product', {
-    fields: {
-      id: 'uuid pk',
-      category_id: 'string:36 fk:category.category_id'
-    }
-  });
-  assert.ok(ir.relations.category);
-});
-
-test('ir-builder: derivasi nama relation untuk field tanpa suffix _id', () => {
-  const ir = buildIR('purchase_order', {
-    fields: {
-      id: 'uuid pk',
-      created_by: 'string:36 fk:user.id'
-    }
-  });
-  assert.ok(ir.relations.created_by_user, 'relation name should be `created_by_user`');
-  assert.strictEqual(ir.relations.created_by_user.target, 'user');
-  assert.strictEqual(ir.relations.created_by_user.localKey, 'created_by');
-  assert.strictEqual(ir.relations.created_by_user.references, 'id');
-});
-
-test('ir-builder: relations eksplisit dengan custom onDelete dan default target', () => {
-  const ir = buildIR('stock_inbound', {
-    fields: {
-      id: 'uuid pk',
-      supplier_id: 'string:36'
-    },
-    relations: {
-      supplier: {
-        type: 'belongsTo',
-        localKey: 'supplier_id',
-        references: 'supplier_id',
-        onDelete: 'setNull'
-      }
-    }
-  });
-  assert.strictEqual(ir.relations.supplier.target, 'supplier');
-  assert.strictEqual(ir.relations.supplier.onDelete, 'setNull');
-  assert.strictEqual(ir.relations.supplier._autoGenerated, false);
-  assert.strictEqual(ir.relations.supplier._sourceField, null);
-});
-
-test('ir-builder: relations eksplisit dengan target eksplisit (multiple FK ke target sama)', () => {
-  const ir = buildIR('purchase_order', {
-    fields: {
-      id: 'string:36 pk',
-      created_by: 'string:36'
-    },
-    relations: {
-      creator: {
-        type: 'belongsTo',
-        target: 'user',
-        localKey: 'created_by',
-        references: 'id'
-      }
-    }
-  });
-  assert.strictEqual(ir.relations.creator.target, 'user');
-  assert.strictEqual(ir.relations.creator.localKey, 'created_by');
-  assert.strictEqual(ir.relations.creator.references, 'id');
-});
-
-test('ir-builder: multiple relations ke target tabel yang sama dengan localKey berbeda', () => {
-  const ir = buildIR('purchase_order', {
-    fields: {
-      id: 'string:36 pk',
-      created_by: 'string:36',
-      updated_by: 'string:36'
-    },
-    relations: {
-      creator: { type: 'belongsTo', target: 'user', localKey: 'created_by', references: 'id' },
-      updater: { type: 'belongsTo', target: 'user', localKey: 'updated_by', references: 'id' }
-    }
-  });
-  assert.strictEqual(ir.relations.creator.target, 'user');
-  assert.strictEqual(ir.relations.creator.localKey, 'created_by');
-  assert.strictEqual(ir.relations.updater.target, 'user');
-  assert.strictEqual(ir.relations.updater.localKey, 'updated_by');
-});
-
-test('ir-builder: auto-index untuk fk shorthand di field-level', () => {
-  const ir = buildIR('item_product', {
-    fields: {
-      id: 'uuid pk',
-      category_id: 'string:36 fk:category.category_id'
-    }
-  });
-  assert.strictEqual(ir.fields.category_id.index, true);
-  const hasIdx = ir.indexes.some((i) => i.columns.length === 1 && i.columns[0] === 'category_id');
-  assert.ok(hasIdx, 'indexes should include category_id');
-});
-
-test('ir-builder: auto-index untuk relations belongsTo eksplisit', () => {
-  const ir = buildIR('stock_inbound', {
-    fields: {
-      id: 'uuid pk',
-      warehouse_id: 'string:36'
-    },
-    relations: {
-      warehouse: { type: 'belongsTo', localKey: 'warehouse_id', references: 'warehouse_id' }
-    }
-  });
-  assert.strictEqual(ir.fields.warehouse_id.index, true);
-  const hasIdx = ir.indexes.some((i) => i.columns.length === 1 && i.columns[0] === 'warehouse_id');
-  assert.ok(hasIdx, 'indexes should include warehouse_id');
-});
-
-test('ir-builder: auto-index dedupe ketika user juga menulis field di indexes', () => {
-  const ir = buildIR('stock_inbound', {
-    fields: {
-      id: 'uuid pk',
-      warehouse_id: 'string:36'
-    },
-    indexes: ['warehouse_id'],
-    relations: {
-      warehouse: { type: 'belongsTo', localKey: 'warehouse_id', references: 'warehouse_id' }
-    }
-  });
-  const matches = ir.indexes.filter((i) => i.columns.length === 1 && i.columns[0] === 'warehouse_id');
-  assert.strictEqual(matches.length, 1, 'warehouse_id should not be duplicated in indexes');
-});
-
-test('ir-builder: checks normalisasi entry dengan operator `in`', () => {
-  const ir = buildIR('stock_inbound', {
-    fields: { id: 'uuid pk', status: "string:20 default:'draft'" },
-    checks: [{ field: 'status', in: ['draft', 'closed'] }]
-  });
-  assert.strictEqual(ir.checks.length, 1);
-  assert.strictEqual(ir.checks[0].field, 'status');
-  assert.strictEqual(ir.checks[0].op, 'in');
-  assert.deepStrictEqual(ir.checks[0].value, ['draft', 'closed']);
-});
-
-test('ir-builder: field dengan autoUpdate token (parser Fase 1 belum support, di-strip oleh IR builder)', () => {
-  const ir = buildIR('foo', {
-    fields: {
-      id: 'uuid pk',
-      updated_at: 'timestamp autoUpdate'
-    }
-  });
-  assert.strictEqual(ir.fields.updated_at.type, 'timestamp');
-  assert.strictEqual(ir.fields.updated_at.autoUpdate, true);
-  assert.strictEqual(ir.fields.updated_at.default, undefined);
-});
-
-// =====================================================
-// Edge case (defer ke validator)
-// =====================================================
-
-test('ir-builder: konflik pk shorthand + primaryKey option keep both, tidak throw', () => {
-  const ir = buildIR('foo', {
-    fields: {
-      a: 'uuid pk',
-      b: 'uuid'
-    },
-    primaryKey: ['a', 'b']
-  });
-  assert.deepStrictEqual(ir.primaryKey, ['a', 'b']);
-  assert.strictEqual(ir._meta.hasSinglePkShorthand, true);
-  assert.strictEqual(ir._meta.hasCompositePrimaryKey, true);
-  assert.strictEqual(ir.fields.a.pk, true);
-  assert.strictEqual(ir.fields.a.notnull, true);
-});
-
-test('ir-builder: auto-name collision dengan eksplisit memakai suffix _auto', () => {
-  const ir = buildIR('item_product', {
-    fields: {
-      id: 'uuid pk',
-      category_id: 'string:36 fk:category.category_id'
-    },
-    relations: {
-      category: {
-        type: 'belongsTo',
-        localKey: 'category_id',
-        references: 'category_id',
-        onDelete: 'cascade'
-      }
-    }
-  });
-  assert.ok(ir.relations.category, 'explicit relation should be preserved');
-  assert.strictEqual(ir.relations.category._autoGenerated, false);
-  assert.strictEqual(ir.relations.category.onDelete, 'cascade');
-  assert.ok(ir.relations.category_auto, 'auto-generated relation should use suffix `_auto`');
-  assert.strictEqual(ir.relations.category_auto._autoGenerated, true);
-  assert.deepStrictEqual(ir._meta.autoGeneratedRelations, ['category_auto']);
-});
-
-test('ir-builder: relations eksplisit dengan localKey ke field tidak existing tidak throw', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk' },
-    relations: {
-      bar: { type: 'belongsTo', localKey: 'nonexistent_field', references: 'id' }
-    }
-  });
-  assert.ok(ir.relations.bar);
-  assert.strictEqual(ir.relations.bar.localKey, 'nonexistent_field');
-});
-
-test('ir-builder: check dengan multiple operator di-flag _invalid', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', x: 'integer' },
-    checks: [{ field: 'x', gt: 0, lt: 100 }]
-  });
-  assert.strictEqual(ir.checks.length, 1);
-  assert.strictEqual(ir.checks[0]._invalid, true);
-  assert.strictEqual(ir.checks[0]._reason, 'multiple operators');
-  assert.strictEqual(ir.checks[0].field, 'x');
-});
-
-test('ir-builder: check tanpa operator di-flag _invalid', () => {
-  const ir = buildIR('foo', {
-    fields: { id: 'uuid pk', x: 'integer' },
-    checks: [{ field: 'x' }]
-  });
-  assert.strictEqual(ir.checks.length, 1);
-  assert.strictEqual(ir.checks[0]._invalid, true);
-  assert.strictEqual(ir.checks[0]._reason, 'no operator');
-});
-
-// =====================================================
-// Structural error case (boleh throw)
-// =====================================================
-
-test('ir-builder: tableName bukan string atau empty harus throw', () => {
-  assert.throws(() => buildIR('', { fields: { id: 'uuid pk' } }), /Table name must be a non-empty string/);
-  assert.throws(() => buildIR(null, { fields: { id: 'uuid pk' } }), /Table name must be a non-empty string/);
-  assert.throws(() => buildIR(123, { fields: { id: 'uuid pk' } }), /Table name must be a non-empty string/);
-});
-
-test('ir-builder: options.fields tidak ada atau bukan plain object harus throw', () => {
-  assert.throws(() => buildIR('foo', {}), /options\.fields must be a plain object/);
-  assert.throws(() => buildIR('foo', { fields: null }), /options\.fields must be a plain object/);
-  assert.throws(() => buildIR('foo', { fields: [] }), /options\.fields must be a plain object/);
-});
-
-test('ir-builder: options.fields empty object harus throw', () => {
-  assert.throws(() => buildIR('foo', { fields: {} }), /options\.fields must have at least one field/);
-});
-
-test('ir-builder: parser error propagated dengan context tableName', () => {
-  assert.throws(
-    () => buildIR('foo', { fields: { code: 'string:20 uniqe' } }),
-    /^Error: Table 'foo': Field 'code': unknown constraint 'uniqe'$/
-  );
-});
-
-// =====================================================
-// Phase 13: schema namespace support
-// =====================================================
-
-test('ir-builder: IR.qualifiedName == <schema>.<table> bila schema diberikan', () => {
-  const ir = buildIR('products', {
-    schema: 'inventory',
-    fields: { id: 'uuid pk' }
-  });
-  assert.strictEqual(ir.schemaName, 'inventory');
-  assert.strictEqual(ir.tableName, 'products');
-  assert.strictEqual(ir.qualifiedName, 'inventory.products');
-});
-
-test('ir-builder: IR.qualifiedName == tableName bila schema null', () => {
-  const ir = buildIR('products', { fields: { id: 'uuid pk' } });
-  assert.strictEqual(ir.schemaName, null);
-  assert.strictEqual(ir.qualifiedName, 'products');
-});
-
-test('ir-builder: options.schema bukan string harus throw', () => {
-  assert.throws(
-    () => buildIR('products', { schema: 42, fields: { id: 'uuid pk' } }),
-    /^Error: Table 'products': options\.schema must be a string or null$/
-  );
-});

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

@@ -1,128 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-const path = require('path');
-
-const { loadSchemaFolder } = require('../../../../lib/dbschema-kit/loader');
-
-const FIXTURES = path.join(__dirname, 'fixtures', 'loader');
-
-test('loader: folder dengan 1 file valid return Map dengan 1 entry, tableName sebagai key', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'valid-single'));
-  assert.strictEqual(map.size, 1);
-  assert.ok(map.has('category'), "key 'category' harus ada");
-  assert.strictEqual(map.get('category').tableName, 'category');
-});
-
-test('loader: folder dengan multiple file valid return Map dengan multiple entries', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'valid-multiple'));
-  assert.strictEqual(map.size, 2);
-  assert.ok(map.has('category'));
-  assert.ok(map.has('item_product'));
-  assert.strictEqual(map.get('item_product').fields.item_product_id.pk, true);
-});
-
-test('loader: folder tidak exist throw', () => {
-  assert.throws(
-    () => loadSchemaFolder(path.join(FIXTURES, 'nonexistent-folder')),
-    /^Error: Schema folder not found:/
-  );
-});
-
-test('loader: folder berisi file non-js (README.md) skip dan return Map kosong', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'empty-folder'));
-  assert.strictEqual(map.size, 0);
-});
-
-test('loader: duplicate tableName antar file throw dengan info kedua file', () => {
-  // fs.readdirSync mengembalikan entry alfabetis: bar.js (di-load duluan), lalu foo.js (collision).
-  assert.throws(
-    () => loadSchemaFolder(path.join(FIXTURES, 'duplicate-tablename')),
-    /^Error: Duplicate table name 'same_name' in files: bar\.js, foo\.js$/
-  );
-});
-
-test('loader: file tidak export factory function throw dengan instruksi migration', () => {
-  assert.throws(
-    () => loadSchemaFolder(path.join(FIXTURES, 'invalid-export')),
-    /^Error: Schema file 'plain\.js' must export a factory function\. Use: module\.exports = \(\{ defineModel \}\) => defineModel\(\.\.\.\)$/
-  );
-});
-
-test('loader: file mengandung schema invalid (single-model violation) throw wrapped error dengan filename context', () => {
-  assert.throws(
-    () => loadSchemaFolder(path.join(FIXTURES, 'invalid-schema')),
-    /^Error: Failed to load schema file 'bad\.js': Table name must be snake_case/
-  );
-});
-
-test('loader: factory function pattern (module.exports = ({ defineModel }) => defineModel(...)) load sukses', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'valid-single'));
-  assert.strictEqual(map.size, 1);
-  const ir = map.get('category');
-  assert.ok(ir, 'IR harus ter-load');
-  assert.strictEqual(ir.tableName, 'category');
-  assert.ok(ir.fields, 'IR harus punya properti fields');
-  assert.strictEqual(ir.fields.category_id.pk, true);
-});
-
-test('loader: pattern lama (module.exports = defineModel(...) direct) throw error dengan instruksi migration', () => {
-  assert.throws(
-    () => loadSchemaFolder(path.join(FIXTURES, 'legacy-pattern')),
-    /^Error: Schema file 'legacy\.js' must export a factory function\. Use: module\.exports = \(\{ defineModel \}\) => defineModel\(\.\.\.\)$/
-  );
-});
-
-test('loader: recursive scan folder dengan 2 subfolder (master, transactions) load 4 model', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'recursive-multi-folder'));
-  assert.strictEqual(map.size, 4, 'harus load 4 model dari subfolder master + transactions');
-  assert.ok(map.has('category'));
-  assert.ok(map.has('supplier'));
-  assert.ok(map.has('stock_inbound'));
-  assert.ok(map.has('stock_inbound_item'));
-});
-
-test('loader: recursive scan skip hidden folder (.hidden), file di dalamnya tidak masuk Map', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'recursive-multi-folder'));
-  assert.ok(!map.has('hidden_ignored'), "tabel di .hidden/ tidak boleh ter-load");
-});
-
-test('loader: recursive scan skip folder node_modules, file di dalamnya tidak masuk Map', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'recursive-multi-folder'));
-  assert.ok(!map.has('nm_junk'), "tabel di node_modules/ tidak boleh ter-load");
-});
-
-test('loader: duplicate tableName di subfolder berbeda throw dengan info kedua relative path', () => {
-  assert.throws(
-    () => loadSchemaFolder(path.join(FIXTURES, 'duplicate-subfolder')),
-    /^Error: Duplicate table name 'category' in files: extra\/category\.js, master\/category\.js$/
-  );
-});
-
-test('loader: recursive scan folder nested 3+ level (a/b/c/foo.js) tetap load file', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'nested-deep'));
-  assert.strictEqual(map.size, 1, 'harus load 1 model dari nested deep folder');
-  assert.ok(map.has('deep_table'));
-  assert.strictEqual(map.get('deep_table').tableName, 'deep_table');
-});
-
-// =====================================================
-// Phase 13: schema namespace support
-// =====================================================
-
-test('loader: dua file dengan tableName sama tapi schema beda load sukses, Map keyed by qualified name', () => {
-  const map = loadSchemaFolder(path.join(FIXTURES, 'multi-schema-distinct'));
-  assert.strictEqual(map.size, 2, 'harus load 2 model walaupun tableName sama');
-  assert.ok(map.has('inventory.products'), 'qualified key inventory.products harus ada');
-  assert.ok(map.has('audit.products'), 'qualified key audit.products harus ada');
-  assert.strictEqual(map.get('inventory.products').schemaName, 'inventory');
-  assert.strictEqual(map.get('audit.products').schemaName, 'audit');
-});
-
-test('loader: dua file dengan qualified name sama (schema + table identik) → duplicate error dengan qualified name', () => {
-  assert.throws(
-    () => loadSchemaFolder(path.join(FIXTURES, 'multi-schema-duplicate')),
-    /^Error: Duplicate table name 'inventory\.products' in files: a\/products\.js, b\/products\.js$/
-  );
-});

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

@@ -1,170 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-const crypto = require('node:crypto');
-
-const { generateConstraintName, deriveCompositeShortName, shortenIdentifier } = require('../../../../lib/dbschema-kit/naming');
-
-test('naming: generateConstraintName tanpa suffix menghasilkan prefix_table', () => {
-  assert.strictEqual(generateConstraintName('pk', 'category', ''), 'pk_category');
-});
-
-test('naming: generateConstraintName tanpa suffix (undefined) menghasilkan prefix_table', () => {
-  assert.strictEqual(generateConstraintName('pk', 'category'), 'pk_category');
-});
-
-test('naming: generateConstraintName dengan suffix menghasilkan prefix_table_suffix', () => {
-  assert.strictEqual(generateConstraintName('uq', 'category', 'code'), 'uq_category_code');
-});
-
-test('naming: generateConstraintName foreign key', () => {
-  assert.strictEqual(
-    generateConstraintName('fk', 'stock_inbound', 'warehouse'),
-    'fk_stock_inbound_warehouse'
-  );
-});
-
-test('naming: generateConstraintName index single column', () => {
-  assert.strictEqual(
-    generateConstraintName('idx', 'stock_inbound', 'inbound_date'),
-    'idx_stock_inbound_inbound_date'
-  );
-});
-
-test('naming: generateConstraintName check single', () => {
-  assert.strictEqual(
-    generateConstraintName('chk', 'item_product', 'uom'),
-    'chk_item_product_uom'
-  );
-});
-
-test('naming: generateConstraintName total tepat 30 char tetap as-is', () => {
-  const name = generateConstraintName('idx', 'stock_inbound', 'inbound_date');
-  assert.strictEqual(name.length, 30);
-  assert.strictEqual(name, 'idx_stock_inbound_inbound_date');
-});
-
-test('naming: generateConstraintName > 30 char menghasilkan 22+1+7 dengan md5 hash', () => {
-  const original = 'fk_stock_inbound_item_stock_inbound';
-  assert.strictEqual(original.length, 35);
-
-  const expectedHash = crypto.createHash('md5').update(original).digest('hex').slice(0, 7);
-  const expected = `${original.slice(0, 22)}_${expectedHash}`;
-
-  const result = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound');
-  assert.strictEqual(result.length, 30);
-  assert.strictEqual(result, expected);
-});
-
-test('naming: generateConstraintName deterministic — panggil 2x dengan input sama menghasilkan output sama', () => {
-  const a = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound');
-  const b = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound');
-  assert.strictEqual(a, b);
-});
-
-test('naming: generateConstraintName beda input menghasilkan beda hash', () => {
-  const a = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound');
-  const b = generateConstraintName('fk', 'stock_inbound_item', 'stock_outbound_xx');
-  assert.notStrictEqual(a, b);
-  assert.strictEqual(a.length, 30);
-  assert.strictEqual(b.length, 30);
-});
-
-test('naming: deriveCompositeShortName total <= 30 char join dengan underscore', () => {
-  assert.strictEqual(
-    deriveCompositeShortName(['stock_inbound_id', 'line_number']),
-    'stock_inbound_id_line_number'
-  );
-});
-
-test('naming: deriveCompositeShortName dua kolom pendek', () => {
-  assert.strictEqual(deriveCompositeShortName(['a', 'b']), 'a_b');
-});
-
-test('naming: deriveCompositeShortName total > 30 char fallback ke kolom terakhir', () => {
-  assert.strictEqual(
-    deriveCompositeShortName(['stock_inbound_id', 'item_product_id']),
-    'item_product_id'
-  );
-});
-
-test('naming: deriveCompositeShortName tiga kolom panjang fallback ke kolom terakhir', () => {
-  assert.strictEqual(
-    deriveCompositeShortName(['long_col_name1', 'long_col_name2', 'long_col_name3']),
-    'long_col_name3'
-  );
-});
-
-test('naming: deriveCompositeShortName throw bila columns kosong', () => {
-  assert.throws(() => deriveCompositeShortName([]), /Columns must be a non-empty array/);
-});
-
-// ---------------------------------------------------------------------------
-// maxLength parameter (per-dialect identifier cap)
-// ---------------------------------------------------------------------------
-
-test('naming: generateConstraintName dengan maxLength=63 keep nama panjang as-is', () => {
-  // Original: 'fk_stock_inbound_item_stock_inbound' = 35 char, < 63 → tidak di-hash
-  const result = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound', 63);
-  assert.strictEqual(result, 'fk_stock_inbound_item_stock_inbound');
-  assert.strictEqual(result.length, 35);
-});
-
-test('naming: generateConstraintName dengan maxLength=63 hash hanya bila > 63', () => {
-  const original = 'fk_very_long_table_name_with_many_words_and_extra_padding_chars_xxx';
-  assert.ok(original.length > 63);
-
-  const expectedHash = crypto.createHash('md5').update(original).digest('hex').slice(0, 7);
-  const expected = `${original.slice(0, 63 - 8)}_${expectedHash}`; // 63 - 7 - 1 = 55
-
-  const result = generateConstraintName('fk', 'very_long_table_name_with_many_words_and_extra_padding_chars', 'xxx', 63);
-  assert.strictEqual(result.length, 63);
-  assert.strictEqual(result, expected);
-});
-
-test('naming: generateConstraintName dengan maxLength=128 (Oracle 19c) keep panjang', () => {
-  const result = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound', 128);
-  assert.strictEqual(result, 'fk_stock_inbound_item_stock_inbound');
-});
-
-test('naming: generateConstraintName maxLength undefined fallback ke 30 (default legacy)', () => {
-  // explicit undefined → still hashed at 30 char limit
-  const a = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound');
-  const b = generateConstraintName('fk', 'stock_inbound_item', 'stock_inbound', undefined);
-  assert.strictEqual(a, b);
-  assert.strictEqual(a.length, 30);
-});
-
-test('naming: deriveCompositeShortName dengan maxLength=63 tidak fallback bila join < 63', () => {
-  // 'stock_inbound_id_item_product_id' = 31 char, < 63 → join utuh
-  assert.strictEqual(
-    deriveCompositeShortName(['stock_inbound_id', 'item_product_id'], 63),
-    'stock_inbound_id_item_product_id'
-  );
-});
-
-test('naming: deriveCompositeShortName dengan maxLength=63 fallback bila join > 63', () => {
-  // join total > 63 → return last column
-  assert.strictEqual(
-    deriveCompositeShortName(['col_aaaaaaaaaaaaa', 'col_bbbbbbbbbbbbbb', 'col_cccccccccccccc', 'col_ddddddddddddd'], 63),
-    'col_ddddddddddddd'
-  );
-});
-
-test('naming: shortenIdentifier short name returns as-is', () => {
-  assert.strictEqual(shortenIdentifier('short_name'), 'short_name');
-});
-
-test('naming: shortenIdentifier > 30 char default → truncate + hash', () => {
-  const original = 'this_is_a_very_long_check_constraint_name';
-  assert.ok(original.length > 30);
-  const result = shortenIdentifier(original);
-  assert.strictEqual(result.length, 30);
-});
-
-test('naming: shortenIdentifier maxLength=63 keep nama < 63 as-is', () => {
-  const original = 'this_is_a_very_long_check_constraint_name';
-  assert.ok(original.length < 63);
-  assert.strictEqual(shortenIdentifier(original, 63), original);
-});