@restforgejs/platform 4.1.1 → 4.3.1

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

@@ -1,237 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { parseFieldShorthand } = require('../../../../../lib/dbschema-kit/parser/shorthand-parser');
-
-test('parser: type sederhana tanpa constraint (integer)', () => {
-  const result = parseFieldShorthand('integer', 'qty');
-  assert.deepStrictEqual(result, { type: 'integer' });
-});
-
-test('parser: type text tanpa constraint', () => {
-  const result = parseFieldShorthand('text', 'description');
-  assert.deepStrictEqual(result, { type: 'text' });
-});
-
-test('parser: string dengan length modifier', () => {
-  const result = parseFieldShorthand('string:20', 'code');
-  assert.deepStrictEqual(result, { type: 'string', length: 20 });
-});
-
-test('parser: decimal dengan precision dan scale', () => {
-  const result = parseFieldShorthand('decimal:15,2', 'amount');
-  assert.deepStrictEqual(result, { type: 'decimal', precision: 15, scale: 2 });
-});
-
-test('parser: decimal dengan scale nol', () => {
-  const result = parseFieldShorthand('decimal:15,0', 'stock');
-  assert.deepStrictEqual(result, { type: 'decimal', precision: 15, scale: 0 });
-});
-
-test('parser: uuid dengan primary key constraint', () => {
-  const result = parseFieldShorthand('uuid pk', 'category_id');
-  assert.deepStrictEqual(result, { type: 'uuid', pk: true });
-});
-
-test('parser: multiple constraint pada string field', () => {
-  const result = parseFieldShorthand('string:20 unique notnull', 'category_code');
-  assert.deepStrictEqual(result, {
-    type: 'string',
-    length: 20,
-    unique: true,
-    notnull: true
-  });
-});
-
-test('parser: default value boolean true', () => {
-  const result = parseFieldShorthand('boolean default:true', 'is_active');
-  assert.deepStrictEqual(result, {
-    type: 'boolean',
-    default: { kind: 'literal', value: true }
-  });
-});
-
-test('parser: default value boolean false', () => {
-  const result = parseFieldShorthand('boolean default:false', 'is_deleted');
-  assert.deepStrictEqual(result, {
-    type: 'boolean',
-    default: { kind: 'literal', value: false }
-  });
-});
-
-test('parser: default value integer nol', () => {
-  const result = parseFieldShorthand('integer default:0', 'qty');
-  assert.deepStrictEqual(result, {
-    type: 'integer',
-    default: { kind: 'literal', value: 0 }
-  });
-});
-
-test('parser: default value integer negatif', () => {
-  const result = parseFieldShorthand('integer default:-5', 'offset');
-  assert.deepStrictEqual(result, {
-    type: 'integer',
-    default: { kind: 'literal', value: -5 }
-  });
-});
-
-test('parser: default value string literal dengan single quote', () => {
-  const result = parseFieldShorthand("string:100 default:'INDONESIA'", 'country');
-  assert.deepStrictEqual(result, {
-    type: 'string',
-    length: 100,
-    default: { kind: 'literal', value: 'INDONESIA' }
-  });
-});
-
-test('parser: default value function call now()', () => {
-  const result = parseFieldShorthand('timestamp default:now()', 'created_at');
-  assert.deepStrictEqual(result, {
-    type: 'timestamp',
-    default: { kind: 'function', name: 'now', args: [] }
-  });
-});
-
-test('parser: default value constant identifier', () => {
-  const result = parseFieldShorthand('date default:current_date', 'inbound_date');
-  assert.deepStrictEqual(result, {
-    type: 'date',
-    default: { kind: 'constant', value: 'current_date' }
-  });
-});
-
-test('parser: foreign key shorthand dengan constraint tambahan', () => {
-  const result = parseFieldShorthand('uuid fk:category.category_id notnull', 'category_id');
-  assert.deepStrictEqual(result, {
-    type: 'uuid',
-    fk: { table: 'category', column: 'category_id' },
-    notnull: true
-  });
-});
-
-test('parser: index shorthand pada field date', () => {
-  const result = parseFieldShorthand('date index', 'inbound_date');
-  assert.deepStrictEqual(result, { type: 'date', index: true });
-});
-
-test('parser: urutan constraint tidak signifikan', () => {
-  const a = parseFieldShorthand('string:20 notnull unique', 'code');
-  const b = parseFieldShorthand('string:20 unique notnull', 'code');
-  assert.deepStrictEqual(a, b);
-});
-
-test('parser: default string literal yang mengandung spasi', () => {
-  const result = parseFieldShorthand("string:100 default:'HELLO WORLD'", 'greeting');
-  assert.deepStrictEqual(result, {
-    type: 'string',
-    length: 100,
-    default: { kind: 'literal', value: 'HELLO WORLD' }
-  });
-});
-
-test('parser: error untuk input string kosong', () => {
-  assert.throws(
-    () => parseFieldShorthand('', 'foo'),
-    /Field 'foo': shorthand must be a non-empty string/
-  );
-});
-
-test('parser: error untuk input bukan string', () => {
-  assert.throws(
-    () => parseFieldShorthand(null, 'foo'),
-    /Field 'foo': shorthand must be a non-empty string/
-  );
-});
-
-test('parser: error untuk type yang tidak dikenali', () => {
-  assert.throws(
-    () => parseFieldShorthand('foobar', 'mystery'),
-    /Field 'mystery': unknown type 'foobar'/
-  );
-});
-
-test('parser: error untuk string tanpa length modifier', () => {
-  assert.throws(
-    () => parseFieldShorthand('string', 'name'),
-    /Field 'name': type 'string' requires length modifier/
-  );
-});
-
-test('parser: error untuk string length bukan positive integer', () => {
-  assert.throws(
-    () => parseFieldShorthand('string:abc', 'name'),
-    /Field 'name': string length must be a positive integer/
-  );
-});
-
-test('parser: error untuk decimal tanpa scale', () => {
-  assert.throws(
-    () => parseFieldShorthand('decimal:15', 'amount'),
-    /Field 'amount': decimal modifier must be 'precision,scale'/
-  );
-});
-
-test('parser: error untuk decimal tanpa modifier sama sekali', () => {
-  assert.throws(
-    () => parseFieldShorthand('decimal', 'amount'),
-    /Field 'amount': type 'decimal' requires precision and scale/
-  );
-});
-
-test('parser: error untuk decimal dengan scale lebih besar dari precision', () => {
-  assert.throws(
-    () => parseFieldShorthand('decimal:5,10', 'amount'),
-    /Field 'amount': decimal scale \(10\) cannot exceed precision \(5\)/
-  );
-});
-
-test('parser: error untuk type non-modifier yang diberi modifier', () => {
-  assert.throws(
-    () => parseFieldShorthand('integer:5', 'qty'),
-    /Field 'qty': type 'integer' does not accept modifier/
-  );
-});
-
-test('parser: error untuk constraint typo unknown', () => {
-  assert.throws(
-    () => parseFieldShorthand('string:20 uniqe', 'code'),
-    /Field 'code': unknown constraint 'uniqe'/
-  );
-});
-
-test('parser: error untuk foreign key tanpa dot separator', () => {
-  assert.throws(
-    () => parseFieldShorthand('uuid fk:nodot notnull', 'parent_id'),
-    /Field 'parent_id': invalid foreign key format 'nodot'/
-  );
-});
-
-test('parser: error untuk foreign key dengan kolom kosong', () => {
-  assert.throws(
-    () => parseFieldShorthand('uuid fk:table.', 'parent_id'),
-    /Field 'parent_id': invalid foreign key format 'table\.'/
-  );
-});
-
-test('parser: error untuk constraint duplikat', () => {
-  assert.throws(
-    () => parseFieldShorthand('string:20 notnull notnull', 'code'),
-    /Field 'code': duplicate constraint 'notnull'/
-  );
-});
-
-test('parser: error untuk string literal yang tidak ditutup', () => {
-  assert.throws(
-    () => parseFieldShorthand("string:100 default:'OPEN", 'code'),
-    /Field 'code': unterminated string literal/
-  );
-});
-
-test('parser: error untuk default value yang tidak bisa di-parse', () => {
-  assert.throws(
-    () => parseFieldShorthand('integer default:!@#', 'qty'),
-    /Field 'qty': invalid default value '!@#'/
-  );
-});

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

