@restforgejs/platform 4.1.1 → 4.3.1

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

@@ -1,175 +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-migrate.js');
-
-const FIXTURE_VALID = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory');
-const FIXTURE_INVALID = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory-invalid');
-const FIXTURE_FILE_WITH_FK = path.resolve(FIXTURE_VALID, 'item_product.js');
-
-const CONFIG_PG = path.resolve(__dirname, '..', 'fixtures', 'connection', 'postgres-valid.env');
-
-const STUB_DIR = path.resolve(__dirname, 'fixtures', 'migrate-stubs');
-const STUB_SUCCESS = path.join(STUB_DIR, 'success.js');
-const STUB_PARTIAL = path.join(STUB_DIR, 'partial.js');
-const STUB_ROLLBACK = path.join(STUB_DIR, 'rollback.js');
-const STUB_CONN_ERR = path.join(STUB_DIR, 'connection-error.js');
-
-function runMigrate(args, options = {}) {
-  return spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-    encoding: 'utf-8',
-    env: { ...process.env, NO_COLOR: '1', ...(options.env || {}) },
-    ...options
-  });
-}
-
-test('migrate: --help → exit 0, stdout berisi usage + flags', () => {
-  const result = runMigrate(['--help']);
-  assert.strictEqual(result.status, 0, `stderr: ${result.stderr}`);
-  assert.match(result.stdout, /dbschema Migrate/);
-  assert.match(result.stdout, /--config=<file>/);
-  assert.match(result.stdout, /--drop=true\|false/);
-  assert.match(result.stdout, /--dry-run/);
-});
-
-test('migrate: tanpa --config → exit 1, stderr berisi "config" required', () => {
-  const result = runMigrate([FIXTURE_VALID]);
-  assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-  assert.match(result.stderr, /--config=<file> is required/);
-});
-
-test('migrate: --config menunjuk file yang tidak ada → exit 1, stderr "Config file not found"', () => {
-  const result = runMigrate([FIXTURE_VALID, '--config=does-not-exist.env']);
-  assert.strictEqual(result.status, 1);
-  assert.match(result.stderr, /Config file not found/);
-});
-
-test('migrate: schema path tidak exist → exit 1, stderr "Schema path not found"', () => {
-  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbsk-mig-'));
-  const ghost = path.join(tmpRoot, 'no-such-folder');
-  try {
-    const result = runMigrate([ghost, `--config=${CONFIG_PG}`]);
-    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('migrate: cross-model validation gagal pada folder mode → exit 1, stderr berisi error', () => {
-  const result = runMigrate([FIXTURE_INVALID, `--config=${CONFIG_PG}`]);
-  assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-  assert.match(result.stderr, /Cross-model validation/);
-});
-
-test('migrate: file mode skip cross-model validation (file dengan FK ke tabel external load sukses)', () => {
-  const result = runMigrate(
-    [FIXTURE_FILE_WITH_FK, `--config=${CONFIG_PG}`, '--dry-run'],
-    { env: { DBSCHEMA_KIT_TEST_APPLY_STUB: STUB_SUCCESS } }
-  );
-  assert.strictEqual(result.status, 2, `expected exit 2 dry-run, got ${result.status}. stderr: ${result.stderr}`);
-  assert.doesNotMatch(result.stderr, /Cross-model validation/);
-  assert.match(result.stdout, /CREATE TABLE/);
-});
-
-test('migrate: --dry-run → exit 2, stdout berisi DDL preview + "Dry-run complete"', () => {
-  const result = runMigrate([FIXTURE_VALID, `--config=${CONFIG_PG}`, '--dry-run']);
-  assert.strictEqual(result.status, 2, `expected exit 2, got ${result.status}. stderr: ${result.stderr}`);
-  assert.match(result.stdout, /-- DDL Preview --/);
-  assert.match(result.stdout, /CREATE TABLE/);
-  assert.match(result.stdout, /Dry-run complete\. No changes applied\./);
-});
-
-test('migrate: --drop=true langsung apply tanpa konfirmasi tambahan, warning tetap muncul di stderr', () => {
-  const result = runMigrate(
-    [FIXTURE_VALID, `--config=${CONFIG_PG}`, '--drop=true'],
-    { env: { DBSCHEMA_KIT_TEST_APPLY_STUB: STUB_SUCCESS } }
-  );
-  assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-  assert.match(result.stdout, /Status: SUCCESS/);
-  assert.match(result.stderr, /--drop=true will DROP/);
-});
-
-test('migrate: --drop=false → statement dimodifikasi pakai IF NOT EXISTS sebelum di-execute', () => {
-  const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbsk-mig-rec-'));
-  const recordFile = path.join(tmpRoot, 'record.json');
-  try {
-    const result = runMigrate(
-      [FIXTURE_VALID, `--config=${CONFIG_PG}`, '--drop=false'],
-      {
-        env: {
-          DBSCHEMA_KIT_TEST_APPLY_STUB: STUB_SUCCESS,
-          DBSCHEMA_KIT_TEST_RECORD_FILE: recordFile
-        }
-      }
-    );
-    assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-    assert.ok(fs.existsSync(recordFile), 'recorder stub harus menulis statements ke file');
-    const recorded = JSON.parse(fs.readFileSync(recordFile, 'utf-8'));
-    assert.ok(Array.isArray(recorded.statements) && recorded.statements.length > 0);
-    const hasIfNotExistsTable = recorded.statements.some((s) => /^CREATE TABLE IF NOT EXISTS/.test(s));
-    const hasIfNotExistsIndex = recorded.statements.some((s) => /^CREATE INDEX IF NOT EXISTS/.test(s));
-    assert.ok(hasIfNotExistsTable, 'minimal satu CREATE TABLE harus pakai IF NOT EXISTS');
-    assert.ok(hasIfNotExistsIndex, 'minimal satu CREATE INDEX harus pakai IF NOT EXISTS');
-  } finally {
-    fs.rmSync(tmpRoot, { recursive: true, force: true });
-  }
-});
-
-test('migrate: status SUCCESS → exit 0, stdout "Status: SUCCESS"', () => {
-  const result = runMigrate(
-    [FIXTURE_VALID, `--config=${CONFIG_PG}`],
-    { env: { DBSCHEMA_KIT_TEST_APPLY_STUB: STUB_SUCCESS } }
-  );
-  assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-  assert.match(result.stdout, /Status: SUCCESS/);
-  assert.match(result.stdout, /Statements applied: \d+/);
-  assert.match(result.stdout, /Duration: \d+ms/);
-});
-
-test('migrate: status PARTIAL → exit 1, stderr "Partial apply detected"', () => {
-  const result = runMigrate(
-    [FIXTURE_VALID, `--config=${CONFIG_PG}`],
-    { env: { DBSCHEMA_KIT_TEST_APPLY_STUB: STUB_PARTIAL } }
-  );
-  assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}. stdout: ${result.stdout}`);
-  assert.match(result.stderr, /Partial apply detected/);
-  assert.match(result.stderr, /Manual cleanup may be required/);
-});
-
-test('migrate: status ROLLBACK → exit 1, stderr "ROLLBACK applied"', () => {
-  const result = runMigrate(
-    [FIXTURE_VALID, `--config=${CONFIG_PG}`],
-    { env: { DBSCHEMA_KIT_TEST_APPLY_STUB: STUB_ROLLBACK } }
-  );
-  assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}. stdout: ${result.stdout}`);
-  assert.match(result.stderr, /ROLLBACK applied\. Database state unchanged\./);
-});
-
-test('migrate: connection error (ECONNREFUSED) → exit 1, stderr berisi "Cannot connect"', () => {
-  const result = runMigrate(
-    [FIXTURE_VALID, `--config=${CONFIG_PG}`],
-    { env: { DBSCHEMA_KIT_TEST_APPLY_STUB: STUB_CONN_ERR } }
-  );
-  assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}. stdout: ${result.stdout}`);
-  assert.match(result.stderr, /Cannot connect/);
-});
-
-test('migrate: invalid --drop value → exit 1, stderr menjelaskan error', () => {
-  const result = runMigrate([FIXTURE_VALID, `--config=${CONFIG_PG}`, '--drop=maybe']);
-  assert.strictEqual(result.status, 1);
-  assert.match(result.stderr, /--drop must be 'true' or 'false'/);
-});
-
-test('migrate: unknown option → exit 1', () => {
-  const result = runMigrate([FIXTURE_VALID, `--config=${CONFIG_PG}`, '--bogus']);
-  assert.strictEqual(result.status, 1);
-  assert.match(result.stderr, /Unknown option/);
-});

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

@@ -1,102 +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-validate.js');
-const FIXTURE_VALID = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory');
-const FIXTURE_INVALID = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory-invalid');
-
-function runValidate(args, options = {}) {
-    return spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-        encoding: 'utf-8',
-        env: { ...process.env, NO_COLOR: '1' },
-        ...options
-    });
-}
-
-test('validate: folder valid (mini-inventory) → exit 0 dengan ringkasan 6 model', () => {
-    const result = runValidate([FIXTURE_VALID]);
-    assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-    assert.match(result.stdout, /6 models loaded, 0 errors\./);
-    // Pastikan setidaknya 1 baris success dengan tableName muncul
-    assert.match(result.stdout, /✓ .+: category/);
-    assert.match(result.stdout, /✓ .+: stock_inbound_item/);
-});
-
-test('validate: folder invalid (mini-inventory-invalid) → exit 1 dengan error cross-model', () => {
-    const result = runValidate([FIXTURE_INVALID]);
-    assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-    assert.match(result.stderr, /✗ Table 'orphan': relation 'missing' targets unknown table 'nonexistent_table'/);
-    assert.match(result.stderr, /1 model loaded, 1 error\./);
-});
-
-test('validate: path tidak exist → exit 1 dengan pesan "Schema path not found"', () => {
-    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbschema-kit-validate-'));
-    const ghost = path.join(tmpRoot, 'does-not-exist');
-    try {
-        const result = runValidate([ghost]);
-        assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-        assert.match(result.stderr, /Schema path not found/);
-        assert.match(result.stderr, /0 models loaded, 1 error\./);
-    } finally {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
-    }
-});
-
-test('validate: --format json folder valid → exit 0 dengan JSON report', () => {
-    const result = runValidate([FIXTURE_VALID, '--format', 'json']);
-    assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-    const report = JSON.parse(result.stdout);
-    assert.strictEqual(report.schemaVersion, '1.0');
-    assert.strictEqual(report.summary.modelsLoaded, 6);
-    assert.strictEqual(report.summary.errorCount, 0);
-    assert.strictEqual(report.summary.warningCount, 0);
-    assert.deepStrictEqual(report.issues, []);
-});
-
-test('validate: --format json folder invalid → exit 1 dengan issue terstruktur di JSON', () => {
-    const result = runValidate([FIXTURE_INVALID, '--format=json']);
-    assert.strictEqual(result.status, 1, `expected exit 1, got ${result.status}`);
-    const report = JSON.parse(result.stdout);
-    assert.strictEqual(report.summary.modelsLoaded, 1);
-    assert.strictEqual(report.summary.errorCount, 1);
-    assert.strictEqual(report.issues.length, 1);
-    assert.strictEqual(report.issues[0].severity, 'error');
-    assert.strictEqual(report.issues[0].code, 'relation-unknown-target');
-    assert.strictEqual(report.issues[0].table, 'orphan');
-    assert.strictEqual(report.issues[0].relation, 'missing');
-});
-
-test('validate: --format json path tidak exist → exit 1 dengan schema-load-error issue', () => {
-    const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'dbschema-kit-validate-json-'));
-    const ghost = path.join(tmpRoot, 'does-not-exist');
-    try {
-        const result = runValidate([ghost, '--format', 'json']);
-        assert.strictEqual(result.status, 1);
-        const report = JSON.parse(result.stdout);
-        assert.strictEqual(report.summary.modelsLoaded, 0);
-        assert.strictEqual(report.summary.errorCount, 1);
-        assert.strictEqual(report.issues[0].code, 'schema-load-error');
-        assert.match(report.issues[0].message, /Schema path not found/);
-    } finally {
-        fs.rmSync(tmpRoot, { recursive: true, force: true });
-    }
-});
-
-test('validate: unknown flag → exit 2 dengan usage error', () => {
-    const result = runValidate([FIXTURE_VALID, '--frobnicate']);
-    assert.strictEqual(result.status, 2, `expected exit 2, got ${result.status}`);
-    assert.match(result.stderr, /Unknown option '--frobnicate'/);
-});
-
-test('validate: --format invalid value → exit 2 dengan format error', () => {
-    const result = runValidate([FIXTURE_VALID, '--format', 'xml']);
-    assert.strictEqual(result.status, 2, `expected exit 2, got ${result.status}`);
-    assert.match(result.stderr, /Invalid format 'xml'/);
-});

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

@@ -1,43 +0,0 @@
-'use strict';
-
-const test = require('node:test');
-const assert = require('node:assert');
-const path = require('node:path');
-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_MULTI_SCHEMA = path.resolve(__dirname, 'fixtures', 'multi-schema');
-const FIXTURE_NO_SCHEMA = path.resolve(__dirname, '..', 'fixtures', 'integration', 'mini-inventory');
-
-function runCli(args, options = {}) {
-    return spawnSync(process.execPath, [CLI_SCRIPT, ...args], {
-        encoding: 'utf-8',
-        env: { ...process.env, NO_COLOR: '1' },
-        ...options
-    });
-}
-
-test('dbschema:models: output kolom Schema, model dengan schema tampil di kolom tersebut', () => {
-    const result = runCli([FIXTURE_MULTI_SCHEMA]);
-    assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-    assert.match(result.stdout, /Schema\s+Table\s+Fields\s+PK\s+Indexes\s+Uniques\s+Relations/);
-    assert.match(result.stdout, /inventory\s+products/);
-    assert.match(result.stdout, /audit\s+events/);
-    assert.match(result.stdout, /3 models loaded\./);
-});
-
-test('dbschema:models: model tanpa schema → kolom Schema menampilkan placeholder dash', () => {
-    const result = runCli([FIXTURE_MULTI_SCHEMA]);
-    assert.strictEqual(result.status, 0, `expected exit 0, got ${result.status}. stderr: ${result.stderr}`);
-    // Row "users" model has no schema, kolom pertama harus berupa dash
-    assert.match(result.stdout, /^-\s+users/m);
-});
-
-test('dbschema:models: backward compatibility — fixture tanpa schema (mini-inventory) tetap render dengan kolom Schema kosong', () => {
-    const result = runCli([FIXTURE_NO_SCHEMA]);
-    assert.strictEqual(result.status, 0);
-    // Semua model di mini-inventory tanpa schema → kolom Schema = '-'
-    assert.match(result.stdout, /-\s+category\s+/);
-    assert.match(result.stdout, /6 models loaded\./);
-});

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/introspect-stubs/all-schemas-listing.js

@@ -1,84 +0,0 @@
-'use strict';
-
-/**
- * Stub introspector exposing three schemas (inventory, audit, public)
- * with assorted tables. Used by dbschema-introspect CLI tests to exercise
- * --all-schemas mode where the CLI calls listSchemas() then introspect()
- * with the resolved schema list.
- */
-
-const TABLES = [
-    {
-        schemaName: 'inventory',
-        tableName: 'products',
-        columns: [
-            { column_name: 'product_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 100 }
-        ],
-        primaryKey: ['product_id'],
-        uniques: [],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_products', columns: ['product_id'], unique: true, primary: true }
-        ],
-        checks: []
-    },
-    {
-        schemaName: 'audit',
-        tableName: 'logs',
-        columns: [
-            { column_name: 'log_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'message', data_type: 'text', udt_name: 'text',
-              column_default: null, is_nullable: 'YES' }
-        ],
-        primaryKey: ['log_id'],
-        uniques: [],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_logs', columns: ['log_id'], unique: true, primary: true }
-        ],
-        checks: []
-    },
-    {
-        schemaName: 'public',
-        tableName: 'users',
-        columns: [
-            { column_name: 'user_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'email', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 100 }
-        ],
-        primaryKey: ['user_id'],
-        uniques: [{ name: 'uq_users_email', columns: ['email'] }],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_users', columns: ['user_id'], unique: true, primary: true }
-        ],
-        checks: []
-    }
-];
-
-async function listSchemas() {
-    return Array.from(new Set(TABLES.map(t => t.schemaName))).sort();
-}
-
-async function introspect({ table, schemas }) {
-    if (table) {
-        if (table.includes('.')) {
-            const meta = TABLES.find(t => `${t.schemaName}.${t.tableName}` === table);
-            return { tables: meta ? [meta] : [] };
-        }
-        const meta = TABLES.find(t => t.tableName === table);
-        return { tables: meta ? [meta] : [] };
-    }
-    if (Array.isArray(schemas) && schemas.length > 0) {
-        const set = new Set(schemas);
-        return { tables: TABLES.filter(t => set.has(t.schemaName)) };
-    }
-    return { tables: TABLES };
-}
-
-module.exports = { introspect, listSchemas };

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

@@ -1,13 +0,0 @@
-'use strict';
-
-/**
- * Stub introspector that simulates a database connection failure.
- */
-
-async function introspect() {
-    const err = new Error('connect ECONNREFUSED 127.0.0.1:5432');
-    err.code = 'ECONNREFUSED';
-    throw err;
-}
-
-module.exports = { introspect };

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

@@ -1,12 +0,0 @@
-'use strict';
-
-/**
- * Stub introspector that returns no tables (simulates an empty database
- * or a missing single-table lookup).
- */
-
-async function introspect() {
-    return { tables: [] };
-}
-
-module.exports = { introspect };

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

@@ -1,124 +0,0 @@
-'use strict';
-
-/**
- * Stub introspector returning four tables across two schemas
- * (inventory.products, inventory.categories, audit.events, audit.logs).
- *
- * Used by dbschema-introspect CLI tests to exercise schema-aware bulk modes
- * (--schema=<list>, qualified --table) without touching a real database.
- */
-
-const TABLES = [
-    {
-        schemaName: 'inventory',
-        tableName: 'products',
-        columns: [
-            { column_name: '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: 'name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 100 }
-        ],
-        primaryKey: ['product_id'],
-        uniques: [],
-        foreignKeys: [{
-            name: 'fk_products_category',
-            columns: ['category_id'],
-            references: { schema: 'inventory', table: 'categories', columns: ['category_id'] },
-            onDelete: 'CASCADE',
-            onUpdate: null
-        }],
-        indexes: [
-            { name: 'pk_products', columns: ['product_id'], unique: true, primary: true }
-        ],
-        checks: []
-    },
-    {
-        schemaName: 'inventory',
-        tableName: 'categories',
-        columns: [
-            { column_name: 'category_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 50 }
-        ],
-        primaryKey: ['category_id'],
-        uniques: [],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_categories', columns: ['category_id'], unique: true, primary: true }
-        ],
-        checks: []
-    },
-    {
-        schemaName: 'audit',
-        tableName: 'events',
-        columns: [
-            { column_name: 'event_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'product_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'action', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 50 }
-        ],
-        primaryKey: ['event_id'],
-        uniques: [],
-        foreignKeys: [{
-            name: 'fk_events_product',
-            columns: ['product_id'],
-            references: { schema: 'inventory', table: 'products', columns: ['product_id'] },
-            onDelete: 'CASCADE',
-            onUpdate: null
-        }],
-        indexes: [
-            { name: 'pk_events', columns: ['event_id'], unique: true, primary: true }
-        ],
-        checks: []
-    },
-    {
-        schemaName: 'audit',
-        tableName: 'logs',
-        columns: [
-            { column_name: 'log_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'message', data_type: 'text', udt_name: 'text',
-              column_default: null, is_nullable: 'YES' }
-        ],
-        primaryKey: ['log_id'],
-        uniques: [],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_logs', columns: ['log_id'], unique: true, primary: true }
-        ],
-        checks: []
-    }
-];
-
-function findByQualified(qualified) {
-    return TABLES.find(t => `${t.schemaName}.${t.tableName}` === qualified);
-}
-
-async function introspect({ table, schemas }) {
-    if (table) {
-        // table arg may be qualified ('inventory.products') or bare ('products')
-        if (table.includes('.')) {
-            const meta = findByQualified(table);
-            return { tables: meta ? [meta] : [] };
-        }
-        const meta = TABLES.find(t => t.tableName === table);
-        return { tables: meta ? [meta] : [] };
-    }
-    if (Array.isArray(schemas) && schemas.length > 0) {
-        const set = new Set(schemas);
-        return { tables: TABLES.filter(t => set.has(t.schemaName)) };
-    }
-    // No filter → all tables
-    return { tables: TABLES };
-}
-
-async function listSchemas() {
-    return Array.from(new Set(TABLES.map(t => t.schemaName))).sort();
-}
-
-module.exports = { introspect, listSchemas };

package/generators/tests/unit/lib/dbschema-kit/cli/fixtures/introspect-stubs/single-schema-inventory.js

@@ -1,64 +0,0 @@
-'use strict';
-
-/**
- * Stub introspector containing only the `inventory` schema (2 tables).
- *
- * Used by dbschema-introspect CLI tests to exercise --schema=inventory bulk mode
- * (single-schema flat layout, schema: emitted in body).
- */
-
-const TABLES = [
-    {
-        schemaName: 'inventory',
-        tableName: 'products',
-        columns: [
-            { column_name: 'product_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 100 }
-        ],
-        primaryKey: ['product_id'],
-        uniques: [],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_products', columns: ['product_id'], unique: true, primary: true }
-        ],
-        checks: []
-    },
-    {
-        schemaName: 'inventory',
-        tableName: 'categories',
-        columns: [
-            { column_name: 'category_id', data_type: 'uuid', udt_name: 'uuid',
-              column_default: null, is_nullable: 'NO' },
-            { column_name: 'name', data_type: 'character varying', udt_name: 'varchar',
-              column_default: null, is_nullable: 'NO', character_maximum_length: 50 }
-        ],
-        primaryKey: ['category_id'],
-        uniques: [],
-        foreignKeys: [],
-        indexes: [
-            { name: 'pk_categories', columns: ['category_id'], unique: true, primary: true }
-        ],
-        checks: []
-    }
-];
-
-async function introspect({ table, schemas }) {
-    if (table) {
-        const lookupQualified = table.includes('.') ? table : `inventory.${table}`;
-        const meta = TABLES.find(t => `${t.schemaName}.${t.tableName}` === lookupQualified);
-        return { tables: meta ? [meta] : [] };
-    }
-    if (Array.isArray(schemas) && schemas.length > 0) {
-        const set = new Set(schemas);
-        return { tables: TABLES.filter(t => set.has(t.schemaName)) };
-    }
-    return { tables: TABLES };
-}
-
-async function listSchemas() {
-    return ['inventory'];
-}
-
-module.exports = { introspect, listSchemas };