@restforgejs/platform 5.1.7 → 5.1.20

package/generators/cli/processor/list.js

@@ -0,0 +1,229 @@
+'use strict';
+
+/**
+ * Contract: processor list
+ *
+ * Menampilkan daftar processor dari workbench metadata di working directory
+ * (`metadata/<project>-workbench.json` map `processors`, output dari
+ * `processor create`). File backup (`.backup.` / `.corrupt.`) di-skip.
+ *
+ * Kolom:
+ * - Processor Name : key di `workbench.processors`
+ * - Payload        : nama file `payload/<processor>.json` bila ada, `-` bila tidak
+ * - Processor      : daftar function berformat `nama (METHOD)`; di-wrap
+ *                    maksimal 4 function per baris, tanpa pemotongan
+ *
+ * Output default berupa table human-readable (`--format=text`). Output JSON
+ * (untuk konsumsi AI agent / mcp-server) tersedia via `--format=json`.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const ConfigReader = require('../../lib/config/config-reader');
+
+/**
+ * Baca semua entry processor dari file workbench metadata di working directory.
+ * Read-only: file yang corrupt di-skip dengan warning, tidak ditulis ulang.
+ *
+ * @param {string} workingDir
+ * @returns {{ project: string, name: string, payload: string|null, processor: { name: string, method: string }[] }[]}
+ */
+function readProcessorEntries(workingDir) {
+    const metadataDir = path.join(workingDir, 'metadata');
+    if (!fs.existsSync(metadataDir)) {
+        return [];
+    }
+
+    const files = fs.readdirSync(metadataDir).filter(name =>
+        name.endsWith('-workbench.json') &&
+        !name.includes('.backup.') &&
+        !name.includes('.corrupt.')
+    );
+
+    const entries = [];
+
+    for (const file of files) {
+        let metadata;
+        try {
+            metadata = JSON.parse(fs.readFileSync(path.join(metadataDir, file), 'utf8'));
+        } catch (error) {
+            console.warn(`Warning: skipping unreadable metadata file: ${file} (${error.message})`);
+            continue;
+        }
+
+        if (!metadata || typeof metadata.processors !== 'object' || metadata.processors === null) {
+            continue;
+        }
+
+        const project = metadata.projectName || path.basename(file, '-workbench.json');
+
+        for (const [processorName, processorData] of Object.entries(metadata.processors)) {
+            const payloadFile = `${processorName}.json`;
+            const hasPayload = fs.existsSync(path.join(workingDir, 'payload', payloadFile));
+
+            const procs = processorData && Array.isArray(processorData.processor)
+                ? processorData.processor.map(proc => ({
+                    name: proc.name,
+                    method: proc.method
+                }))
+                : [];
+
+            entries.push({
+                project,
+                name: processorName,
+                payload: hasPayload ? payloadFile : null,
+                processor: procs
+            });
+        }
+    }
+
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    return entries;
+}
+
+/**
+ * Konversi pattern glob sederhana (`*` = karakter apa pun) menjadi RegExp
+ * case-insensitive yang match keseluruhan nama. Tanpa wildcard berarti
+ * exact match.
+ * @param {string} pattern
+ * @returns {RegExp}
+ */
+function patternToRegExp(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp('^' + escaped.replace(/\*/g, '.*') + '$', 'i');
+}
+
+/**
+ * Potong string dengan suffix '..' bila melebihi lebar kolom (pola `project list`).
+ * @param {string} value
+ * @param {number} width
+ * @returns {string}
+ */
+function truncate(value, width) {
+    return value.length > width - 2
+        ? value.substring(0, width - 4) + '..'
+        : value;
+}
+
+/**
+ * Render daftar processor ke format table human-readable.
+ * @param {{ name: string, payload: string|null, processor: { name: string, method: string }[] }[]} entries
+ * @returns {string}
+ */
+function renderHumanTable(entries) {
+    const lines = [];
+
+    const colName = 24;
+    const colPayload = 28;
+    const colProcessor = 44;
+
+    lines.push('');
+    lines.push('Registered Processors:');
+    lines.push('');
+    lines.push(
+        'Processor Name'.padEnd(colName) +
+        'Payload'.padEnd(colPayload) +
+        'Processor'.padEnd(colProcessor)
+    );
+    lines.push('-'.repeat(colName + colPayload + colProcessor));
+
+    const PROCS_PER_LINE = 4;
+
+    for (const entry of entries) {
+        // Wrap function per 4 item; baris pertama menyatu dengan kolom lain,
+        // baris lanjutan di-indent sejajar kolom Processor.
+        const labels = entry.processor.map(proc =>
+            proc.method ? `${proc.name} (${proc.method})` : proc.name
+        );
+
+        const procLines = [];
+        if (labels.length === 0) {
+            procLines.push('-');
+        } else {
+            for (let i = 0; i < labels.length; i += PROCS_PER_LINE) {
+                const chunk = labels.slice(i, i + PROCS_PER_LINE).join(', ');
+                const isLast = i + PROCS_PER_LINE >= labels.length;
+                procLines.push(isLast ? chunk : chunk + ',');
+            }
+        }
+
+        lines.push(
+            truncate(entry.name, colName).padEnd(colName) +
+            truncate(entry.payload || '-', colPayload).padEnd(colPayload) +
+            procLines[0]
+        );
+        for (const continuation of procLines.slice(1)) {
+            lines.push(' '.repeat(colName + colPayload) + continuation);
+        }
+    }
+
+    lines.push('');
+    lines.push(`Total: ${entries.length} processor(s)`);
+    lines.push('');
+
+    return lines.join('\n');
+}
+
+module.exports = {
+    resource: 'processor',
+    verb: 'list',
+    description: 'Menampilkan daftar processor dari workbench metadata di working directory',
+    category: 'management',
+    flags: {
+        format: {
+            type: 'string',
+            required: false,
+            default: 'text',
+            description: 'Format output: `text` (table human-readable) atau `json` (untuk AI agent / mcp-server)'
+        },
+        name: {
+            type: 'string',
+            required: false,
+            default: null,
+            description: 'Filter nama processor, case-insensitive. Wildcard `*` = karakter apa pun (mis. `*order*`); tanpa wildcard berarti exact match'
+        }
+    },
+    examples: [
+        'npx restforge processor list',
+        'npx restforge processor list --format=json',
+        'npx restforge processor list --name=*order*'
+    ],
+    async handler(args) {
+        const workingDir = ConfigReader.getWorkingDirectory();
+        const allEntries = readProcessorEntries(workingDir);
+        const format = (args.format || 'text').toLowerCase();
+
+        const entries = args.name
+            ? allEntries.filter(e => patternToRegExp(args.name).test(e.name))
+            : allEntries;
+
+        if (format === 'json') {
+            const summary = {
+                totalProcessors: entries.length,
+                projects: [...new Set(entries.map(e => e.project))].sort()
+            };
+            if (args.name) {
+                summary.namePattern = args.name;
+            }
+            const output = {
+                schemaVersion: '1.0',
+                source: 'processor-list',
+                summary,
+                processors: entries
+            };
+            process.stdout.write(JSON.stringify(output, null, 2) + '\n');
+            return;
+        }
+
+        if (allEntries.length === 0) {
+            console.log('');
+            console.log('No processors found in this project.');
+            console.log('');
+            console.log('Use "npx restforge processor create" to create a new processor.');
+            console.log('');
+            return;
+        }
+
+        process.stdout.write(renderHumanTable(entries) + '\n');
+    }
+};

