@restforgejs/platform 4.1.1 → 4.3.1

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

@@ -1,126 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const mysql = require('../../../../../lib/dbschema-kit/dialect/mysql');
-
-test('mysql: name identifier dialect adalah mysql', () => {
-  assert.strictEqual(mysql.name, 'mysql');
-});
-
-test('mysql: mapType integer menghasilkan INT (bukan INTEGER)', () => {
-  assert.strictEqual(mysql.mapType({ type: 'integer' }), 'INT');
-});
-
-test('mysql: mapType bigint menghasilkan BIGINT', () => {
-  assert.strictEqual(mysql.mapType({ type: 'bigint' }), 'BIGINT');
-});
-
-test('mysql: mapType text menghasilkan TEXT', () => {
-  assert.strictEqual(mysql.mapType({ type: 'text' }), 'TEXT');
-});
-
-test('mysql: mapType string dengan length menghasilkan VARCHAR(N)', () => {
-  assert.strictEqual(mysql.mapType({ type: 'string', length: 36 }), 'VARCHAR(36)');
-});
-
-test('mysql: mapType decimal menghasilkan DECIMAL(M,N)', () => {
-  assert.strictEqual(mysql.mapType({ type: 'decimal', precision: 15, scale: 2 }), 'DECIMAL(15,2)');
-});
-
-test('mysql: mapType boolean menghasilkan VARCHAR(5) sesuai konvensi runtime', () => {
-  assert.strictEqual(mysql.mapType({ type: 'boolean' }), 'VARCHAR(5)');
-});
-
-test('mysql: mapType uuid menghasilkan VARCHAR(36)', () => {
-  assert.strictEqual(mysql.mapType({ type: 'uuid' }), 'VARCHAR(36)');
-});
-
-test('mysql: mapType json native menghasilkan JSON', () => {
-  assert.strictEqual(mysql.mapType({ type: 'json' }), 'JSON');
-});
-
-test('mysql: mapType date menghasilkan DATE', () => {
-  assert.strictEqual(mysql.mapType({ type: 'date' }), 'DATE');
-});
-
-test('mysql: mapType timestamp menghasilkan TIMESTAMP', () => {
-  assert.strictEqual(mysql.mapType({ type: 'timestamp' }), 'TIMESTAMP');
-});
-
-test('mysql: mapType throw bila type tidak dikenal', () => {
-  assert.throws(() => mysql.mapType({ type: 'binary' }), /Unknown type: 'binary'/);
-});
-
-test("mysql: formatDefault literal boolean true menghasilkan 'true'", () => {
-  assert.strictEqual(mysql.formatDefault({ kind: 'literal', value: true }), "'true'");
-});
-
-test("mysql: formatDefault literal boolean false menghasilkan 'false'", () => {
-  assert.strictEqual(mysql.formatDefault({ kind: 'literal', value: false }), "'false'");
-});
-
-test('mysql: formatDefault literal angka menghasilkan literal tanpa quote', () => {
-  assert.strictEqual(mysql.formatDefault({ kind: 'literal', value: 0 }), '0');
-  assert.strictEqual(mysql.formatDefault({ kind: 'literal', value: 100 }), '100');
-});
-
-test('mysql: formatDefault literal string menghasilkan single quote wrapped', () => {
-  assert.strictEqual(mysql.formatDefault({ kind: 'literal', value: 'INDONESIA' }), "'INDONESIA'");
-});
-
-test('mysql: formatDefault function now menghasilkan CURRENT_TIMESTAMP', () => {
-  assert.strictEqual(
-    mysql.formatDefault({ kind: 'function', name: 'now', args: [] }),
-    'CURRENT_TIMESTAMP'
-  );
-});
-
-test('mysql: formatDefault constant current_date menghasilkan CURRENT_DATE', () => {
-  assert.strictEqual(
-    mysql.formatDefault({ kind: 'constant', value: 'current_date' }),
-    'CURRENT_DATE'
-  );
-});
-
-test('mysql: formatDefault throw bila function bukan whitelist', () => {
-  assert.throws(
-    () => mysql.formatDefault({ kind: 'function', name: 'uuid', args: [] }),
-    /Unknown function: 'uuid'/
-  );
-});
-
-test('mysql: formatDefault throw bila constant bukan whitelist', () => {
-  assert.throws(
-    () => mysql.formatDefault({ kind: 'constant', value: 'sysdate' }),
-    /Unknown constant: 'sysdate'/
-  );
-});
-
-test('mysql: quoteIdentifier identifier biasa return as-is tanpa quote', () => {
-  assert.strictEqual(mysql.quoteIdentifier('category'), 'category');
-});
-
-test('mysql: quoteIdentifier reserved word return as-is tanpa quote', () => {
-  assert.strictEqual(mysql.quoteIdentifier('user'), 'user');
-  assert.strictEqual(mysql.quoteIdentifier('order'), 'order');
-});
-
-test('mysql: quoteIdentifier throw bila identifier empty string', () => {
-  assert.throws(() => mysql.quoteIdentifier(''), /Identifier must be a non-empty string/);
-});
-
-test('mysql: formatReferentialAction memetakan semua action ke SQL', () => {
-  assert.strictEqual(mysql.formatReferentialAction('cascade'), 'CASCADE');
-  assert.strictEqual(mysql.formatReferentialAction('restrict'), 'RESTRICT');
-  assert.strictEqual(mysql.formatReferentialAction('setNull'), 'SET NULL');
-  assert.strictEqual(mysql.formatReferentialAction('noAction'), 'NO ACTION');
-});
-
-test('mysql: formatReferentialAction throw bila action tidak dikenal', () => {
-  assert.throws(
-    () => mysql.formatReferentialAction('unknown'),
-    /Unknown referential action: 'unknown'/
-  );
-});

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

