@restforgejs/platform 4.1.1 → 4.3.1

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/introspect-stubs/two-tables.js

@@ -1,66 +0,0 @@
-'use strict';
-
-/**
- * Stub introspector returning a small two-table dataset (`category` + `item_product`).
- * Used by dbschema-introspect CLI tests to exercise bulk + single-table modes
- * without touching a real database.
- */
-
-const TABLES = {
-    category: {
-        tableName: 'category',
-        columns: [
-            { column_name: 'category_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'code', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 20 },
-            { column_name: 'name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 100 },
-            { column_name: 'is_active', data_type: 'boolean', udt_name: 'bool',
-              column_default: 'true', is_nullable: 'YES' }
-        ],
-        primaryKey: ['category_id'],
-        uniques: [{ name: 'uq_category_code', columns: ['code'] }],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_category', columns: ['category_id'], unique: true, primary: true },
-            { name: 'idx_is_active', columns: ['is_active'], unique: false, primary: false }
-        ],
-        checks: []
-    },
-    item_product: {
-        tableName: 'item_product',
-        columns: [
-            { column_name: 'item_product_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'category_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'product_name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 100 }
-        ],
-        primaryKey: ['item_product_id'],
-        uniques: [],
-        foreignKeys: [{
-            name: 'fk_item_category',
-            columns: ['category_id'],
-            references: { schema: 'public', table: 'category', columns: ['category_id'] },
-            onDelete: 'CASCADE',
-            onUpdate: null
-        }],
-        indexes: [
-            { name: 'pk_item_product', columns: ['item_product_id'], unique: true, primary: true }
-        ],
-        checks: []
-    }
-};
-
-async function introspect({ table }) {
-    if (table) {
-        const meta = TABLES[table];
-        if (!meta) return { tables: [] };
-        return { tables: [meta] };
-    }
-    return { tables: Object.values(TABLES) };
-}
-
-module.exports = { introspect };

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/migrate-stubs/connection-error.js

@@ -1,9 +0,0 @@
-'use strict';
-
-async function applyStatements(_options) {
-  const err = new Error('connect ECONNREFUSED 127.0.0.1:5432');
-  err.code = 'ECONNREFUSED';
-  throw err;
-}
-
-module.exports = { applyStatements };

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/migrate-stubs/partial.js

@@ -1,29 +0,0 @@
-'use strict';
-
-async function applyStatements(options) {
-  const total = options.statements.length;
-  if (typeof options.onProgress === 'function' && total >= 1) {
-    options.onProgress({ index: 1, total, statement: options.statements[0], status: 'running' });
-    options.onProgress({ index: 1, total, statement: options.statements[0], status: 'success' });
-    if (total >= 2) {
-      options.onProgress({
-        index: 2,
-        total,
-        statement: options.statements[1],
-        status: 'error',
-        error: new Error("Table 'foo' already exists")
-      });
-    }
-  }
-
-  return {
-    applied: 1,
-    failed: 1,
-    durationMs: 8,
-    status: 'PARTIAL',
-    failedIndex: 2,
-    failedStatement: options.statements[1] || ''
-  };
-}
-
-module.exports = { applyStatements };

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/migrate-stubs/rollback.js

@@ -1,26 +0,0 @@
-'use strict';
-
-async function applyStatements(options) {
-  const total = options.statements.length;
-  if (typeof options.onProgress === 'function' && total >= 1) {
-    options.onProgress({ index: 1, total, statement: options.statements[0], status: 'running' });
-    options.onProgress({
-      index: 1,
-      total,
-      statement: options.statements[0],
-      status: 'error',
-      error: new Error('column "id" does not exist')
-    });
-  }
-
-  const err = new Error('column "id" does not exist');
-  err.status = 'ROLLBACK';
-  err.applied = 0;
-  err.failed = 1;
-  err.failedIndex = 1;
-  err.failedStatement = options.statements[0] || '';
-  err.durationMs = 4;
-  throw err;
-}
-
-module.exports = { applyStatements };

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/migrate-stubs/success.js

@@ -1,43 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-
-async function applyStatements(options) {
-  const recordPath = process.env.DBSCHEMA_KIT_TEST_RECORD_FILE;
-  if (recordPath) {
-    fs.writeFileSync(
-      recordPath,
-      JSON.stringify({
-        statements: options.statements,
-        dialect: options.dialect,
-        config: options.config
-      }, null, 2)
-    );
-  }
-
-  if (typeof options.onProgress === 'function') {
-    for (let i = 0; i < options.statements.length; i++) {
-      options.onProgress({
-        index: i + 1,
-        total: options.statements.length,
-        statement: options.statements[i],
-        status: 'running'
-      });
-      options.onProgress({
-        index: i + 1,
-        total: options.statements.length,
-        statement: options.statements[i],
-        status: 'success'
-      });
-    }
-  }
-
-  return {
-    applied: options.statements.length,
-    failed: 0,
-    durationMs: 5,
-    status: 'SUCCESS'
-  };
-}
-
-module.exports = { applyStatements };

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/multi-schema/audit/events.js

@@ -1,18 +0,0 @@
-'use strict';
-
-module.exports = ({ defineModel }) => defineModel('events', {
-  schema: 'audit',
-  fields: {
-    event_id: 'uuid pk',
-    product_id: 'uuid notnull',
-    action: 'string:50 notnull'
-  },
-  relations: {
-    product: {
-      type: 'belongsTo',
-      target: 'inventory.products',
-      localKey: 'product_id',
-      references: 'product_id'
-    }
-  }
-});

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/multi-schema/inventory/products.js

@@ -1,9 +0,0 @@
-'use strict';
-
-module.exports = ({ defineModel }) => defineModel('products', {
-  schema: 'inventory',
-  fields: {
-    product_id: 'uuid pk',
-    name: 'string:100 notnull'
-  }
-});

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/multi-schema/users.js

@@ -1,8 +0,0 @@
-'use strict';
-
-module.exports = ({ defineModel }) => defineModel('users', {
-  fields: {
-    user_id: 'uuid pk',
-    email: 'string:100 unique notnull'
-  }
-});

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

@@ -1,112 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-const path = require('path');
-
-const { loadConfig, parseConfig } = require('../../../../lib/dbschema-kit/connection');
-
-const FIXTURES = path.join(__dirname, 'fixtures', 'connection');
-
-test('connection: parseConfig parse KEY=VALUE menjadi object dengan dua key', () => {
-  const result = parseConfig('DB_TYPE=postgresql\nDB_HOST=localhost');
-  assert.deepStrictEqual(result, { DB_TYPE: 'postgresql', DB_HOST: 'localhost' });
-});
-
-test('connection: parseConfig skip baris kosong dan baris comment (#)', () => {
-  const content = [
-    '# Comment di awal',
-    '',
-    'DB_TYPE=postgresql',
-    '   ',
-    '# Comment di tengah',
-    'DB_HOST=localhost',
-    ''
-  ].join('\n');
-  const result = parseConfig(content);
-  assert.deepStrictEqual(result, { DB_TYPE: 'postgresql', DB_HOST: 'localhost' });
-});
-
-test('connection: parseConfig trim whitespace pada key dan value', () => {
-  const result = parseConfig('  DB_HOST  =  localhost  \n  DB_PORT  =  5432');
-  assert.deepStrictEqual(result, { DB_HOST: 'localhost', DB_PORT: '5432' });
-});
-
-test('connection: parseConfig throw bila baris tidak match KEY=VALUE', () => {
-  assert.throws(
-    () => parseConfig('DB_TYPE=postgresql\nINVALID_LINE_WITHOUT_EQUALS'),
-    /Invalid config line 2/
-  );
-});
-
-test('connection: parseConfig throw bila key kosong', () => {
-  assert.throws(() => parseConfig('=value'), /Key cannot be empty/);
-});
-
-test('connection: parseConfig throw bila content bukan string', () => {
-  assert.throws(() => parseConfig(null), /content must be a string/);
-});
-
-test('connection: parseConfig parse value yang mengandung tanda = (URL, dst)', () => {
-  const result = parseConfig('DB_URL=postgres://user:pass@host:5432/db?sslmode=require');
-  assert.deepStrictEqual(result, {
-    DB_URL: 'postgres://user:pass@host:5432/db?sslmode=require'
-  });
-});
-
-test('connection: loadConfig happy path postgres lengkap', () => {
-  const config = loadConfig(path.join(FIXTURES, 'postgres-valid.env'));
-  assert.strictEqual(config.dialect, 'postgres');
-  assert.strictEqual(config.host, 'localhost');
-  assert.strictEqual(config.port, 5432);
-  assert.strictEqual(typeof config.port, 'number');
-  assert.strictEqual(config.database, 'mini_inventory');
-  assert.strictEqual(config.user, 'postgres');
-  assert.strictEqual(config.password, 'secret');
-});
-
-test('connection: loadConfig SQLite hanya butuh dialect dan file', () => {
-  const config = loadConfig(path.join(FIXTURES, 'sqlite-valid.env'));
-  assert.strictEqual(config.dialect, 'sqlite');
-  assert.strictEqual(config.file, './database.sqlite');
-});
-
-test('connection: loadConfig Oracle expose serviceName dari DB_SERVICE_NAME', () => {
-  const config = loadConfig(path.join(FIXTURES, 'oracle-valid.env'));
-  assert.strictEqual(config.dialect, 'oracle');
-  assert.strictEqual(config.serviceName, 'XEPDB1');
-  assert.strictEqual(config.database, undefined);
-});
-
-test('connection: loadConfig throw bila DB_TYPE tidak ada', () => {
-  assert.throws(
-    () => loadConfig(path.join(FIXTURES, 'missing-dialect.env')),
-    /DB_TYPE not found/
-  );
-});
-
-test('connection: loadConfig throw bila DB_TYPE invalid (mssql)', () => {
-  assert.throws(
-    () => loadConfig(path.join(FIXTURES, 'invalid-dialect.env')),
-    /Invalid DB_TYPE 'mssql'/
-  );
-});
-
-test('connection: loadConfig throw bila required field missing (postgresql tanpa DB_HOST)', () => {
-  assert.throws(
-    () => loadConfig(path.join(FIXTURES, 'missing-host.env')),
-    /missing required fields for postgresql: DB_HOST/
-  );
-});
-
-test('connection: loadConfig throw bila file tidak exist', () => {
-  assert.throws(
-    () => loadConfig(path.join(FIXTURES, 'nonexistent.env')),
-    /Config file not found/
-  );
-});
-
-test('connection: loadConfig throw bila filePath bukan string', () => {
-  assert.throws(() => loadConfig(null), /filePath must be a non-empty string/);
-  assert.throws(() => loadConfig(''), /filePath must be a non-empty string/);
-});

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

@@ -1,205 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-const path = require('node:path');
-
-const { defineModel } = require('../../../../lib/dbschema-kit/define-model');
-const { loadSchemaFolder } = require('../../../../lib/dbschema-kit/loader');
-const { generateDDL } = require('../../../../lib/dbschema-kit/ddl-generator');
-
-const FIXTURE_VALID = path.resolve(__dirname, 'fixtures', 'integration', 'mini-inventory');
-
-test('ddl-generator: tabel tunggal + dialect postgres menghasilkan header + CREATE TABLE tanpa DROP/INDEX section bila tidak ada index', () => {
-  const ir = defineModel('only_table', {
-    fields: {
-      only_table_id: 'string:36 pk',
-      name: 'string:100 notnull'
-    }
-  });
-  const models = new Map([['only_table', ir]]);
-
-  const sql = generateDDL(models, { dialect: 'postgres' });
-
-  assert.match(sql, /-- Generated by dbschema:generate-ddl/);
-  assert.match(sql, /-- Dialect: postgres/);
-  assert.match(sql, /-- Generated at: \d{4}-\d{2}-\d{2}T/);
-  assert.match(sql, /-- CREATE TABLE section/);
-  assert.match(sql, /CREATE TABLE only_table/);
-  assert.doesNotMatch(sql, /-- DROP section/);
-  assert.doesNotMatch(sql, /-- CREATE INDEX section/);
-});
-
-test('ddl-generator: drop=true menambahkan section DROP dengan header "-- DROP section"', () => {
-  const ir = defineModel('only_table', {
-    fields: { only_table_id: 'string:36 pk' }
-  });
-  const models = new Map([['only_table', ir]]);
-
-  const sql = generateDDL(models, { dialect: 'postgres', drop: true });
-
-  assert.match(sql, /-- DROP section/);
-  assert.match(sql, /DROP TABLE IF EXISTS only_table CASCADE;/);
-  // DROP harus muncul sebelum CREATE TABLE
-  const dropIdx = sql.indexOf('DROP TABLE');
-  const createIdx = sql.indexOf('CREATE TABLE');
-  assert.ok(dropIdx > 0 && dropIdx < createIdx, 'DROP harus sebelum CREATE TABLE');
-});
-
-test('ddl-generator: DROP order = reverse topological (child sebelum parent)', () => {
-  const parent = defineModel('parent', {
-    fields: { parent_id: 'string:36 pk' }
-  });
-  const child = defineModel('child', {
-    fields: {
-      child_id: 'string:36 pk',
-      parent_id: 'string:36 notnull'
-    },
-    relations: {
-      parent: { type: 'belongsTo', target: 'parent', localKey: 'parent_id', references: 'parent_id' }
-    }
-  });
-
-  const models = new Map([['parent', parent], ['child', child]]);
-  const sql = generateDDL(models, { dialect: 'postgres', drop: true });
-
-  const dropChildIdx = sql.indexOf('DROP TABLE IF EXISTS child');
-  const dropParentIdx = sql.indexOf('DROP TABLE IF EXISTS parent');
-  assert.ok(dropChildIdx > 0 && dropParentIdx > 0);
-  assert.ok(dropChildIdx < dropParentIdx, 'DROP child harus sebelum DROP parent');
-
-  // CREATE order kebalikannya
-  const createParentIdx = sql.indexOf('CREATE TABLE parent');
-  const createChildIdx = sql.indexOf('CREATE TABLE child');
-  assert.ok(createParentIdx < createChildIdx, 'CREATE parent harus sebelum CREATE child');
-});
-
-test('ddl-generator: multiple tables dengan FK menghasilkan CREATE order = topological (parent dulu)', () => {
-  const models = loadSchemaFolder(FIXTURE_VALID);
-  const sql = generateDDL(models, { dialect: 'postgres' });
-
-  const categoryIdx = sql.indexOf('CREATE TABLE category');
-  const itemProductIdx = sql.indexOf('CREATE TABLE item_product');
-  assert.ok(categoryIdx > 0 && itemProductIdx > 0);
-  assert.ok(categoryIdx < itemProductIdx, 'category harus sebelum item_product (item_product punya FK ke category)');
-
-  const stockInboundIdx = sql.indexOf('CREATE TABLE stock_inbound');
-  const stockInboundItemIdx = sql.indexOf('CREATE TABLE stock_inbound_item');
-  assert.ok(stockInboundIdx < stockInboundItemIdx, 'stock_inbound harus sebelum stock_inbound_item');
-});
-
-test('ddl-generator: tabel dengan index menghasilkan CREATE INDEX section di akhir, urut topological', () => {
-  const a = defineModel('parent_idx', {
-    fields: {
-      parent_idx_id: 'string:36 pk',
-      name: 'string:100 notnull',
-      flag: 'boolean'
-    },
-    indexes: ['flag']
-  });
-  const b = defineModel('child_idx', {
-    fields: {
-      child_idx_id: 'string:36 pk',
-      parent_idx_id: 'string:36 notnull',
-      tag: 'string:50'
-    },
-    indexes: ['tag'],
-    relations: {
-      parent: { type: 'belongsTo', target: 'parent_idx', localKey: 'parent_idx_id', references: 'parent_idx_id' }
-    }
-  });
-
-  const models = new Map([['child_idx', b], ['parent_idx', a]]);
-  const sql = generateDDL(models, { dialect: 'postgres' });
-
-  assert.match(sql, /-- CREATE INDEX section/);
-
-  const indexSectionIdx = sql.indexOf('-- CREATE INDEX section');
-  const lastCreateTableIdx = sql.lastIndexOf('CREATE TABLE');
-  assert.ok(indexSectionIdx > lastCreateTableIdx, 'CREATE INDEX section harus setelah semua CREATE TABLE');
-
-  // Urutan index ikut topological tabel: parent_idx index muncul sebelum child_idx index
-  const idxParent = sql.indexOf('ON parent_idx');
-  const idxChild = sql.indexOf('ON child_idx');
-  assert.ok(idxParent > 0 && idxChild > 0);
-  assert.ok(idxParent < idxChild, 'index parent_idx harus sebelum index child_idx');
-});
-
-test('ddl-generator: map kosong menghasilkan output hanya header, tanpa section', () => {
-  const sql = generateDDL(new Map(), { dialect: 'postgres' });
-
-  assert.match(sql, /-- Generated by dbschema:generate-ddl/);
-  assert.match(sql, /-- Dialect: postgres/);
-  assert.doesNotMatch(sql, /-- DROP section/);
-  assert.doesNotMatch(sql, /-- CREATE TABLE section/);
-  assert.doesNotMatch(sql, /-- CREATE INDEX section/);
-  assert.doesNotMatch(sql, /CREATE TABLE/);
-});
-
-test('ddl-generator: dialect mysql emit identifier tanpa quote', () => {
-  const ir = defineModel('only_table', {
-    fields: {
-      only_table_id: 'string:36 pk',
-      name: 'string:100 notnull'
-    }
-  });
-  const models = new Map([['only_table', ir]]);
-
-  const sql = generateDDL(models, { dialect: 'mysql' });
-
-  assert.match(sql, /-- Dialect: mysql/);
-  assert.match(sql, /CREATE TABLE only_table/);
-  assert.match(sql, /only_table_id VARCHAR/);
-});
-
-test('ddl-generator: dialect oracle dengan drop=true emit DROP berbentuk PL/SQL block tanpa `;` setelah `/`', () => {
-  const ir = defineModel('only_table', {
-    fields: { only_table_id: 'string:36 pk' }
-  });
-  const models = new Map([['only_table', ir]]);
-
-  const sql = generateDDL(models, { dialect: 'oracle', drop: true });
-
-  assert.match(sql, /BEGIN/);
-  assert.match(sql, /EXECUTE IMMEDIATE 'DROP TABLE only_table CASCADE CONSTRAINTS'/);
-  assert.match(sql, /EXCEPTION/);
-  assert.match(sql, /END;/);
-  // Tidak boleh ada `;` setelah `/` di Oracle DROP block
-  assert.doesNotMatch(sql, /\/;/);
-  // Pastikan ada `/` terminator pada baris tersendiri
-  assert.match(sql, /\n\/\n/);
-});
-
-test('ddl-generator: header comment menyertakan timestamp ISO 8601 (UTC)', () => {
-  const ir = defineModel('only_table', { fields: { only_table_id: 'string:36 pk' } });
-  const models = new Map([['only_table', ir]]);
-
-  const sql = generateDDL(models, { dialect: 'postgres' });
-  // Match ISO 8601 UTC timestamp
-  assert.match(sql, /-- Generated at: \d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z/);
-});
-
-test('ddl-generator: setiap CREATE TABLE statement diakhiri dengan `;`', () => {
-  const models = loadSchemaFolder(FIXTURE_VALID);
-  const sql = generateDDL(models, { dialect: 'postgres' });
-
-  const lines = sql.split('\n');
-  // Cari line yang mulai dengan ')' dan pastikan diikuti ';'
-  let createTableEndingFound = 0;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].trim() === ');') createTableEndingFound++;
-  }
-  assert.ok(createTableEndingFound >= 6, `expected at least 6 CREATE TABLE endings, got ${createTableEndingFound}`);
-});
-
-test('ddl-generator: input bukan Map melempar error', () => {
-  assert.throws(() => generateDDL({}, { dialect: 'postgres' }), /must be a Map/);
-  assert.throws(() => generateDDL([], { dialect: 'postgres' }), /must be a Map/);
-});
-
-test('ddl-generator: dialect tidak dikenal melempar error', () => {
-  const ir = defineModel('only_table', { fields: { only_table_id: 'string:36 pk' } });
-  const models = new Map([['only_table', ir]]);
-
-  assert.throws(() => generateDDL(models, { dialect: 'mssql' }), /Unknown dialect/);
-});

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