package/generators/cli/schema/apply.js

@@ -80,6 +80,7 @@ async function collectTableMeta(introspector, target) {
     const constraints = await introspector.getConstraints(ref);
     const foreignKeys = await introspector.getForeignKeys(ref);
     const indexes = await introspector.getIndexes(ref);
+    const checks = await introspector.getCheckConstraints(ref);
 
     const pkConstraint = constraints.find((c) => c.type === 'PRIMARY KEY');
     const uniqueConstraints = constraints
@@ -94,7 +95,11 @@ async function collectTableMeta(introspector, target) {
         uniques: uniqueConstraints,
         foreignKeys,
         indexes,
-        checks: []
+        // introspect-mapper expects { name, expression }; getCheckConstraints
+        // returns { name, clause } (D5 wiring, Phase 03).
+        checks: Array.isArray(checks)
+            ? checks.map((c) => ({ name: c.name, expression: c.clause }))
+            : []
     };
 }
 

package/generators/cli/schema/diff.js

@@ -69,6 +69,7 @@ async function collectTableMeta(introspector, target) {
     const constraints = await introspector.getConstraints(ref);
     const foreignKeys = await introspector.getForeignKeys(ref);
     const indexes = await introspector.getIndexes(ref);
+    const checks = await introspector.getCheckConstraints(ref);
 
     const pkConstraint = constraints.find((c) => c.type === 'PRIMARY KEY');
     const uniqueConstraints = constraints
@@ -83,7 +84,11 @@ async function collectTableMeta(introspector, target) {
         uniques: uniqueConstraints,
         foreignKeys,
         indexes,
-        checks: []
+        // introspect-mapper expects { name, expression }; getCheckConstraints
+        // returns { name, clause } (D5 wiring, Phase 03).
+        checks: Array.isArray(checks)
+            ? checks.map((c) => ({ name: c.name, expression: c.clause }))
+            : []
     };
 }
 