@@ -1,126 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const oracle = require('../../../../../lib/dbschema-kit/dialect/oracle');
-
-test('oracle: name identifier dialect adalah oracle', () => {
-  assert.strictEqual(oracle.name, 'oracle');
-});
-
-test('oracle: mapType integer menghasilkan NUMBER(10)', () => {
-  assert.strictEqual(oracle.mapType({ type: 'integer' }), 'NUMBER(10)');
-});
-
-test('oracle: mapType bigint menghasilkan NUMBER(19)', () => {
-  assert.strictEqual(oracle.mapType({ type: 'bigint' }), 'NUMBER(19)');
-});
-
-test('oracle: mapType text menghasilkan CLOB', () => {
-  assert.strictEqual(oracle.mapType({ type: 'text' }), 'CLOB');
-});
-
-test('oracle: mapType string dengan length menghasilkan VARCHAR2(N)', () => {
-  assert.strictEqual(oracle.mapType({ type: 'string', length: 36 }), 'VARCHAR2(36)');
-});
-
-test('oracle: mapType decimal menghasilkan NUMBER(M,N)', () => {
-  assert.strictEqual(oracle.mapType({ type: 'decimal', precision: 15, scale: 2 }), 'NUMBER(15,2)');
-});
-
-test('oracle: mapType boolean menghasilkan VARCHAR2(5) sesuai konvensi runtime', () => {
-  assert.strictEqual(oracle.mapType({ type: 'boolean' }), 'VARCHAR2(5)');
-});
-
-test('oracle: mapType uuid menghasilkan VARCHAR2(36)', () => {
-  assert.strictEqual(oracle.mapType({ type: 'uuid' }), 'VARCHAR2(36)');
-});
-
-test('oracle: mapType json menghasilkan CLOB', () => {
-  assert.strictEqual(oracle.mapType({ type: 'json' }), 'CLOB');
-});
-
-test('oracle: mapType date menghasilkan DATE', () => {
-  assert.strictEqual(oracle.mapType({ type: 'date' }), 'DATE');
-});
-
-test('oracle: mapType timestamp menghasilkan TIMESTAMP', () => {
-  assert.strictEqual(oracle.mapType({ type: 'timestamp' }), 'TIMESTAMP');
-});
-
-test('oracle: mapType throw bila type tidak dikenal', () => {
-  assert.throws(() => oracle.mapType({ type: 'binary' }), /Unknown type: 'binary'/);
-});
-
-test("oracle: formatDefault literal boolean true menghasilkan 'true'", () => {
-  assert.strictEqual(oracle.formatDefault({ kind: 'literal', value: true }), "'true'");
-});
-
-test("oracle: formatDefault literal boolean false menghasilkan 'false'", () => {
-  assert.strictEqual(oracle.formatDefault({ kind: 'literal', value: false }), "'false'");
-});
-
-test('oracle: formatDefault literal angka menghasilkan literal tanpa quote', () => {
-  assert.strictEqual(oracle.formatDefault({ kind: 'literal', value: 0 }), '0');
-  assert.strictEqual(oracle.formatDefault({ kind: 'literal', value: 100 }), '100');
-});
-
-test('oracle: formatDefault literal string menghasilkan single quote wrapped', () => {
-  assert.strictEqual(oracle.formatDefault({ kind: 'literal', value: 'INDONESIA' }), "'INDONESIA'");
-});
-
-test('oracle: formatDefault function now menghasilkan SYSTIMESTAMP (native)', () => {
-  assert.strictEqual(
-    oracle.formatDefault({ kind: 'function', name: 'now', args: [] }),
-    'SYSTIMESTAMP'
-  );
-});
-
-test('oracle: formatDefault constant current_date menghasilkan CURRENT_DATE', () => {
-  assert.strictEqual(
-    oracle.formatDefault({ kind: 'constant', value: 'current_date' }),
-    'CURRENT_DATE'
-  );
-});
-
-test('oracle: formatDefault throw bila function bukan whitelist', () => {
-  assert.throws(
-    () => oracle.formatDefault({ kind: 'function', name: 'sysdate', args: [] }),
-    /Unknown function: 'sysdate'/
-  );
-});
-
-test('oracle: formatDefault throw bila constant bukan whitelist', () => {
-  assert.throws(
-    () => oracle.formatDefault({ kind: 'constant', value: 'sysdate' }),
-    /Unknown constant: 'sysdate'/
-  );
-});
-
-test('oracle: quoteIdentifier identifier biasa return as-is tanpa quote', () => {
-  assert.strictEqual(oracle.quoteIdentifier('category'), 'category');
-});
-
-test('oracle: quoteIdentifier reserved word return as-is tanpa quote', () => {
-  assert.strictEqual(oracle.quoteIdentifier('user'), 'user');
-  assert.strictEqual(oracle.quoteIdentifier('order'), 'order');
-});
-
-test('oracle: quoteIdentifier throw bila identifier empty string', () => {
-  assert.throws(() => oracle.quoteIdentifier(''), /Identifier must be a non-empty string/);
-});
-
-test('oracle: formatReferentialAction memetakan semua action ke SQL', () => {
-  assert.strictEqual(oracle.formatReferentialAction('cascade'), 'CASCADE');
-  assert.strictEqual(oracle.formatReferentialAction('restrict'), 'RESTRICT');
-  assert.strictEqual(oracle.formatReferentialAction('setNull'), 'SET NULL');
-  assert.strictEqual(oracle.formatReferentialAction('noAction'), 'NO ACTION');
-});
-
-test('oracle: formatReferentialAction throw bila action tidak dikenal', () => {
-  assert.throws(
-    () => oracle.formatReferentialAction('unknown'),
-    /Unknown referential action: 'unknown'/
-  );
-});

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

