@restforgejs/platform 4.1.1 → 4.3.1

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

@@ -1,393 +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 { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..');
-const CLI_SCRIPT = path.join(REPO_ROOT, 'cli', 'dbschema-introspect.js');
-
-const CONFIG_PG = path.resolve(__dirname, '..', 'fixtures', 'connection', 'postgres-valid.env');
-
-const STUB_DIR = path.resolve(__dirname, 'fixtures', 'introspect-stubs');
-const STUB_TWO = path.join(STUB_DIR, 'two-tables.js');
-const STUB_EMPTY = path.join(STUB_DIR, 'empty.js');
-const STUB_CONN = path.join(STUB_DIR, 'connection-error.js');
-const STUB_MULTI = path.join(STUB_DIR, 'multi-schema.js');
-const STUB_INVENTORY = path.join(STUB_DIR, 'single-schema-inventory.js');
-const STUB_ALL_SCHEMAS = path.join(STUB_DIR, 'all-schemas-listing.js');
-
-function runIntrospect(args, options = {}) {
-    return spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-        encoding: 'utf-8',
-        env: { ...process.env, NO_COLOR: '1', ...(options.env || {}) },
-        ...options
-    });
-}
-
-function withTmpDir(fn) {
-    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbsk-introspect-'));
-    try {
-        return fn(tmpRoot);
-    } finally {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
-    }
-}
-
-test('introspect: --help → exit 0, stdout berisi usage', () => {
-    const result = runIntrospect(['--help']);
-    assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-    assert.match(result.stdout, /dbschema Introspect/);
-    assert.match(result.stdout, /--config=<file>/);
-    assert.match(result.stdout, /--output=<path>/);
-    assert.match(result.stdout, /--table=<name>/);
-});
-
-test('introspect: tanpa --config → exit 1, stderr "config" required', () => {
-    const result = runIntrospect(['--output=./schema']);
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /--config=<file> is required/);
-});
-
-test('introspect: --config menunjuk file yang tidak ada → exit 1, stderr "Config file not found"', () => {
-    const result = runIntrospect(['--config=does-not-exist.env', '--output=./schema']);
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /Config file not found/);
-});
-
-test('introspect: tanpa --output dan tanpa --dry-run → exit 1, stderr "output" required', () => {
-    const result = runIntrospect([`--config=${CONFIG_PG}`]);
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /--output=<path> is required/);
-});
-
-test('introspect: bulk mode tulis ke folder, semua tabel jadi file .js', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.ok(fs.existsSync(path.join(outDir, 'category.js')));
-        assert.ok(fs.existsSync(path.join(outDir, 'item_product.js')));
-        const content = fs.readFileSync(path.join(outDir, 'category.js'), 'utf8');
-        assert.match(content, /defineModel\('category'/);
-    });
-});
-
-test('introspect: single mode --output=folder + --table → file di <folder>/<table>.js', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--table=category'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.ok(fs.existsSync(path.join(outDir, 'category.js')));
-        // Should NOT emit other table.
-        assert.ok(!fs.existsSync(path.join(outDir, 'item_product.js')));
-    });
-});
-
-test('introspect: single mode --output=file.js + --table=foo (basename match) → tulis ke file', () => {
-    withTmpDir((tmpRoot) => {
-        const outFile = path.join(tmpRoot, 'category.js');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outFile}`, '--table=category'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.ok(fs.existsSync(outFile));
-        const content = fs.readFileSync(outFile, 'utf8');
-        assert.match(content, /defineModel\('category'/);
-    });
-});
-
-test('introspect: single mode --output=file.js basename mismatch dengan --table → exit 1', () => {
-    withTmpDir((tmpRoot) => {
-        const outFile = path.join(tmpRoot, 'wrong-name.js');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outFile}`, '--table=category'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 1);
-        assert.match(result.stderr, /does not match --table/);
-    });
-});
-
-test('introspect: bulk mode --output adalah file .js (tanpa --table) → exit 1', () => {
-    withTmpDir((tmpRoot) => {
-        const outFile = path.join(tmpRoot, 'all.js');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outFile}`],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 1);
-        assert.match(result.stderr, /Bulk mode requires a folder/);
-    });
-});
-
-test('introspect: file existing tanpa --force → exit 1, stderr "File already exists"', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        fs.mkdirSync(outDir, { recursive: true });
-        fs.writeFileSync(path.join(outDir, 'category.js'), '// pre-existing');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--table=category'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 1);
-        assert.match(result.stderr, /File already exists/);
-    });
-});
-
-test('introspect: file existing dengan --force → overwrite sukses', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        fs.mkdirSync(outDir, { recursive: true });
-        const target = path.join(outDir, 'category.js');
-        fs.writeFileSync(target, '// pre-existing');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--table=category', '--force'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        const content = fs.readFileSync(target, 'utf8');
-        assert.match(content, /defineModel\('category'/);
-        assert.doesNotMatch(content, /pre-existing/);
-    });
-});
-
-test('introspect: --dry-run tanpa --output → exit 2, stdout berisi factory function', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--dry-run'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-    );
-    assert.strictEqual(result.status, 2, `expected exit 2, got ${result.status}. stderr: ${result.stderr}`);
-    assert.match(result.stdout, /defineModel\('category'/);
-    assert.match(result.stdout, /defineModel\('item_product'/);
-    assert.match(result.stderr, /Dry-run complete/);
-});
-
-test('introspect: --dry-run + --table=foo → exit 2, stdout hanya satu factory function', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--dry-run', '--table=category'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-    );
-    assert.strictEqual(result.status, 2);
-    assert.match(result.stdout, /defineModel\('category'/);
-    assert.doesNotMatch(result.stdout, /defineModel\('item_product'/);
-});
-
-test('introspect: connection error → exit 1, stderr "Cannot connect"', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--output=./out'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_CONN } }
-    );
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /Cannot connect/);
-});
-
-test('introspect: --table tidak ditemukan di DB → exit 1, stderr "not found"', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--output=./out', '--table=ghost'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_EMPTY } }
-    );
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /'ghost' not found/);
-});
-
-test('introspect: unknown option → exit 1', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--output=./out', '--bogus'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-    );
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /Unknown option/);
-});
-
-// =====================================================
-// Phase 14: schema-aware CLI flags
-// =====================================================
-
-test('introspect (Phase 14): --schema=inventory bulk → flat layout, semua emit schema: inventory', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--schema=inventory'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_INVENTORY } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        // Flat layout (no subfolder per schema for single-schema bulk)
-        assert.ok(fs.existsSync(path.join(outDir, 'products.js')));
-        assert.ok(fs.existsSync(path.join(outDir, 'categories.js')));
-        const productsContent = fs.readFileSync(path.join(outDir, 'products.js'), 'utf8');
-        assert.match(productsContent, /defineModel\('products'/);
-        assert.match(productsContent, /schema: 'inventory'/);
-    });
-});
-
-test('introspect (Phase 14): --schema=inventory,audit bulk → subfolder layout per schema', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--schema=inventory,audit'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_MULTI } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.ok(fs.existsSync(path.join(outDir, 'inventory', 'products.js')));
-        assert.ok(fs.existsSync(path.join(outDir, 'inventory', 'categories.js')));
-        assert.ok(fs.existsSync(path.join(outDir, 'audit', 'events.js')));
-        assert.ok(fs.existsSync(path.join(outDir, 'audit', 'logs.js')));
-        const eventsContent = fs.readFileSync(path.join(outDir, 'audit', 'events.js'), 'utf8');
-        assert.match(eventsContent, /schema: 'audit'/);
-    });
-});
-
-test('introspect (Phase 14): --all-schemas → listSchemas() lalu bulk subfolder', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--all-schemas'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_ALL_SCHEMAS } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.ok(fs.existsSync(path.join(outDir, 'inventory', 'products.js')));
-        assert.ok(fs.existsSync(path.join(outDir, 'audit', 'logs.js')));
-        assert.ok(fs.existsSync(path.join(outDir, 'public', 'users.js')));
-    });
-});
-
-test('introspect (Phase 14): --table=inventory.products qualified → file emit schema: inventory', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--table=inventory.products'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_MULTI } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.ok(fs.existsSync(path.join(outDir, 'products.js')));
-        const content = fs.readFileSync(path.join(outDir, 'products.js'), 'utf8');
-        assert.match(content, /schema: 'inventory'/);
-        assert.match(content, /defineModel\('products'/);
-    });
-});
-
-test('introspect (Phase 14): --schema=inventory --table=products (split style) → equivalent to qualified single', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--schema=inventory', '--table=products'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_MULTI } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        const content = fs.readFileSync(path.join(outDir, 'products.js'), 'utf8');
-        assert.match(content, /schema: 'inventory'/);
-    });
-});
-
-test('introspect (Phase 14): conflict --all-schemas + --schema → exit 1', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--output=./out', '--all-schemas', '--schema=inventory'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_ALL_SCHEMAS } }
-    );
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /--all-schemas conflicts with --schema/);
-});
-
-test('introspect (Phase 14): conflict --all-schemas + --table → exit 1', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--output=./out', '--all-schemas', '--table=foo'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_ALL_SCHEMAS } }
-    );
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /--all-schemas conflicts with --table/);
-});
-
-test('introspect (Phase 14): conflict --schema=foo + qualified --table=audit.events → exit 1', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--output=./out', '--schema=inventory', '--table=audit.events'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_MULTI } }
-    );
-    assert.strictEqual(result.status, 1);
-    assert.match(result.stderr, /--schema conflicts with a qualified --table/);
-});
-
-test('introspect (Phase 14): default-schema bulk (no --schema/--all-schemas) backward compat — flat + no schema:', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        const content = fs.readFileSync(path.join(outDir, 'category.js'), 'utf8');
-        // Phase 12 stub does not set schemaName → output must NOT include schema: line
-        assert.doesNotMatch(content, /^\s*schema:/m);
-        // Flat layout
-        assert.ok(!fs.existsSync(path.join(outDir, 'public')));
-    });
-});
-
-test('introspect (Phase 14): multi-schema bulk dry-run → stdout banner per qualified table', () => {
-    const result = runIntrospect(
-        [`--config=${CONFIG_PG}`, '--dry-run', '--schema=inventory,audit'],
-        { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_MULTI } }
-    );
-    assert.strictEqual(result.status, 2, `stderr: ${result.stderr}`);
-    assert.match(result.stdout, /── inventory\.products /);
-    assert.match(result.stdout, /── audit\.events /);
-    assert.match(result.stdout, /schema: 'inventory'/);
-    assert.match(result.stdout, /schema: 'audit'/);
-    assert.match(result.stderr, /Dry-run complete: 4 table\(s\) previewed across 2 schema\(s\)/);
-});
-
-test('introspect (Phase 14): round-trip multi-schema → 4 model dengan schemaName valid', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`, '--schema=inventory,audit'],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_MULTI } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-
-        const { loadSchemaPath } = require(path.join(REPO_ROOT, 'lib', 'dbschema-kit', 'loader'));
-        const models = loadSchemaPath(outDir);
-        assert.strictEqual(models.size, 4);
-        assert.ok(models.has('inventory.products'));
-        assert.ok(models.has('inventory.categories'));
-        assert.ok(models.has('audit.events'));
-        assert.ok(models.has('audit.logs'));
-
-        const eventsIr = models.get('audit.events');
-        assert.strictEqual(eventsIr.schemaName, 'audit');
-        // FK target ke schema lain harus qualified
-        const rels = Object.values(eventsIr.relations);
-        assert.ok(rels.some(r => r.target === 'inventory.products'));
-    });
-});
-
-test('introspect: round-trip — output bulk dapat di-load oleh loadSchemaPath', () => {
-    withTmpDir((tmpRoot) => {
-        const outDir = path.join(tmpRoot, 'schema');
-        const result = runIntrospect(
-            [`--config=${CONFIG_PG}`, `--output=${outDir}`],
-            { env: { DBSCHEMA_KIT_TEST_INTROSPECT_STUB: STUB_TWO } }
-        );
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-
-        const { loadSchemaPath } = require(path.join(REPO_ROOT, 'lib', 'dbschema-kit', 'loader'));
-        const models = loadSchemaPath(outDir);
-        assert.strictEqual(models.size, 2);
-        assert.ok(models.has('category'));
-        assert.ok(models.has('item_product'));
-
-        const itemIr = models.get('item_product');
-        assert.ok(itemIr.relations && Object.keys(itemIr.relations).length > 0,
-            'item_product harus punya relasi ke category');
-    });
-});

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