package/generators/cli/schema/introspect.js

@@ -146,6 +146,7 @@ async function collectTableMeta(introspector, target) {
     const constraints = await introspector.getConstraints(ref);
     const foreignKeys = await introspector.getForeignKeys(ref);
     const indexes = await introspector.getIndexes(ref);
+    const checks = await introspector.getCheckConstraints(ref);
 
     const pkConstraint = constraints.find((c) => c.type === 'PRIMARY KEY');
     const uniqueConstraints = constraints
@@ -160,7 +161,11 @@ async function collectTableMeta(introspector, target) {
         uniques: uniqueConstraints,
         foreignKeys,
         indexes,
-        checks: []
+        // introspect-mapper expects { name, expression }; getCheckConstraints
+        // returns { name, clause } (D5 wiring, Phase 03).
+        checks: Array.isArray(checks)
+            ? checks.map((c) => ({ name: c.name, expression: c.clause }))
+            : []
     };
 }
 
@@ -406,16 +411,32 @@ module.exports = {
         }
 
         const dialect = config.dialect;
-        const emitted = result.tables.map((tableMeta) => {
-            const ir = mapTableMetaToIR(tableMeta, dialect);
-            const source = serialize(ir);
-            return {
-                tableName: ir.tableName,
-                schemaName: ir.schemaName,
-                qualifiedName: ir.qualifiedName,
-                source
-            };
-        });
+        let emitted;
+        try {
+            emitted = result.tables.map((tableMeta) => {
+                // strictSoftDelete: introspect ERROR (R6) bila kolom soft-delete tidak
+                // lengkap / tipe salah / CHECK konsistensi hilang, dan tidak menghasilkan SDF.
+                const ir = mapTableMetaToIR(tableMeta, dialect, { strictSoftDelete: true });
+                const source = serialize(ir);
+                return {
+                    tableName: ir.tableName,
+                    schemaName: ir.schemaName,
+                    qualifiedName: ir.qualifiedName,
+                    source
+                };
+            });
+        } catch (err) {
+            if (err && err.isSoftDeleteIntrospectError) {
+                // Pesan multi-baris (R6/R8) sudah lengkap; print apa adanya lalu rethrow
+                // silent agar cli-entry tidak menambah prefix "Error: " yang merusak format.
+                console.error(err.message);
+                const e = new Error(err.message);
+                e.silent = true;
+                e.exitCode = 1;
+                throw e;
+            }
+            throw err;
+        }
 
         const schemaSet = new Set();
         for (const item of emitted) {

package/generators/lib/data/db-executor.js

@@ -38,33 +38,33 @@ function loadDriver(dialect) {
     case 'postgresql':
       if (!pgDriver) {
         try { pgDriver = require('pg'); } catch (_e) {
-          throw new Error('PostgreSQL driver (pg) tidak terpasang. Jalankan: npm install pg');
+          throw new Error('PostgreSQL driver (pg) is not installed. Run: npm install pg');
         }
       }
       return pgDriver;
     case 'mysql':
       if (!mysqlDriver) {
         try { mysqlDriver = require('mysql2/promise'); } catch (_e) {
-          throw new Error('MySQL driver (mysql2) tidak terpasang. Jalankan: npm install mysql2');
+          throw new Error('MySQL driver (mysql2) is not installed. Run: npm install mysql2');
         }
       }
       return mysqlDriver;
     case 'oracle':
       if (!oracleDriver) {
         try { oracleDriver = require('oracledb'); } catch (_e) {
-          throw new Error('Oracle driver (oracledb) tidak terpasang. Jalankan: npm install oracledb');
+          throw new Error('Oracle driver (oracledb) is not installed. Run: npm install oracledb');
         }
       }
       return oracleDriver;
     case 'sqlite':
       if (!sqliteDriver) {
         try { sqliteDriver = require('better-sqlite3'); } catch (_e) {
-          throw new Error('SQLite driver (better-sqlite3) tidak terpasang. Jalankan: npm rebuild better-sqlite3');
+          throw new Error('SQLite driver (better-sqlite3) is not installed. Run: npm rebuild better-sqlite3');
         }
       }
       return sqliteDriver;
     default:
-      throw new Error(`Dialect tidak didukung: ${dialect}. Didukung: postgresql, mysql, oracle, sqlite`);
+      throw new Error(`Unsupported dialect: ${dialect}. Supported: postgresql, mysql, oracle, sqlite`);
   }
 }
 