@@ -1,131 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const postgres = require('../../../../../lib/dbschema-kit/dialect/postgres');
-
-test('postgres: name identifier dialect adalah postgres', () => {
-  assert.strictEqual(postgres.name, 'postgres');
-});
-
-test('postgres: mapType integer menghasilkan INTEGER', () => {
-  assert.strictEqual(postgres.mapType({ type: 'integer' }), 'INTEGER');
-});
-
-test('postgres: mapType bigint menghasilkan BIGINT', () => {
-  assert.strictEqual(postgres.mapType({ type: 'bigint' }), 'BIGINT');
-});
-
-test('postgres: mapType text menghasilkan TEXT', () => {
-  assert.strictEqual(postgres.mapType({ type: 'text' }), 'TEXT');
-});
-
-test('postgres: mapType string dengan length menghasilkan VARCHAR(N)', () => {
-  assert.strictEqual(postgres.mapType({ type: 'string', length: 36 }), 'VARCHAR(36)');
-});
-
-test('postgres: mapType decimal dengan precision dan scale menghasilkan DECIMAL(M,N)', () => {
-  assert.strictEqual(postgres.mapType({ type: 'decimal', precision: 15, scale: 2 }), 'DECIMAL(15,2)');
-});
-
-test('postgres: mapType boolean native menghasilkan BOOLEAN', () => {
-  assert.strictEqual(postgres.mapType({ type: 'boolean' }), 'BOOLEAN');
-});
-
-test('postgres: mapType uuid native menghasilkan UUID', () => {
-  assert.strictEqual(postgres.mapType({ type: 'uuid' }), 'UUID');
-});
-
-test('postgres: mapType json menghasilkan JSONB', () => {
-  assert.strictEqual(postgres.mapType({ type: 'json' }), 'JSONB');
-});
-
-test('postgres: mapType date menghasilkan DATE', () => {
-  assert.strictEqual(postgres.mapType({ type: 'date' }), 'DATE');
-});
-
-test('postgres: mapType timestamp menghasilkan TIMESTAMP', () => {
-  assert.strictEqual(postgres.mapType({ type: 'timestamp' }), 'TIMESTAMP');
-});
-
-test('postgres: mapType throw bila type tidak dikenal', () => {
-  assert.throws(() => postgres.mapType({ type: 'binary' }), /Unknown type: 'binary'/);
-});
-
-test('postgres: formatDefault literal boolean true menghasilkan TRUE', () => {
-  assert.strictEqual(postgres.formatDefault({ kind: 'literal', value: true }), 'TRUE');
-});
-
-test('postgres: formatDefault literal boolean false menghasilkan FALSE', () => {
-  assert.strictEqual(postgres.formatDefault({ kind: 'literal', value: false }), 'FALSE');
-});
-
-test('postgres: formatDefault literal angka menghasilkan literal tanpa quote', () => {
-  assert.strictEqual(postgres.formatDefault({ kind: 'literal', value: 0 }), '0');
-  assert.strictEqual(postgres.formatDefault({ kind: 'literal', value: -5 }), '-5');
-  assert.strictEqual(postgres.formatDefault({ kind: 'literal', value: 100 }), '100');
-});
-
-test('postgres: formatDefault literal string menghasilkan single quote wrapped', () => {
-  assert.strictEqual(postgres.formatDefault({ kind: 'literal', value: 'INDONESIA' }), "'INDONESIA'");
-});
-
-test('postgres: formatDefault literal string escape single quote dengan double-up', () => {
-  assert.strictEqual(postgres.formatDefault({ kind: 'literal', value: "O'Brien" }), "'O''Brien'");
-});
-
-test('postgres: formatDefault function now menghasilkan CURRENT_TIMESTAMP', () => {
-  assert.strictEqual(
-    postgres.formatDefault({ kind: 'function', name: 'now', args: [] }),
-    'CURRENT_TIMESTAMP'
-  );
-});
-
-test('postgres: formatDefault constant current_date menghasilkan CURRENT_DATE', () => {
-  assert.strictEqual(
-    postgres.formatDefault({ kind: 'constant', value: 'current_date' }),
-    'CURRENT_DATE'
-  );
-});
-
-test('postgres: formatDefault throw bila function bukan whitelist', () => {
-  assert.throws(
-    () => postgres.formatDefault({ kind: 'function', name: 'uuid_generate_v4', args: [] }),
-    /Unknown function: 'uuid_generate_v4'/
-  );
-});
-
-test('postgres: formatDefault throw bila constant bukan whitelist', () => {
-  assert.throws(
-    () => postgres.formatDefault({ kind: 'constant', value: 'current_user' }),
-    /Unknown constant: 'current_user'/
-  );
-});
-
-test('postgres: quoteIdentifier identifier biasa return as-is tanpa quote', () => {
-  assert.strictEqual(postgres.quoteIdentifier('category'), 'category');
-});
-
-test('postgres: quoteIdentifier reserved word return as-is tanpa quote', () => {
-  assert.strictEqual(postgres.quoteIdentifier('user'), 'user');
-  assert.strictEqual(postgres.quoteIdentifier('order'), 'order');
-});
-
-test('postgres: quoteIdentifier throw bila identifier empty string', () => {
-  assert.throws(() => postgres.quoteIdentifier(''), /Identifier must be a non-empty string/);
-});
-
-test('postgres: formatReferentialAction memetakan semua action ke SQL', () => {
-  assert.strictEqual(postgres.formatReferentialAction('cascade'), 'CASCADE');
-  assert.strictEqual(postgres.formatReferentialAction('restrict'), 'RESTRICT');
-  assert.strictEqual(postgres.formatReferentialAction('setNull'), 'SET NULL');
-  assert.strictEqual(postgres.formatReferentialAction('noAction'), 'NO ACTION');
-});
-
-test('postgres: formatReferentialAction throw bila action tidak dikenal', () => {
-  assert.throws(
-    () => postgres.formatReferentialAction('unknown'),
-    /Unknown referential action: 'unknown'/
-  );
-});

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