@@ -1,56 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { defineModel } = require('../../../../lib/dbschema-kit/define-model');
-
-test('define-model: returns IR object dengan struktur lengkap (sanity check)', () => {
-  const ir = defineModel('foo', {
-    fields: {
-      id: 'uuid pk',
-      name: 'string:20 notnull'
-    }
-  });
-  assert.strictEqual(ir.tableName, 'foo');
-  assert.ok(ir.fields, 'fields property exists');
-  assert.ok(Array.isArray(ir.primaryKey), 'primaryKey is array');
-  assert.ok(Array.isArray(ir.indexes), 'indexes is array');
-  assert.ok(Array.isArray(ir.uniques), 'uniques is array');
-  assert.strictEqual(typeof ir.relations, 'object', 'relations is object');
-  assert.ok(Array.isArray(ir.checks), 'checks is array');
-  assert.ok(ir._meta, '_meta exists');
-});
-
-test('define-model: propagate error dari parser dengan informasi tableName di error message', () => {
-  assert.throws(
-    () => defineModel('purchase_order', { fields: { status: 'string:20 uniqe' } }),
-    /^Error: Table 'purchase_order': Field 'status': unknown constraint 'uniqe'$/
-  );
-});
-
-test('define-model: mengembalikan object literal yang freezable (bukan class instance)', () => {
-  const ir = defineModel('foo', { fields: { id: 'uuid pk' } });
-  assert.strictEqual(Object.getPrototypeOf(ir), Object.prototype, 'must be plain object');
-  assert.doesNotThrow(() => Object.freeze(ir), 'should be freezable without error');
-  assert.ok(Object.isFrozen(ir), 'object should be frozen after freeze call');
-});
-
-test('define-model: throw validator error bila tableName uppercase', () => {
-  assert.throws(
-    () => defineModel('StockInbound', { fields: { id: 'string:36 pk' } }),
-    /^Error: Table name must be snake_case \(lowercase, alphanumeric, underscore, no leading digit\)$/
-  );
-});
-
-test('define-model: throw validator error bila relation localKey reference field tidak existing', () => {
-  assert.throws(
-    () => defineModel('foo', {
-      fields: { id: 'uuid pk' },
-      relations: {
-        bar: { type: 'belongsTo', localKey: 'nonexistent_field', references: 'id' }
-      }
-    }),
-    /^Error: Table 'foo': relation 'bar' references unknown field 'nonexistent_field'$/
-  );
-});

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