@@ -362,7 +362,7 @@ function createSqliteExecutor(config) {
   const Database = loadDriver('sqlite');
   const filePath = config.file || config.database;
   if (!filePath) {
-    throw new Error('SQLite: path file database wajib ada di config (field "file" atau "database")');
+    throw new Error('SQLite: the database file path is required in config (field "file" or "database")');
   }
   let db = null;
 
@@ -419,7 +419,7 @@ function createSqliteExecutor(config) {
  */
 function createExecutor(config) {
   if (!config || typeof config !== 'object') {
-    throw new Error('createExecutor: config wajib berupa object hasil loadConfig');
+    throw new Error('createExecutor: config must be an object produced by loadConfig');
   }
   const dialect = normalizeDialect(config.dialect);
   switch (dialect) {
@@ -428,7 +428,7 @@ function createExecutor(config) {
     case 'oracle': return createOracleExecutor(config);
     case 'sqlite': return createSqliteExecutor(config);
     default:
-      throw new Error(`createExecutor: dialect tidak didukung '${config.dialect}'`);
+      throw new Error(`createExecutor: unsupported dialect '${config.dialect}'`);
   }
 }
 

package/generators/lib/data/envelope.js

@@ -55,7 +55,7 @@ function resolveSink(sink) {
   if (typeof sink.write === 'function') {
     return { write: (chunk) => sink.write(chunk), buffer: null };
   }
-  throw new Error('EnvelopeWriter: sink harus berupa fungsi, object dengan method write(), atau undefined');
+  throw new Error('EnvelopeWriter: sink must be a function, an object with a write() method, or undefined');
 }
 
 /**
@@ -116,7 +116,7 @@ class EnvelopeWriter {
    */
   appendRows(rows) {
     if (this._state !== 'header') {
-      throw new Error('EnvelopeWriter: appendRows() harus dipanggil setelah writeHeader() dan sebelum end()');
+      throw new Error('EnvelopeWriter: appendRows() must be called after writeHeader() and before end()');
     }
     if (!Array.isArray(rows)) {
       throw new Error('EnvelopeWriter: appendRows() membutuhkan array rows');
@@ -138,7 +138,7 @@ class EnvelopeWriter {
       throw new Error('EnvelopeWriter: end() dipanggil sebelum writeHeader()');
     }
     if (this._state === 'ended') {
-      throw new Error('EnvelopeWriter: end() sudah dipanggil');
+      throw new Error('EnvelopeWriter: end() has already been called');
     }
     this._write(']}');
     this._state = 'ended';

package/generators/lib/dbschema-kit/apply-engine.js

@@ -645,6 +645,26 @@ function noteDeferredSections(delta, skipped) {
             });
         }
     }
+
+    // Soft-delete CHECK drift — Detection-only di Fase 1 (TIDAK ada emitter ALTER ADD
+    // CHECK). apply tidak meng-auto-retrofit; cukup laporkan + rekomendasi recreate/manual.
+    if (delta.softDelete && delta.softDelete.match === false) {
+        const sd = delta.softDelete;
+        const description = (sd.sdf && !sd.db)
+            ? `Soft-delete consistency CHECK missing in DB for '${delta.tableName}'. ` +
+              `Detection-only in Phase 1 (no ALTER ADD CHECK): retrofit via ` +
+              `'schema migrate --drop' (recreate) or add the CHECK manually.`
+            : `Soft-delete state mismatch for '${delta.tableName}' ` +
+              `(DB has the consistency CHECK, SDF does not declare softDelete.enabled). ` +
+              `Detection-only: reconcile SDF/DB manually.`;
+        skipped.push({
+            table: delta.tableName,
+            kind: 'soft-delete-check',
+            target: 'soft_delete_consistency',
+            reason: 'detection-only',
+            description
+        });
+    }
 }
 
 // ─────────────────────────────────────────────────────────────

package/generators/lib/dbschema-kit/dialect/mysql.js

@@ -84,6 +84,8 @@ module.exports = {
   maxIdentifierLength: 64,
   // Boolean disimpan sebagai VARCHAR(5) 'true'/'false'; bukan native.
   nativeBoolean: false,
+  // MySQL tidak punya partial index efisien; index soft-delete jadi plain (R11).
+  supportsPartialIndex: false,
   mapType,
   formatDefault,
   quoteIdentifier,

package/generators/lib/dbschema-kit/dialect/oracle.js

@@ -89,6 +89,8 @@ module.exports = {
   maxIdentifierLength: 128,
   // Boolean disimpan sebagai VARCHAR2(5) 'true'/'false'; bukan native.
   nativeBoolean: false,
+  // Oracle tidak punya partial index efisien; index soft-delete jadi plain (R11).
+  supportsPartialIndex: false,
   mapType,
   formatDefault,
   quoteIdentifier,

package/generators/lib/dbschema-kit/dialect/postgres.js

@@ -84,6 +84,10 @@ module.exports = {
   // PostgreSQL punya tipe BOOLEAN native; dialect lain menyimpan boolean
   // sebagai VARCHAR 'true'/'false' dan butuh CHECK sebagai penanda boolean.
   nativeBoolean: true,
+  // PostgreSQL mendukung partial index (`CREATE INDEX ... WHERE <predikat>`).
+  // Dipakai R10/R11: index non-unique pada tabel soft-delete jadi partial
+  // (`WHERE is_deleted = FALSE`).
+  supportsPartialIndex: true,
   mapType,
   formatDefault,
   quoteIdentifier,

package/generators/lib/dbschema-kit/dialect/sqlite.js

@@ -87,6 +87,11 @@ module.exports = {
   maxIdentifierLength: 63,
   // Boolean disimpan sebagai VARCHAR(5) 'true'/'false'; bukan native.
   nativeBoolean: false,
+  // Flag ini menandai apakah index non-unique soft-delete dimaterialisasi sebagai
+  // partial index (R10/R11). Per plan master R11, SQLite masuk grup plain index
+  // (bersama MySQL/Oracle), jadi false. (Soft-delete Fase 1 juga PostgreSQL-only via
+  // guard di emitter, sehingga jalur ini belum aktif untuk SQLite.)
+  supportsPartialIndex: false,
   mapType,
   formatDefault,
   quoteIdentifier,

package/generators/lib/dbschema-kit/diff-engine.js

@@ -588,6 +588,24 @@ function diffChecks(sdfChecks, dbChecks) {
     return { onlyInSdf, onlyInDb, mismatched };
 }
 
+// ─────────────────────────────────────────────────────────────
+// Soft-delete comparison (R8 poin 2 / R6 reverse)
+// ─────────────────────────────────────────────────────────────
+
+// Bandingkan status soft-delete kedua IR. CHECK konsistensi soft-delete bersifat
+// IMPLISIT (diturunkan dari `softDelete.enabled`, tidak pernah di-list di `checks`).
+// introspect-mapper men-set `dbIR.softDelete = { enabled: true }` HANYA bila tabel DB
+// valid (3 kolom + tipe benar + CHECK ada by-nama), dan mengecualikan CHECK soft-delete
+// dari `checks` di kedua sisi. Maka:
+//   - enabled di kedua sisi → CHECK implisit expected di keduanya → tidak ada drift.
+//   - SDF enabled tetapi DB tidak (CHECK absen / kolom-tipe tak valid) → drift NYATA
+//     (Detection-only; dilaporkan apa adanya, bukan disembunyikan, bukan di-auto-fix).
+function diffSoftDelete(sdfIR, dbIR) {
+    const sdf = !!(sdfIR && sdfIR.softDelete && sdfIR.softDelete.enabled === true);
+    const db = !!(dbIR && dbIR.softDelete && dbIR.softDelete.enabled === true);
+    return { sdf, db, match: sdf === db };
+}
+
 // ─────────────────────────────────────────────────────────────
 // Top-level API
 // ─────────────────────────────────────────────────────────────
@@ -610,6 +628,7 @@ function hasAnyDrift(delta) {
     if (delta.checks && delta.checks.onlyInSdf.length > 0) return true;
     if (delta.checks && delta.checks.onlyInDb.length > 0) return true;
     if (delta.checks && delta.checks.mismatched.length > 0) return true;
+    if (delta.softDelete && delta.softDelete.match === false) return true;
     return false;
 }
 
@@ -631,7 +650,8 @@ function diffModel(sdfIR, dbIR) {
         indexes: diffIndexes(sdfIR.indexes, dbIR.indexes),
         uniques: diffUniques(sdfIR.uniques, dbIR.uniques),
         foreignKeys: diffForeignKeys(sdfIR, dbIR),
-        checks: diffChecks(sdfIR.checks, dbIR.checks)
+        checks: diffChecks(sdfIR.checks, dbIR.checks),
+        softDelete: diffSoftDelete(sdfIR, dbIR)
     };
     delta.hasDrift = hasAnyDrift(delta);
 
@@ -706,6 +726,7 @@ module.exports = {
         diffForeignKeys,
         extractForeignKeys,
         diffChecks,
+        diffSoftDelete,
         compareDefaultValue,
         canonicalDefaultPayload,
         normalizeWeakDefault,