@@ -1,126 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const sqlite = require('../../../../../lib/dbschema-kit/dialect/sqlite');
-
-test('sqlite: name identifier dialect adalah sqlite', () => {
-  assert.strictEqual(sqlite.name, 'sqlite');
-});
-
-test('sqlite: mapType integer menghasilkan INTEGER', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'integer' }), 'INTEGER');
-});
-
-test('sqlite: mapType bigint menghasilkan BIGINT', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'bigint' }), 'BIGINT');
-});
-
-test('sqlite: mapType text menghasilkan TEXT', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'text' }), 'TEXT');
-});
-
-test('sqlite: mapType string dengan length menghasilkan VARCHAR(N)', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'string', length: 36 }), 'VARCHAR(36)');
-});
-
-test('sqlite: mapType decimal menghasilkan DECIMAL(M,N)', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'decimal', precision: 15, scale: 2 }), 'DECIMAL(15,2)');
-});
-
-test('sqlite: mapType boolean menghasilkan VARCHAR(5) sesuai konvensi runtime', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'boolean' }), 'VARCHAR(5)');
-});
-
-test('sqlite: mapType uuid menghasilkan VARCHAR(36)', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'uuid' }), 'VARCHAR(36)');
-});
-
-test('sqlite: mapType json menghasilkan TEXT', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'json' }), 'TEXT');
-});
-
-test('sqlite: mapType date menghasilkan DATE', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'date' }), 'DATE');
-});
-
-test('sqlite: mapType timestamp menghasilkan TIMESTAMP', () => {
-  assert.strictEqual(sqlite.mapType({ type: 'timestamp' }), 'TIMESTAMP');
-});
-
-test('sqlite: mapType throw bila type tidak dikenal', () => {
-  assert.throws(() => sqlite.mapType({ type: 'binary' }), /Unknown type: 'binary'/);
-});
-
-test("sqlite: formatDefault literal boolean true menghasilkan 'true'", () => {
-  assert.strictEqual(sqlite.formatDefault({ kind: 'literal', value: true }), "'true'");
-});
-
-test("sqlite: formatDefault literal boolean false menghasilkan 'false'", () => {
-  assert.strictEqual(sqlite.formatDefault({ kind: 'literal', value: false }), "'false'");
-});
-
-test('sqlite: formatDefault literal angka menghasilkan literal tanpa quote', () => {
-  assert.strictEqual(sqlite.formatDefault({ kind: 'literal', value: 0 }), '0');
-  assert.strictEqual(sqlite.formatDefault({ kind: 'literal', value: 100 }), '100');
-});
-
-test('sqlite: formatDefault literal string menghasilkan single quote wrapped', () => {
-  assert.strictEqual(sqlite.formatDefault({ kind: 'literal', value: 'INDONESIA' }), "'INDONESIA'");
-});
-
-test('sqlite: formatDefault function now menghasilkan CURRENT_TIMESTAMP', () => {
-  assert.strictEqual(
-    sqlite.formatDefault({ kind: 'function', name: 'now', args: [] }),
-    'CURRENT_TIMESTAMP'
-  );
-});
-
-test('sqlite: formatDefault constant current_date menghasilkan CURRENT_DATE', () => {
-  assert.strictEqual(
-    sqlite.formatDefault({ kind: 'constant', value: 'current_date' }),
-    'CURRENT_DATE'
-  );
-});
-
-test('sqlite: formatDefault throw bila function bukan whitelist', () => {
-  assert.throws(
-    () => sqlite.formatDefault({ kind: 'function', name: 'datetime', args: [] }),
-    /Unknown function: 'datetime'/
-  );
-});
-
-test('sqlite: formatDefault throw bila constant bukan whitelist', () => {
-  assert.throws(
-    () => sqlite.formatDefault({ kind: 'constant', value: 'current_time' }),
-    /Unknown constant: 'current_time'/
-  );
-});
-
-test('sqlite: quoteIdentifier identifier biasa return as-is tanpa quote', () => {
-  assert.strictEqual(sqlite.quoteIdentifier('category'), 'category');
-});
-
-test('sqlite: quoteIdentifier reserved word return as-is tanpa quote', () => {
-  assert.strictEqual(sqlite.quoteIdentifier('user'), 'user');
-  assert.strictEqual(sqlite.quoteIdentifier('order'), 'order');
-});
-
-test('sqlite: quoteIdentifier throw bila identifier empty string', () => {
-  assert.throws(() => sqlite.quoteIdentifier(''), /Identifier must be a non-empty string/);
-});
-
-test('sqlite: formatReferentialAction memetakan semua action ke SQL', () => {
-  assert.strictEqual(sqlite.formatReferentialAction('cascade'), 'CASCADE');
-  assert.strictEqual(sqlite.formatReferentialAction('restrict'), 'RESTRICT');
-  assert.strictEqual(sqlite.formatReferentialAction('setNull'), 'SET NULL');
-  assert.strictEqual(sqlite.formatReferentialAction('noAction'), 'NO ACTION');
-});
-
-test('sqlite: formatReferentialAction throw bila action tidak dikenal', () => {
-  assert.throws(
-    () => sqlite.formatReferentialAction('unknown'),
-    /Unknown referential action: 'unknown'/
-  );
-});

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