@@ -1,104 +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 { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..');
-const CLI_SCRIPT = path.join(REPO_ROOT, 'cli', 'dbschema-generate-ddl.js');
-const FIXTURE_VALID = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory');
-const FIXTURE_INVALID = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory-invalid');
-
-function runGen(args, options = {}) {
-    return spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-        encoding: 'utf-8',
-        env: { ...process.env, NO_COLOR: '1' },
-        ...options
-    });
-}
-
-test('generate-ddl: folder valid + --dialect=postgres → exit 0, stdout berisi CREATE TABLE', () => {
-    const result = runGen([FIXTURE_VALID, '--dialect=postgres']);
-    assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-    assert.match(result.stdout, /-- Generated by dbschema:generate-ddl/);
-    assert.match(result.stdout, /CREATE TABLE category/);
-    assert.match(result.stdout, /CREATE TABLE item_product/);
-    // Topological order
-    const catIdx = result.stdout.indexOf('CREATE TABLE category');
-    const itemIdx = result.stdout.indexOf('CREATE TABLE item_product');
-    assert.ok(catIdx < itemIdx, 'category harus muncul sebelum item_product');
-});
-
-test('generate-ddl: --out=<tempfile> → file ditulis dengan content sama dengan stdout default', () => {
-    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbschema-kit-gen-'));
-    const outPath = path.join(tmpRoot, 'out.sql');
-    try {
-        const stdoutResult = runGen([FIXTURE_VALID, '--dialect=postgres']);
-        assert.strictEqual(stdoutResult.status, 0);
-
-        const fileResult = runGen([FIXTURE_VALID, '--dialect=postgres', `--out=${outPath}`]);
-        assert.strictEqual(fileResult.status, 0, `stderr: ${fileResult.stderr}`);
-        assert.strictEqual(fileResult.stdout, '', 'stdout harus kosong saat --out di-set');
-
-        assert.ok(fs.existsSync(outPath), 'file output harus terbuat');
-        const fileContent = fs.readFileSync(outPath, 'utf-8');
-
-        // Buang baris timestamp untuk perbandingan (timestamp beda antar run)
-        const stripTs = (s) => s.replace(/-- Generated at: [^\n]+/, '-- Generated at: <ts>');
-        assert.strictEqual(stripTs(fileContent), stripTs(stdoutResult.stdout));
-    } finally {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
-    }
-});
-
-test('generate-ddl: --drop=true → output mengandung DROP TABLE statement', () => {
-    const result = runGen([FIXTURE_VALID, '--dialect=postgres', '--drop=true']);
-    assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-    assert.match(result.stdout, /-- DROP section/);
-    assert.match(result.stdout, /DROP TABLE IF EXISTS stock_inbound_item CASCADE;/);
-    // DROP child sebelum DROP parent
-    const dropChildIdx = result.stdout.indexOf('DROP TABLE IF EXISTS stock_inbound_item');
-    const dropParentIdx = result.stdout.indexOf('DROP TABLE IF EXISTS stock_inbound CASCADE');
-    assert.ok(dropChildIdx > 0 && dropParentIdx > 0);
-    assert.ok(dropChildIdx < dropParentIdx, 'DROP child harus sebelum DROP parent');
-});
-
-test('generate-ddl: folder invalid (mini-inventory-invalid) → exit 1, stderr berisi error cross-model', () => {
-    const result = runGen([FIXTURE_INVALID, '--dialect=postgres']);
-    assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-    assert.match(result.stderr, /Cross-model validation/);
-});
-
-test('generate-ddl: path tidak exist → exit 1, stderr berisi "Schema path not found"', () => {
-    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbschema-kit-gen-'));
-    const ghost = path.join(tmpRoot, 'does-not-exist');
-    try {
-        const result = runGen([ghost, '--dialect=postgres']);
-        assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-        assert.match(result.stderr, /Schema path not found/);
-    } finally {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
-    }
-});
-
-test('generate-ddl: --dialect tidak diberikan → exit 1, stderr berisi pesan error tentang dialect required', () => {
-    const result = runGen([FIXTURE_VALID]);
-    assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-    assert.match(result.stderr, /--dialect is required/);
-});
-
-test('generate-ddl: --dialect=mssql (invalid) → exit 1, stderr berisi pesan error dialect tidak dikenal', () => {
-    const result = runGen([FIXTURE_VALID, '--dialect=mssql']);
-    assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-    assert.match(result.stderr, /Unknown dialect 'mssql'/);
-});
-
-test('generate-ddl: --dialect=mysql menghasilkan output dengan identifier tanpa quote', () => {
-    const result = runGen([FIXTURE_VALID, '--dialect=mysql']);
-    assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-    assert.match(result.stdout, /CREATE TABLE category/);
-    assert.match(result.stdout, /-- Dialect: mysql/);
-});

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