@@ -1,251 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-const path = require('node:path');
-const fs = require('node:fs');
-const os = require('node:os');
-
-const { serialize } = require('../../../../lib/dbschema-kit/schema-printer');
-const { loadSchemaPath } = require('../../../../lib/dbschema-kit/loader');
-const { defineModel } = require('../../../../lib/dbschema-kit/define-model');
-
-const FIXED_TIMESTAMP = '2026-05-10T00:00:00.000Z';
-
-function buildIRViaDefineModel(tableName, options) {
-    return defineModel(tableName, options);
-}
-
-function withTmpFile(content, fn) {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'dbsk-printer-'));
-    const file = path.join(tmpDir, `${Date.now()}.js`);
-    fs.writeFileSync(file, content, 'utf8');
-    try {
-        return fn(file);
-    } finally {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    }
-}
-
-test('printer: IR sederhana (PK + 2 field) menghasilkan factory function valid', () => {
-    const ir = buildIRViaDefineModel('category', {
-        fields: {
-            category_id: 'string:36 pk',
-            name: 'string:100 notnull'
-        }
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /^'use strict';/);
-    assert.match(out, /module\.exports = \(\{ defineModel \}\) => defineModel\('category'/);
-    assert.match(out, /category_id: 'string:36 pk'/);
-    assert.match(out, /name: 'string:100 notnull'/);
-    assert.match(out, /\}\);\n$/);
-});
-
-test('printer: output dapat di-load oleh loadSchemaPath (round-trip parse)', () => {
-    const ir = buildIRViaDefineModel('supplier', {
-        fields: {
-            supplier_id: 'string:36 pk',
-            code: 'string:20 unique notnull',
-            name: 'string:100 notnull'
-        },
-        indexes: [['code', 'name']]
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    withTmpFile(out, (file) => {
-        const models = loadSchemaPath(file);
-        assert.strictEqual(models.size, 1);
-        const reloaded = models.get('supplier');
-        assert.strictEqual(reloaded.tableName, 'supplier');
-        assert.deepStrictEqual(reloaded.primaryKey, ['supplier_id']);
-        assert.strictEqual(reloaded.fields.code.unique, true);
-        assert.strictEqual(reloaded.fields.code.notnull, true);
-        const compositeIdx = reloaded.indexes.find((i) => i.composite);
-        assert.ok(compositeIdx, 'composite index harus terjaga setelah round-trip');
-        assert.deepStrictEqual(compositeIdx.columns, ['code', 'name']);
-    });
-});
-
-test('printer: section kosong (no uniques, no relations) tidak di-emit', () => {
-    const ir = buildIRViaDefineModel('thing', {
-        fields: {
-            thing_id: 'string:36 pk',
-            name: 'string:50 notnull'
-        }
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.doesNotMatch(out, /uniques:/);
-    assert.doesNotMatch(out, /relations:/);
-    assert.doesNotMatch(out, /checks:/);
-    assert.doesNotMatch(out, /primaryKey:/); // single PK uses shorthand on field
-});
-
-test('printer: single quote dalam value pakai wrapper double quote', () => {
-    const ir = buildIRViaDefineModel('order', {
-        fields: {
-            order_id: 'string:36 pk',
-            status: "string:20 notnull default:'active'"
-        }
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /status: "string:20 notnull default:'active'"/);
-});
-
-test('printer: composite uniques dirender sebagai array nested', () => {
-    const ir = buildIRViaDefineModel('item_warehouse', {
-        fields: {
-            item_warehouse_id: 'string:36 pk',
-            item_id: 'string:36 notnull',
-            warehouse_id: 'string:36 notnull'
-        },
-        uniques: [['item_id', 'warehouse_id']]
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /uniques: \[\s*\['item_id', 'warehouse_id'\]\s*\]/m);
-});
-
-test('printer: CHECK in dengan multiple values dirender benar', () => {
-    const ir = buildIRViaDefineModel('order', {
-        fields: {
-            order_id: 'string:36 pk',
-            status: "string:20 notnull default:'active'"
-        },
-        checks: [
-            { field: 'status', in: ['active', 'inactive', 'cancelled'] }
-        ]
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /checks:\s*\[/);
-    assert.match(out, /field: 'status', in: \['active', 'inactive', 'cancelled'\]/);
-});
-
-test('printer: relations multi-line dengan onDelete', () => {
-    const ir = buildIRViaDefineModel('stock_inbound', {
-        fields: {
-            stock_inbound_id: 'string:36 pk',
-            warehouse_id: 'string:36 notnull'
-        },
-        relations: {
-            warehouse: {
-                type: 'belongsTo',
-                target: 'warehouse',
-                localKey: 'warehouse_id',
-                references: 'warehouse_id',
-                onDelete: 'restrict'
-            }
-        }
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /relations:\s*\{/);
-    assert.match(out, /warehouse:\s*\{/);
-    assert.match(out, /type: 'belongsTo'/);
-    assert.match(out, /target: 'warehouse'/);
-    assert.match(out, /localKey: 'warehouse_id'/);
-    assert.match(out, /references: 'warehouse_id'/);
-    assert.match(out, /onDelete: 'restrict'/);
-});
-
-test('printer: header comment include timestamp valid', () => {
-    const ir = buildIRViaDefineModel('thing', {
-        fields: { thing_id: 'string:36 pk' }
-    });
-    const customStamp = '2026-05-10T12:34:56.000Z';
-    const out = serialize(ir, { timestamp: customStamp });
-    assert.match(out, new RegExp(`Generated at: ${customStamp.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')}`));
-    assert.match(out, /Schema definition for `thing`/);
-    assert.match(out, /Generated by: npx restforge schema introspect/);
-});
-
-test('printer: composite primaryKey dirender sebagai opsi terpisah', () => {
-    const ir = buildIRViaDefineModel('user_role', {
-        fields: {
-            user_id: 'string:36',
-            role_id: 'string:36'
-        },
-        primaryKey: ['user_id', 'role_id']
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /primaryKey:\s*\['user_id',\s*'role_id'\]/);
-    assert.doesNotMatch(out, /string:36 pk/);
-});
-
-test('printer: indexes single-col yang merupakan FK dilewati saat emit', () => {
-    const ir = buildIRViaDefineModel('item_product', {
-        fields: {
-            item_product_id: 'string:36 pk',
-            category_id: 'string:36 fk:category.category_id notnull'
-        }
-    });
-    // FK auto-generates an index entry, but printer should skip emitting it.
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.doesNotMatch(out, /indexes:\s*\[\s*'category_id'/);
-});
-
-// =====================================================
-// Phase 14: schema-aware printer
-// =====================================================
-
-test('printer (Phase 14): IR dengan schemaName → output emit baris schema: di body factory', () => {
-    const ir = buildIRViaDefineModel('products', {
-        schema: 'inventory',
-        fields: {
-            product_id: 'string:36 pk',
-            name: 'string:100 notnull'
-        }
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /defineModel\('products', \{/);
-    assert.match(out, /^\s{2}schema: 'inventory',$/m);
-    assert.match(out, /^\s{2}fields: \{/m);
-    // schema must appear before fields
-    const schemaIdx = out.indexOf("schema: 'inventory'");
-    const fieldsIdx = out.indexOf('fields: {');
-    assert.ok(schemaIdx < fieldsIdx && schemaIdx > 0, 'schema: must appear before fields:');
-});
-
-test('printer (Phase 14): IR tanpa schemaName → output tidak emit baris schema: (backward compat)', () => {
-    const ir = buildIRViaDefineModel('category', {
-        fields: {
-            category_id: 'string:36 pk',
-            name: 'string:50 notnull'
-        }
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.doesNotMatch(out, /^\s*schema:/m);
-});
-
-test('printer (Phase 14): output dengan schemaName dapat di-load oleh loadSchemaPath (round-trip)', () => {
-    const ir = buildIRViaDefineModel('events', {
-        schema: 'audit',
-        fields: {
-            event_id: 'string:36 pk',
-            action: 'string:50 notnull'
-        }
-    });
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    withTmpFile(out, (file) => {
-        const models = loadSchemaPath(file);
-        assert.strictEqual(models.size, 1);
-        const reloaded = models.get('audit.events');
-        assert.ok(reloaded, 'model harus terindex via qualifiedName');
-        assert.strictEqual(reloaded.schemaName, 'audit');
-        assert.strictEqual(reloaded.tableName, 'events');
-        assert.strictEqual(reloaded.qualifiedName, 'audit.events');
-    });
-});
-
-test('printer: check unparsable diemit sebagai komentar TODO', () => {
-    const ir = {
-        tableName: 'item',
-        fields: { item_id: { type: 'string', length: 36, pk: true, notnull: true } },
-        primaryKey: ['item_id'],
-        indexes: [],
-        uniques: [],
-        relations: {},
-        checks: [{ _unparsable: true, expression: 'col1 LIKE \'%foo%\'' }],
-        _meta: { hasSinglePkShorthand: true, hasCompositePrimaryKey: false, autoGeneratedRelations: [] }
-    };
-    const out = serialize(ir, { timestamp: FIXED_TIMESTAMP });
-    assert.match(out, /TODO: CHECK constraints below are not parsable/);
-    assert.match(out, /col1 LIKE '%foo%'/);
-});

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

@@ -1,105 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { applyIfNotExistsModifier } = require('../../../../lib/dbschema-kit/statement-modifier');
-
-test('modifier: Postgres CREATE TABLE → tambah IF NOT EXISTS', () => {
-  const stmt = 'CREATE TABLE foo (id UUID NOT NULL)';
-  const out = applyIfNotExistsModifier(stmt, 'postgres');
-  assert.strictEqual(out, 'CREATE TABLE IF NOT EXISTS foo (id UUID NOT NULL)');
-});
-
-test('modifier: Postgres CREATE INDEX → tambah IF NOT EXISTS', () => {
-  const stmt = 'CREATE INDEX idx_foo ON foo (col_a)';
-  const out = applyIfNotExistsModifier(stmt, 'postgres');
-  assert.strictEqual(out, 'CREATE INDEX IF NOT EXISTS idx_foo ON foo (col_a)');
-});
-
-test('modifier: MySQL CREATE TABLE → tambah IF NOT EXISTS', () => {
-  const stmt = 'CREATE TABLE category (id BIGINT)';
-  const out = applyIfNotExistsModifier(stmt, 'mysql');
-  assert.strictEqual(out, 'CREATE TABLE IF NOT EXISTS category (id BIGINT)');
-});
-
-test('modifier: SQLite CREATE TABLE → tambah IF NOT EXISTS', () => {
-  const stmt = 'CREATE TABLE foo (id INTEGER PRIMARY KEY)';
-  const out = applyIfNotExistsModifier(stmt, 'sqlite');
-  assert.strictEqual(out, 'CREATE TABLE IF NOT EXISTS foo (id INTEGER PRIMARY KEY)');
-});
-
-test('modifier: Oracle CREATE TABLE → wrap dalam BEGIN ... EXCEPTION ... END dengan SQLCODE -955', () => {
-  const stmt = 'CREATE TABLE category (category_id VARCHAR2(36) NOT NULL)';
-  const out = applyIfNotExistsModifier(stmt, 'oracle');
-  assert.match(out, /^BEGIN\n/);
-  assert.match(out, /EXECUTE IMMEDIATE '/);
-  assert.match(out, /CREATE TABLE category/);
-  assert.match(out, /EXCEPTION/);
-  assert.match(out, /WHEN OTHERS THEN/);
-  assert.match(out, /IF SQLCODE != -955 THEN RAISE; END IF;/);
-  assert.match(out, /END;$/);
-  // Tidak ada terminator / di output (statement-splitter tidak suka)
-  assert.ok(!out.endsWith('/'));
-});
-
-test('modifier: Oracle CREATE TABLE dengan apostrophe DEFAULT → escape jadi double quote', () => {
-  const stmt = "CREATE TABLE category (is_active VARCHAR2(5) DEFAULT 'true')";
-  const out = applyIfNotExistsModifier(stmt, 'oracle');
-  // Original ' harus jadi '' di dalam EXECUTE IMMEDIATE string literal
-  assert.match(out, /EXECUTE IMMEDIATE 'CREATE TABLE category \(is_active VARCHAR2\(5\) DEFAULT ''true''\)';/);
-});
-
-test('modifier: Oracle CREATE INDEX → wrap dalam PL/SQL block (SQLCODE -955)', () => {
-  const stmt = 'CREATE INDEX idx_foo ON foo (col_a)';
-  const out = applyIfNotExistsModifier(stmt, 'oracle');
-  assert.match(out, /^BEGIN/);
-  assert.match(out, /EXECUTE IMMEDIATE 'CREATE INDEX idx_foo ON foo \(col_a\)';/);
-  assert.match(out, /IF SQLCODE != -955 THEN RAISE; END IF;/);
-});
-
-test('modifier: DROP statement → return as-is (semua dialect)', () => {
-  const stmt = 'DROP TABLE IF EXISTS foo CASCADE';
-  assert.strictEqual(applyIfNotExistsModifier(stmt, 'postgres'), stmt);
-  assert.strictEqual(applyIfNotExistsModifier(stmt, 'mysql'), stmt);
-  assert.strictEqual(applyIfNotExistsModifier(stmt, 'sqlite'), stmt);
-  assert.strictEqual(applyIfNotExistsModifier(stmt, 'oracle'), stmt);
-});
-
-test('modifier: statement sudah ada IF NOT EXISTS → idempotent (no double insert)', () => {
-  const stmt = 'CREATE TABLE IF NOT EXISTS foo (id UUID)';
-  assert.strictEqual(applyIfNotExistsModifier(stmt, 'postgres'), stmt);
-  assert.strictEqual(applyIfNotExistsModifier(stmt, 'mysql'), stmt);
-
-  const idxStmt = 'CREATE INDEX IF NOT EXISTS idx_foo ON foo (col_a)';
-  assert.strictEqual(applyIfNotExistsModifier(idxStmt, 'postgres'), idxStmt);
-});
-
-test('modifier: CREATE UNIQUE INDEX → tambah IF NOT EXISTS sambil pertahankan UNIQUE', () => {
-  const stmt = 'CREATE UNIQUE INDEX idx_foo ON foo (col_a)';
-  const out = applyIfNotExistsModifier(stmt, 'postgres');
-  assert.strictEqual(out, 'CREATE UNIQUE INDEX IF NOT EXISTS idx_foo ON foo (col_a)');
-});
-
-test('modifier: Postgres multi-line CREATE TABLE → IF NOT EXISTS hanya di header', () => {
-  const stmt = [
-    'CREATE TABLE foo (',
-    '    id UUID NOT NULL,',
-    '    PRIMARY KEY (id)',
-    ')'
-  ].join('\n');
-  const out = applyIfNotExistsModifier(stmt, 'postgres');
-  assert.match(out, /^CREATE TABLE IF NOT EXISTS foo \(\n/);
-  assert.match(out, /PRIMARY KEY \(id\)/);
-  // Hanya satu kemunculan IF NOT EXISTS
-  const occurrences = (out.match(/IF NOT EXISTS/g) || []).length;
-  assert.strictEqual(occurrences, 1);
-});
-
-test('modifier: invalid dialect → throw error', () => {
-  assert.throws(() => applyIfNotExistsModifier('CREATE TABLE foo (id INT)', 'mssql'), /invalid dialect/);
-});
-
-test('modifier: statement bukan string → throw error', () => {
-  assert.throws(() => applyIfNotExistsModifier(null, 'postgres'), /must be a string/);
-});