@restforgejs/platform 4.2.8 → 4.3.2

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

@@ -1,403 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-
-const { mapTableMetaToIR } = require('../../../../lib/dbschema-kit/introspect-mapper');
-
-function baseMeta(overrides = {}) {
-    return Object.assign({
-        tableName: 'sample',
-        columns: [],
-        primaryKey: [],
-        uniques: [],
-        foreignKeys: [],
-        indexes: [],
-        checks: []
-    }, overrides);
-}
-
-test('map: kolom VARCHAR(N) NOT NULL → IR field {type:string, length:N, notnull:true}', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 100 }
-        ]
-    }), 'postgres');
-    assert.deepStrictEqual(ir.fields.name, { type: 'string', length: 100, notnull: true });
-});
-
-test('map: kolom INTEGER PRIMARY KEY → IR field {type:integer, pk:true, notnull:true}', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'id', data_type: 'integer', udt_name: 'int4',
-              column_default: null, is_nullable: 'NO' }
-        ],
-        primaryKey: ['id']
-    }), 'postgres');
-    assert.strictEqual(ir.fields.id.type, 'integer');
-    assert.strictEqual(ir.fields.id.pk, true);
-    assert.strictEqual(ir.fields.id.notnull, true);
-    // single-column PK: the primaryKey OUT array should be empty (PK lives in shorthand)
-    assert.deepStrictEqual(ir.primaryKey, []);
-});
-
-test('map: kolom NUMERIC(p,s) DEFAULT 0 → IR field {type:decimal, precision, scale, default:literal 0}', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'price', data_type: 'numeric', udt_name: 'numeric',
-              column_default: '0', is_nullable: 'YES',
-              numeric_precision: 18, numeric_scale: 2 }
-        ]
-    }), 'postgres');
-    assert.deepStrictEqual(ir.fields.price, {
-        type: 'decimal', precision: 18, scale: 2,
-        default: { kind: 'literal', value: 0 }
-    });
-});
-
-test('map: kolom TIMESTAMP DEFAULT CURRENT_TIMESTAMP → default function now()', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'created_at', data_type: 'timestamp without time zone',
-              udt_name: 'timestamp', column_default: 'CURRENT_TIMESTAMP', is_nullable: 'YES' }
-        ]
-    }), 'postgres');
-    assert.deepStrictEqual(ir.fields.created_at.default, { kind: 'function', name: 'now', args: [] });
-    assert.strictEqual(ir.fields.created_at.type, 'timestamp');
-});
-
-test('map: kolom BOOLEAN DEFAULT TRUE → default literal true', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'is_active', data_type: 'boolean', udt_name: 'bool',
-              column_default: 'true', is_nullable: 'YES' }
-        ]
-    }), 'postgres');
-    assert.deepStrictEqual(ir.fields.is_active, {
-        type: 'boolean', default: { kind: 'literal', value: true }
-    });
-});
-
-test('map: composite UNIQUE → uniques array', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'item_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' },
-            { column_name: 'warehouse_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        uniques: [{ name: 'uq_item_wh', columns: ['item_id', 'warehouse_id'] }]
-    }), 'postgres');
-    assert.deepStrictEqual(ir.uniques, [{ columns: ['item_id', 'warehouse_id'] }]);
-    // Field-level unique should NOT be set when constraint is composite.
-    assert.notStrictEqual(ir.fields.item_id.unique, true);
-    assert.notStrictEqual(ir.fields.warehouse_id.unique, true);
-});
-
-test('map: single-column UNIQUE → token unique di field, bukan uniques array', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'code', data_type: 'character varying', udt_name: 'varchar',
-              is_nullable: 'NO', character_maximum_length: 20 }
-        ],
-        uniques: [{ name: 'uq_code', columns: ['code'] }]
-    }), 'postgres');
-    assert.strictEqual(ir.fields.code.unique, true);
-    assert.deepStrictEqual(ir.uniques, []);
-});
-
-test('map: FK constraint → relations dengan onDelete mapping', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'category_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        foreignKeys: [
-            {
-                name: 'fk_item_category',
-                columns: ['category_id'],
-                references: { schema: 'public', table: 'category', columns: ['category_id'] },
-                onDelete: 'CASCADE',
-                onUpdate: null
-            }
-        ]
-    }), 'postgres');
-    // Relation key derives from target table, not constraint name.
-    assert.ok(ir.relations.category);
-    const rel = ir.relations.category;
-    assert.strictEqual(rel.type, 'belongsTo');
-    assert.strictEqual(rel.target, 'category');
-    assert.strictEqual(rel.localKey, 'category_id');
-    assert.strictEqual(rel.references, 'category_id');
-    assert.strictEqual(rel.onDelete, 'cascade');
-    assert.strictEqual(rel.onUpdate, undefined);
-});
-
-test('map: composite index → entry dengan composite=true di indexes array', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'status', data_type: 'character varying', udt_name: 'varchar',
-              is_nullable: 'YES', character_maximum_length: 20 },
-            { column_name: 'is_active', data_type: 'boolean', udt_name: 'bool', is_nullable: 'YES' }
-        ],
-        indexes: [{ name: 'idx_status_active', columns: ['status', 'is_active'], unique: false, primary: false }]
-    }), 'postgres');
-    assert.strictEqual(ir.indexes.length, 1);
-    assert.deepStrictEqual(ir.indexes[0].columns, ['status', 'is_active']);
-    assert.strictEqual(ir.indexes[0].composite, true);
-});
-
-test('map: index implicit dari UNIQUE constraint → di-skip (deduplicate)', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'code', data_type: 'character varying', udt_name: 'varchar',
-              is_nullable: 'NO', character_maximum_length: 20 }
-        ],
-        uniques: [{ name: 'uq_code', columns: ['code'] }],
-        indexes: [
-            { name: 'uq_code', columns: ['code'], unique: true, primary: false },
-            { name: 'idx_code_other', columns: ['code'], unique: false, primary: false }
-        ]
-    }), 'postgres');
-    // Both should be skipped: first matches unique, second matches first column (dedupe by column set)
-    assert.strictEqual(ir.indexes.length, 0);
-});
-
-test('map: CHECK col IN (...) → checks dengan op in', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'status', data_type: 'character varying', udt_name: 'varchar',
-              is_nullable: 'NO', character_maximum_length: 20 }
-        ],
-        checks: [{ expression: "status IN ('active', 'inactive', 'cancelled')" }]
-    }), 'postgres');
-    assert.strictEqual(ir.checks.length, 1);
-    assert.deepStrictEqual(ir.checks[0], {
-        field: 'status', op: 'in', value: ['active', 'inactive', 'cancelled']
-    });
-});
-
-test('map: CHECK comparison col > N → checks dengan op gt', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'qty', data_type: 'integer', udt_name: 'int4', is_nullable: 'NO' }
-        ],
-        checks: [{ expression: 'qty > 0', name: 'ck_qty_pos' }]
-    }), 'postgres');
-    assert.strictEqual(ir.checks.length, 1);
-    assert.strictEqual(ir.checks[0].field, 'qty');
-    assert.strictEqual(ir.checks[0].op, 'gt');
-    assert.strictEqual(ir.checks[0].value, 0);
-    assert.strictEqual(ir.checks[0].name, 'ck_qty_pos');
-});
-
-test('map: type tidak dikenal → fallback text dengan komentar TODO', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'data_blob', data_type: 'bytea', udt_name: 'bytea', is_nullable: 'YES' }
-        ]
-    }), 'postgres');
-    assert.strictEqual(ir.fields.data_blob.type, 'text');
-    assert.match(ir.fields.data_blob._comment || '', /unsupported type 'bytea'/);
-});
-
-test('map: sequence default (nextval) → tidak emit default, simpan komentar', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'id', data_type: 'integer', udt_name: 'int4',
-              column_default: "nextval('items_id_seq'::regclass)", is_nullable: 'NO' }
-        ]
-    }), 'postgres');
-    assert.strictEqual(ir.fields.id.default, undefined);
-    assert.match(ir.fields.id._defaultComment || '', /nextval/);
-});
-
-test('map: composite PK → primaryKey out berisi semua kolom, field tidak punya pk shorthand', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'user_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' },
-            { column_name: 'role_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        primaryKey: ['user_id', 'role_id']
-    }), 'postgres');
-    assert.deepStrictEqual(ir.primaryKey, ['user_id', 'role_id']);
-    assert.notStrictEqual(ir.fields.user_id.pk, true);
-    assert.notStrictEqual(ir.fields.role_id.pk, true);
-    assert.strictEqual(ir.fields.user_id.notnull, true);
-});
-
-test('map: FK onDelete SET NULL → setNull, NO ACTION → restrict', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'a_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'YES' },
-            { column_name: 'b_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        foreignKeys: [
-            { name: 'fk_a', columns: ['a_id'],
-              references: { schema: 'public', table: 'parent_a', columns: ['parent_a_id'] },
-              onDelete: 'SET NULL' },
-            { name: 'fk_b', columns: ['b_id'],
-              references: { schema: 'public', table: 'parent_b', columns: ['parent_b_id'] },
-              onDelete: 'NO ACTION' }
-        ]
-    }), 'postgres');
-    // Relation key derives from target table (parent_a / parent_b), not constraint name (fk_a / fk_b).
-    assert.strictEqual(ir.relations.parent_a.onDelete, 'setNull');
-    assert.strictEqual(ir.relations.parent_b.onDelete, 'restrict');
-});
-
-test('map: relation key derives from target table, ignoring DBA-assigned constraint name', () => {
-    // Even when the DB constraint name carries a meaningful prefix (sys_*, fk_*),
-    // the relation key is taken from the target table for emitter consistency.
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'parent_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'YES' }
-        ],
-        foreignKeys: [
-            { name: 'sys_c0099', columns: ['parent_id'],
-              references: { schema: 'public', table: 'parent_table', columns: ['parent_id'] },
-              onDelete: null }
-        ]
-    }), 'oracle');
-    assert.ok(ir.relations.parent_table, `expected relation 'parent_table', got: ${Object.keys(ir.relations).join(',')}`);
-});
-
-test('map: index PK-backed → di-skip', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        primaryKey: ['id'],
-        indexes: [{ name: 'pk_x', columns: ['id'], unique: true, primary: true }]
-    }), 'postgres');
-    assert.strictEqual(ir.indexes.length, 0);
-});
-
-test('map: CHECK unparsable → entry dengan _unparsable=true', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        columns: [
-            { column_name: 'name', data_type: 'character varying', udt_name: 'varchar',
-              is_nullable: 'YES', character_maximum_length: 50 }
-        ],
-        checks: [{ expression: "name LIKE '%foo%'" }]
-    }), 'postgres');
-    assert.strictEqual(ir.checks.length, 1);
-    assert.strictEqual(ir.checks[0]._unparsable, true);
-    assert.match(ir.checks[0].expression, /LIKE/);
-});
-
-test('map: tableMeta.tableName wajib non-empty string', () => {
-    assert.throws(() => mapTableMetaToIR({ tableName: '' }), /tableName must be a non-empty string/);
-    assert.throws(() => mapTableMetaToIR(null), /tableMeta is required/);
-});
-
-// =====================================================
-// Phase 14: schema-aware mapping
-// =====================================================
-
-test('map (Phase 14): tableMeta dengan schemaName → IR.schemaName + qualifiedName terisi', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        tableName: 'products',
-        schemaName: 'inventory',
-        columns: [
-            { column_name: 'product_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        primaryKey: ['product_id']
-    }), 'postgres');
-    assert.strictEqual(ir.schemaName, 'inventory');
-    assert.strictEqual(ir.qualifiedName, 'inventory.products');
-    assert.strictEqual(ir.tableName, 'products');
-});
-
-test('map (Phase 14): tableMeta tanpa schemaName → IR.schemaName=null, qualifiedName=tableName (backward compat)', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        tableName: 'category',
-        columns: [
-            { column_name: 'category_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        primaryKey: ['category_id']
-    }), 'postgres');
-    assert.strictEqual(ir.schemaName, null);
-    assert.strictEqual(ir.qualifiedName, 'category');
-});
-
-test('map (Phase 14): cross-schema FK → rel.target qualified <schema>.<table>', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        tableName: 'events',
-        schemaName: 'audit',
-        columns: [
-            { column_name: 'product_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        foreignKeys: [{
-            name: 'fk_events_product',
-            columns: ['product_id'],
-            references: { schema: 'inventory', table: 'products', columns: ['product_id'] },
-            onDelete: 'CASCADE'
-        }]
-    }), 'postgres');
-    // Relation key derives from target table 'products' (refSchema not part of key).
-    assert.ok(ir.relations.products);
-    assert.strictEqual(ir.relations.products.target, 'inventory.products');
-});
-
-test('map (Phase 14): same-schema FK → rel.target tetap unqualified (portability)', () => {
-    const ir = mapTableMetaToIR(baseMeta({
-        tableName: 'products',
-        schemaName: 'inventory',
-        columns: [
-            { column_name: 'category_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        foreignKeys: [{
-            name: 'fk_products_category',
-            columns: ['category_id'],
-            references: { schema: 'inventory', table: 'categories', columns: ['category_id'] },
-            onDelete: 'CASCADE'
-        }]
-    }), 'postgres');
-    assert.strictEqual(ir.relations.categories.target, 'categories');
-});
-
-// =====================================================
-// pickRelationName: collision handling
-// =====================================================
-
-test('map: multi-FK ke target table sama → relation key collision di-resolve via localKey', () => {
-    // Two FKs to the same target 'account' must produce distinct relation keys.
-    // Resolution: first uses target table name, second falls back to localKey-derived name.
-    const ir = mapTableMetaToIR(baseMeta({
-        tableName: 'transaction',
-        columns: [
-            { column_name: 'from_account_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' },
-            { column_name: 'to_account_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'NO' }
-        ],
-        foreignKeys: [
-            { name: 'fk_tx_from', columns: ['from_account_id'],
-              references: { schema: 'public', table: 'account', columns: ['account_id'] },
-              onDelete: null },
-            { name: 'fk_tx_to', columns: ['to_account_id'],
-              references: { schema: 'public', table: 'account', columns: ['account_id'] },
-              onDelete: null }
-        ]
-    }), 'postgres');
-    // First FK wins the natural name 'account', second falls back to 'to_account' (localKey strip _id).
-    assert.ok(ir.relations.account, `expected 'account', got: ${Object.keys(ir.relations).join(',')}`);
-    assert.ok(ir.relations.to_account, `expected 'to_account', got: ${Object.keys(ir.relations).join(',')}`);
-    assert.strictEqual(ir.relations.account.localKey, 'from_account_id');
-    assert.strictEqual(ir.relations.to_account.localKey, 'to_account_id');
-});
-
-test('map: self-FK (parent_id ref own table) → relation key dari localKey strip _id', () => {
-    // Self-referencing FK: target same as source table. tableCandidate=='category' but
-    // since this is the only FK, no collision; key becomes 'category'.
-    const ir = mapTableMetaToIR(baseMeta({
-        tableName: 'category',
-        columns: [
-            { column_name: 'parent_id', data_type: 'uuid', udt_name: 'uuid', is_nullable: 'YES' }
-        ],
-        foreignKeys: [
-            { name: 'fk_category_parent', columns: ['parent_id'],
-              references: { schema: 'public', table: 'category', columns: ['category_id'] },
-              onDelete: null }
-        ]
-    }), 'postgres');
-    assert.ok(ir.relations.category);
-    assert.strictEqual(ir.relations.category.localKey, 'parent_id');
-});