@@ -1,119 +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 { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..');
-const CLI_SCRIPT = path.join(REPO_ROOT, 'cli', 'dbschema-init.js');
-
-function runInit(args, options = {}) {
-    return spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-        encoding: 'utf-8',
-        env: { ...process.env, NO_COLOR: '1' },
-        ...options
-    });
-}
-
-function withTmpDir(fn) {
-    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbsk-init-'));
-    try {
-        return fn(tmpRoot);
-    } finally {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
-    }
-}
-
-test('init: --help → exit 0, stdout berisi usage', () => {
-    const result = runInit(['--help']);
-    assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-    assert.match(result.stdout, /dbschema Init/);
-    assert.match(result.stdout, /<path>/);
-});
-
-test('init: tanpa argumen path → exit 1, stderr "Target file path is required"', () => {
-    const result = runInit([]);
-    assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-    assert.match(result.stderr, /Target file path is required/);
-});
-
-test('init: file path tanpa ekstensi .js → exit 1, stderr "must have .js extension"', () => {
-    withTmpDir((tmpRoot) => {
-        const target = path.join(tmpRoot, 'supplier');
-        const result = runInit([target]);
-        assert.strictEqual(result.status, 1);
-        assert.match(result.stderr, /must have \.js extension/);
-    });
-});
-
-test('init: file sudah ada → exit 1, stderr "File already exists"', () => {
-    withTmpDir((tmpRoot) => {
-        const target = path.join(tmpRoot, 'supplier.js');
-        fs.writeFileSync(target, '// existing');
-        const result = runInit([target]);
-        assert.strictEqual(result.status, 1);
-        assert.match(result.stderr, /File already exists/);
-    });
-});
-
-test('init: nama tabel invalid (mulai dengan angka) → exit 1', () => {
-    withTmpDir((tmpRoot) => {
-        const target = path.join(tmpRoot, '1invalid.js');
-        const result = runInit([target]);
-        assert.strictEqual(result.status, 1);
-        assert.match(result.stderr, /Invalid table name/);
-    });
-});
-
-test('init: happy path → exit 0, file dibuat dengan factory function pattern', () => {
-    withTmpDir((tmpRoot) => {
-        const target = path.join(tmpRoot, 'supplier.js');
-        const result = runInit([target]);
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.match(result.stdout, /Created schema skeleton/);
-        assert.ok(fs.existsSync(target), 'file harus dibuat');
-        const content = fs.readFileSync(target, 'utf8');
-        assert.match(content, /module\.exports = \(\{ defineModel \}\) => defineModel\('supplier'/);
-        assert.match(content, /supplier_id: 'string:36 pk'/);
-        assert.match(content, /relations:/);
-        assert.match(content, /belongsTo/);
-    });
-});
-
-test('init: parent folder dibuat otomatis bila belum ada', () => {
-    withTmpDir((tmpRoot) => {
-        const target = path.join(tmpRoot, 'nested', 'subfolder', 'order.js');
-        const result = runInit([target]);
-        assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-        assert.ok(fs.existsSync(target));
-    });
-});
-
-test('init: skeleton hasilnya dapat di-load oleh loader (factory function valid)', () => {
-    withTmpDir((tmpRoot) => {
-        const target = path.join(tmpRoot, 'item_product.js');
-        const result = runInit([target]);
-        assert.strictEqual(result.status, 0);
-
-        const { loadSchemaPath } = require(path.join(REPO_ROOT, 'lib', 'dbschema-kit', 'loader'));
-        const models = loadSchemaPath(target);
-        assert.strictEqual(models.size, 1);
-        const ir = models.get('item_product');
-        assert.ok(ir, 'tableName harus terdaftar');
-        assert.strictEqual(ir.tableName, 'item_product');
-        assert.ok(ir.fields, 'fields harus ada');
-        assert.ok(ir.relations, 'relations harus ada');
-    });
-});
-
-test('init: unknown option → exit 1', () => {
-    withTmpDir((tmpRoot) => {
-        const target = path.join(tmpRoot, 'supplier.js');
-        const result = runInit([target, '--unknown-flag']);
-        assert.strictEqual(result.status, 1);
-        assert.match(result.stderr, /Unknown option/);
-    });
-});

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

@@ -1,48 +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 { spawnSync } = require('node:child_process');
-
-const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..');
-const CLI_SCRIPT = path.join(REPO_ROOT, 'cli', 'dbschema-models.js');
-const FIXTURE_VALID = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory');
-
-function runList(args, options = {}) {
-    return spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-        encoding: 'utf-8',
-        env: { ...process.env, NO_COLOR: '1' },
-        ...options
-    });
-}
-
-test('list: folder valid (mini-inventory) → exit 0 dengan 6 nama tabel', () => {
-    const result = runList([FIXTURE_VALID]);
-    assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-    const expectedTables = ['category', 'supplier', 'warehouse', 'item_product', 'stock_inbound', 'stock_inbound_item'];
-    for (const tbl of expectedTables) {
-        assert.match(result.stdout, new RegExp(`\\b${tbl}\\b`), `tabel ${tbl} tidak ditemukan di output`);
-    }
-    assert.match(result.stdout, /6 models loaded\./);
-});
-
-test('list: folder valid → output mengandung header tabel ringkasan', () => {
-    const result = runList([FIXTURE_VALID]);
-    assert.strictEqual(result.status, 0);
-    assert.match(result.stdout, /Schema\s+Table\s+Fields\s+PK\s+Indexes\s+Uniques\s+Relations/);
-});
-
-test('list: path tidak exist → exit 1 dengan pesan "Schema path not found"', () => {
-    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbschema-kit-list-'));
-    const ghost = path.join(tmpRoot, 'does-not-exist');
-    try {
-        const result = runList([ghost]);
-        assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-        assert.match(result.stderr, /Schema path not found/);
-    } finally {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
-    }
-});