@@ -1,46 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { getDialect, DIALECTS } = require('../../../../../lib/dbschema-kit/dialect');
-
-test('factory: getDialect("postgres") return modul dengan name === "postgres"', () => {
-  const d = getDialect('postgres');
-  assert.strictEqual(d.name, 'postgres');
-  assert.strictEqual(typeof d.mapType, 'function');
-  assert.strictEqual(typeof d.formatDefault, 'function');
-  assert.strictEqual(typeof d.quoteIdentifier, 'function');
-  assert.strictEqual(typeof d.formatReferentialAction, 'function');
-});
-
-test('factory: getDialect("mysql") return modul dengan name === "mysql"', () => {
-  assert.strictEqual(getDialect('mysql').name, 'mysql');
-});
-
-test('factory: getDialect("oracle") return modul dengan name === "oracle"', () => {
-  assert.strictEqual(getDialect('oracle').name, 'oracle');
-});
-
-test('factory: getDialect("sqlite") return modul dengan name === "sqlite"', () => {
-  assert.strictEqual(getDialect('sqlite').name, 'sqlite');
-});
-
-test('factory: getDialect throw bila nama dialect tidak dikenal', () => {
-  assert.throws(
-    () => getDialect('mssql'),
-    /Unknown dialect: 'mssql'\. Supported: postgres, mysql, oracle, sqlite/
-  );
-});
-
-test('factory: getDialect throw bila nama undefined atau null', () => {
-  assert.throws(() => getDialect(undefined), /Unknown dialect/);
-  assert.throws(() => getDialect(null), /Unknown dialect/);
-});
-
-test('factory: DIALECTS map mengekspos keempat dialect', () => {
-  assert.deepStrictEqual(
-    Object.keys(DIALECTS).sort(),
-    ['mysql', 'oracle', 'postgres', 'sqlite']
-  );
-});