@@ -1,93 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { loadDriver, DIALECT_TO_PACKAGE } = require('../../../../lib/dbschema-kit/driver-loader');
-
-function makeMockRequire(behavior) {
-  return function mockRequire(packageName) {
-    if (typeof behavior === 'function') return behavior(packageName);
-    if (behavior && Object.prototype.hasOwnProperty.call(behavior, packageName)) {
-      const result = behavior[packageName];
-      if (result instanceof Error) throw result;
-      return result;
-    }
-    const err = new Error(`Cannot find module '${packageName}'`);
-    err.code = 'MODULE_NOT_FOUND';
-    throw err;
-  };
-}
-
-test('driver-loader: DIALECT_TO_PACKAGE mapping mencakup keempat dialect resmi', () => {
-  assert.deepStrictEqual(Object.keys(DIALECT_TO_PACKAGE).sort(), [
-    'mysql',
-    'oracle',
-    'postgres',
-    'sqlite'
-  ]);
-  assert.strictEqual(DIALECT_TO_PACKAGE.postgres, 'pg');
-  assert.strictEqual(DIALECT_TO_PACKAGE.mysql, 'mysql2/promise');
-  assert.strictEqual(DIALECT_TO_PACKAGE.oracle, 'oracledb');
-  assert.strictEqual(DIALECT_TO_PACKAGE.sqlite, 'better-sqlite3');
-});
-
-test('driver-loader: loadDriver return modul bila package tersedia (mock require)', () => {
-  const fakePg = { Client: function FakeClient() {} };
-  const _requireFn = makeMockRequire({ pg: fakePg });
-  const result = loadDriver('postgres', { _requireFn });
-  assert.strictEqual(result, fakePg);
-});
-
-test('driver-loader: loadDriver throw "Unknown dialect" untuk dialect tidak dikenal', () => {
-  assert.throws(
-    () => loadDriver('unknown'),
-    /Unknown dialect: 'unknown'\. Supported: postgres, mysql, oracle, sqlite/
-  );
-});
-
-test('driver-loader: loadDriver throw dengan instruksi install bila MODULE_NOT_FOUND', () => {
-  const _requireFn = makeMockRequire({}); // semua package throw MODULE_NOT_FOUND
-  let caught;
-  try {
-    loadDriver('postgres', { _requireFn });
-  } catch (err) {
-    caught = err;
-  }
-  assert.ok(caught, 'harus throw error');
-  assert.match(caught.message, /Database driver 'pg' not found/);
-  assert.match(caught.message, /Install with: npm install pg/);
-  assert.strictEqual(caught.code, 'DRIVER_NOT_FOUND');
-  assert.strictEqual(caught.dialect, 'postgres');
-  assert.strictEqual(caught.packageName, 'pg');
-});
-
-test('driver-loader: instruksi install untuk mysql pakai nama package "mysql2" (bukan "mysql2/promise")', () => {
-  const _requireFn = makeMockRequire({});
-  let caught;
-  try {
-    loadDriver('mysql', { _requireFn });
-  } catch (err) {
-    caught = err;
-  }
-  assert.match(caught.message, /Database driver 'mysql2' not found/);
-  assert.match(caught.message, /Install with: npm install mysql2/);
-  assert.strictEqual(caught.packageName, 'mysql2');
-});
-
-test('driver-loader: error non-MODULE_NOT_FOUND di-bubble up apa adanya', () => {
-  const syntaxErr = new SyntaxError('Unexpected token in driver internals');
-  const _requireFn = makeMockRequire({ pg: syntaxErr });
-  assert.throws(() => loadDriver('postgres', { _requireFn }), (err) => {
-    assert.ok(err instanceof SyntaxError);
-    assert.strictEqual(err.message, 'Unexpected token in driver internals');
-    return true;
-  });
-});
-
-test('driver-loader: loadDriver tanpa options pakai require Node default', () => {
-  // dependency 'pg' terdaftar di package.json runtime, jadi panggilan ini harus sukses.
-  const driver = loadDriver('postgres');
-  assert.ok(driver, 'pg module harus loadable');
-  assert.strictEqual(typeof driver.Client, 'function');
-});