@restforgejs/platform 5.1.6 → 5.1.16

package/generators/lib/validators/payload-validator.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
 const ConfigReader = require('../config/config-reader');
+const {
+  SOFT_DELETE_COLUMNS,
+  isSoftDeleteEnabled
+} = require('../dbschema-kit/soft-delete-constants');
 
 /**
  * Validator untuk payload files - fokus HANYA pada validasi
@@ -270,6 +274,14 @@ class PayloadValidator {
     if (payload.fieldPolicy) {
       this.validateFieldPolicy(payload.fieldPolicy, payload.fieldName, fileName);
     }
+
+    // Soft-delete (R17): validasi blok `softDelete` (shape, scope guard Fase 1,
+    // konsistensi reusable, action.restore gate) PLUS guard kolom-tanpa-blok (Q3).
+    // Dipanggil TANPA syarat (bukan `if (payload.softDelete)`): guard kolom-tanpa-blok
+    // dan restore gate justru menangani kasus blok ABSEN (payload hasil `sync`/edit manual
+    // yang menjatuhkan blok), sehingga menggantungnya pada keberadaan blok akan membuat
+    // guard itu dead code. validateSoftDelete early-return untuk payload non-soft-delete.
+    this.validateSoftDelete(payload, fileName);
   }
 
   /**
@@ -486,6 +498,421 @@ class PayloadValidator {
     }
   }
 
+  /**
+   * Validasi blok `softDelete` di RDF (R17) — gate kedua (defense in depth) setelah
+   * `payload generate` menurunkan blok dari SDF (R12). Berguna terutama bila payload
+   * di-edit manual atau di-`sync` (sync TIDAK menurunkan blok; lihat guard kolom-tanpa-blok).
+   *
+   * Dipanggil TANPA syarat dari validatePayloadStructure (bukan `if (payload.softDelete)`):
+   * dua guard di bawah (kolom-tanpa-blok & action.restore) justru menangani kasus blok ABSEN,
+   * sehingga menggantungnya pada keberadaan blok akan membuat guard itu tidak pernah jalan.
+   * Untuk payload non-soft-delete (tanpa kolom soft-delete, tanpa blok, tanpa action.restore)
+   * method langsung return — tidak ada efek samping (backward-compat byte-identik).
+   *
+   * Cakupan (R17 + Q3 + R20):
+   *   - Shape: `enabled` boolean; `reusable` array of { field:string, length:int>0 };
+   *     `visibility` opsional ∈ {active_only, deleted_only, include_deleted}.
+   *   - Konsistensi reusable: field ada di `fieldName`; unique
+   *     (`fieldValidation[field].constraints.unique === true`); `length` === maxLength field (R13).
+   *   - Scope guard Fase 1 (ERROR "not supported in Phase 1"): `purge` di blok; `restoreEndpoint`
+   *     di blok (sisa arsitektur lama, restore via `action.restore` R20); `masterDetail`
+   *     enabled bersama `softDelete.enabled`.
+   *   - Guard kolom-tanpa-blok (Q3): kolom soft-delete ada di `fieldName` tetapi blok absen /
+   *     `enabled !== true` → ERROR.
+   *   - Restore gate (R20): `action.restore === true` mewajibkan `softDelete.enabled === true`.
+   *   - Gate FK-aware Fase 1.5 (G1-G5, via `validateSoftDeleteFk`): tolak cascade→anak non-soft-delete
+   *     (G1), `onDelete:setNull` (G2, deferral), node cascade composite-PK (G3), plus shape defensif
+   *     `softDeleteFkChildren`/`softDeleteCascadeTree` (G4) dan `softDeleteFkParents` (G5).
+   *
+   * Validasi SDF (R3/R5/R7/R9 — lapis schema) TIDAK diduplikasi di sini; itu ditegakkan
+   * `validateSchema`/`validateSoftDelete` SDF saat `schema validate`/`migrate`/`diff`/`apply`.
+   *
+   * @param {Object} payload - Payload utuh (butuh softDelete, fieldName, fieldValidation, action, masterDetail)
+   * @param {string} fileName - Nama file untuk error message
+   * @throws {Error} Jika blok softDelete / guard scope / gate dilanggar
+   */
+  static validateSoftDelete(payload, fileName) {
+    const fieldNames = Array.isArray(payload.fieldName) ? payload.fieldName : [];
+    const softDelete = payload.softDelete;
+    const hasBlock = softDelete !== undefined && softDelete !== null;
+    const presentColumns = SOFT_DELETE_COLUMNS.filter((col) => fieldNames.includes(col));
+    const hasSoftDeleteColumns = presentColumns.length > 0;
+    const restoreRequested = !!(payload.action && payload.action.restore === true);
+
+    // FK-aware metadata (Fase 1.5). `softDeleteFkChildren`/`softDeleteCascadeTree` dipersist hanya
+    // untuk tabel soft-delete (di-guard hasSoftDeleteColumns di payload-runner); `softDeleteFkParents`
+    // (forward registry FK-SD-1) dipersist di LUAR guard itu, sehingga muncul juga pada tabel anak
+    // NON-soft-delete (mis. `visitors`: tanpa blok/kolom soft-delete). Ketiganya disertakan di
+    // early-return agar payload yang membawa metadata FK TANPA blok/kolom tetap mencapai gate FK di
+    // bawah (validateSoftDeleteFk) — termasuk shape guard `softDeleteFkParents` (G5) — alih-alih
+    // lolos diam-diam.
+    const hasFkMetadata =
+      payload.softDeleteFkParents !== undefined ||
+      payload.softDeleteFkChildren !== undefined ||
+      payload.softDeleteCascadeTree !== undefined;
+
+    // Backward-compat: payload tanpa blok, tanpa kolom soft-delete, tanpa action.restore,
+    // tanpa metadata FK tidak terpengaruh sama sekali (lolos seperti biasa).
+    if (!hasBlock && !hasSoftDeleteColumns && !restoreRequested && !hasFkMetadata) {
+      return;
+    }
+
+    // --- Shape + konsistensi blok (bila blok ada) ---
+    // Divalidasi LEBIH DULU sehingga blok yang malformed (mis. `enabled` bukan boolean)
+    // memberi error shape yang presisi, bukan tertangkap guard kolom-tanpa-blok di bawah
+    // (yang pesannya menyesatkan untuk blok yang sebenarnya ADA tetapi salah bentuk).
+    if (hasBlock) {
+      if (typeof softDelete !== 'object' || Array.isArray(softDelete)) {
+        throw new Error(`softDelete in ${fileName} must be a non-null object`);
+      }
+
+      // Scope guard Fase 1: purge ditolak (operasi destruktif permanen, fase lanjut).
+      // Dicek lebih dulu, lepas dari nilai `enabled` (purge di luar scope total).
+      if (softDelete.purge !== undefined) {
+        throw new Error(
+          `softDelete.purge in ${fileName} is not supported in Phase 1: purge is a destructive, ` +
+          `permanent operation deferred to a later phase. Remove the purge key from the softDelete block.`
+        );
+      }
+
+      // Scope guard Fase 1: restoreEndpoint ditolak (sisa arsitektur lama). Restore di Fase 1
+      // diaktifkan via `action.restore` (R20), bukan key `restoreEndpoint` di blok softDelete.
+      // Dicek berdampingan dengan purge, lepas dari nilai `enabled`.
+      if (softDelete.restoreEndpoint !== undefined) {
+        throw new Error(
+          `softDelete.restoreEndpoint in ${fileName} is not supported in Phase 1: it is a remnant of the ` +
+          `old architecture. Enable the restore endpoint via action.restore = true instead (R20), then ` +
+          `remove the restoreEndpoint key from the softDelete block.`
+        );
+      }
+
+      // enabled: harus boolean (R17).
+      if (typeof softDelete.enabled !== 'boolean') {
+        throw new Error(`softDelete.enabled in ${fileName} is required and must be a boolean`);
+      }
+
+      // visibility: opsional (default active_only); harus salah satu enum (R13/R15).
+      if (softDelete.visibility !== undefined) {
+        const VALID_VISIBILITY = ['active_only', 'deleted_only', 'include_deleted'];
+        if (!VALID_VISIBILITY.includes(softDelete.visibility)) {
+          throw new Error(
+            `softDelete.visibility '${softDelete.visibility}' in ${fileName} is invalid. ` +
+            `Valid values: ${VALID_VISIBILITY.join(', ')} (default: active_only).`
+          );
+        }
+      }
+
+      // reusable: opsional. Bila ada, harus array of { field:string, length:int>0 } dengan
+      // konsistensi unique + base length (R13). Blok bisa { enabled: true } tanpa reusable.
+      if (softDelete.reusable !== undefined) {
+        if (!Array.isArray(softDelete.reusable)) {
+          throw new Error(`softDelete.reusable in ${fileName} must be an array of { field, length }`);
+        }
+
+        for (let i = 0; i < softDelete.reusable.length; i++) {
+          const entry = softDelete.reusable[i];
+
+          if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new Error(`softDelete.reusable[${i}] in ${fileName} must be an object { field, length }`);
+          }
+
+          if (typeof entry.field !== 'string' || entry.field.trim() === '') {
+            throw new Error(
+              `softDelete.reusable[${i}].field in ${fileName} is required and must be a non-empty string`
+            );
+          }
+
+          if (!Number.isInteger(entry.length) || entry.length <= 0) {
+            throw new Error(
+              `softDelete.reusable[${i}].length (field '${entry.field}') in ${fileName} must be an integer greater than 0`
+            );
+          }
+
+          // field harus ada di fieldName.
+          if (!fieldNames.includes(entry.field)) {
+            throw new Error(
+              `softDelete.reusable references field '${entry.field}' in ${fileName} which is not in fieldName`
+            );
+          }
+
+          // field harus unique: fieldValidation[field].constraints.unique === true.
+          const fv = Array.isArray(payload.fieldValidation)
+            ? payload.fieldValidation.find((f) => f && f.name === entry.field)
+            : undefined;
+          const constraints = (fv && fv.constraints) || {};
+
+          if (constraints.unique !== true) {
+            throw new Error(
+              `softDelete.reusable field '${entry.field}' in ${fileName} must be unique ` +
+              `(fieldValidation['${entry.field}'].constraints.unique must be true)`
+            );
+          }
+
+          // Konsistensi base length (R13): reusable.length === fieldValidation[field].constraints.maxLength.
+          // Menutup kasus edit manual yang membuat keduanya tidak lagi cocok (mis. maxLength diubah).
+          if (constraints.maxLength !== entry.length) {
+            throw new Error(
+              `softDelete.reusable field '${entry.field}' length (${entry.length}) in ${fileName} must equal ` +
+              `fieldValidation['${entry.field}'].constraints.maxLength (${constraints.maxLength}); ` +
+              `the base length and the field maxLength must be identical (R13).`
+            );
+          }
+        }
+      }
+    }
+
+    // `enabled === true` dipakai konsisten untuk guard cross-cutting di bawah. isSoftDeleteEnabled
+    // memeriksa payload.softDelete.enabled === true (false bila blok absen / enabled bukan true).
+    // Bila blok ada, shape di atas sudah memastikan `enabled` benar-benar boolean.
+    const blockEnabled = isSoftDeleteEnabled(payload);
+
+    // --- Guard kolom-tanpa-blok (Q3, defense in depth) ---
+    // Kolom soft-delete ada di fieldName tetapi blok absen atau enabled !== true. Menangkap
+    // payload hasil `sync`/edit manual yang menjatuhkan blok sehingga tabel soft-delete
+    // diperlakukan sebagai tabel normal (/delete jadi hard delete, kolom soft-delete writable).
+    if (hasSoftDeleteColumns && !blockEnabled) {
+      throw new Error(
+        `Payload ${fileName} has soft-delete column(s) [${presentColumns.join(', ')}] in fieldName ` +
+        `but no enabled 'softDelete' block (softDelete.enabled must be true). This usually means the ` +
+        `block was dropped by 'payload sync' or a manual edit, which would treat a soft-delete table ` +
+        `as a normal table (/delete becomes a hard delete and the soft-delete columns become ` +
+        `user-writable). Re-derive the payload with 'payload generate --schema-path=<sdf>' or restore ` +
+        `the softDelete block.`
+      );
+    }
+
+    // --- Restore gate (R20) ---
+    // action.restore = true mewajibkan softDelete.enabled = true (restore membalik soft delete).
+    if (restoreRequested && !blockEnabled) {
+      throw new Error(
+        `Payload ${fileName} sets action.restore = true but softDelete.enabled is not true. ` +
+        `The restore endpoint reverses a soft delete and requires an enabled softDelete block (R20).`
+      );
+    }
+
+    // Scope guard Fase 1: master-detail + soft-delete ditolak. Cascade soft-delete butuh
+    // SQL filter injection (detailQuery) yang ditunda ke fase lanjut (Q4 Phase 05).
+    const masterDetailEnabled = !!(payload.masterDetail && payload.masterDetail.enabled);
+    if (masterDetailEnabled && blockEnabled) {
+      throw new Error(
+        `Payload ${fileName} combines masterDetail with an enabled softDelete block, which is not ` +
+        `supported in Phase 1. Cascade soft-delete needs custom SQL filter injection (detailQuery) ` +
+        `deferred to a later phase; Phase 1 covers single-table soft-delete only.`
+      );
+    }
+
+    // --- Gate FK-aware Fase 1.5 (G1-G4) ---
+    // Penolakan konfigurasi FK-aware yang TIDAK didukung Fase 1.5, plus shape defensif untuk
+    // metadata yang di-edit manual. Dipisah ke sub-fungsi sendiri; internal no-op bila payload
+    // tidak membawa softDeleteFkChildren/softDeleteCascadeTree (backward-compat byte-identik).
+    PayloadValidator.validateSoftDeleteFk(payload, fileName);
+  }
+
+  /**
+   * Gate FK-aware soft-delete (Fase 1.5) — perluasan R17 (defense in depth) yang menolak
+   * konfigurasi FK-aware INVALID yang belum didukung Fase 1.5. Dipanggil dari validateSoftDelete
+   * setelah seluruh guard R17/Q3/R20. Beroperasi atas metadata FK yang diturunkan `payload generate`:
+   * `softDeleteFkChildren` (reverse registry) + `softDeleteCascadeTree` (closure cascade) hanya
+   * dipersist untuk tabel soft-delete; `softDeleteFkParents` (forward registry FK-SD-1) dipersist juga
+   * untuk tabel anak NON-soft-delete (mis. `visitors`), sehingga shape guard-nya (G5) di sini adalah
+   * satu-satunya gate defensif untuknya. Payload tanpa ketiga field ini tidak terpengaruh (no-op).
+   *
+   * Lima penolakan:
+   *   - G1: entry `softDeleteFkChildren` `onDelete:'cascade'` ke anak `childSoftDelete:false` →
+   *     ERROR (cascade men-soft-delete anak, tetapi anak tanpa kolom soft-delete tak bisa).
+   *   - G2: entry `onDelete:'setNull'` → ERROR (deferral Fase 1.5; SET NULL menuntut mutasi kolom
+   *     FK anak yang ditunda).
+   *   - G3: node `softDeleteCascadeTree` dengan `pk` array (composite PK) → ERROR (walk cascade
+   *     memakai single-column `row[node.pk]` sebagai identitas visited-set/lock; di luar scope).
+   *   - G4: shape defensif — tipe dasar `softDeleteFkChildren`/`softDeleteCascadeTree` salah (mis.
+   *     bukan array, `onDelete` di luar enum) → ERROR jelas, bukan meledak saat generate handler.
+   *   - G5: shape defensif `softDeleteFkParents` — tiap entry `{ columns:[string], refTable:string,
+   *     refColumns:[string] }`; tipe dasar salah → ERROR jelas (simetri G4).
+   *
+   * Cakupan G1/G2 sengaja per-tabel pada `softDeleteFkChildren` (anak LANGSUNG master ini). Edge
+   * cascade→non-SD/setNull yang lebih dalam (cucu) muncul sebagai anak langsung pada RDF tabel
+   * perantara (yang juga soft-delete dan divalidasi sendiri), sehingga tertutup saat tiap tabel
+   * soft-delete melewati validator ini. `softDeleteCascadeTree` master hanya cermin agregat dan
+   * tidak perlu validasi semantik ulang anaknya.
+   *
+   * @param {Object} payload - Payload utuh (membaca softDeleteFkChildren, softDeleteCascadeTree)
+   * @param {string} fileName - Nama file untuk error message
+   * @throws {Error} Jika konfigurasi FK-aware invalid (G1-G4) ditemukan
+   */
+  static validateSoftDeleteFk(payload, fileName) {
+    const VALID_ON_DELETE = ['cascade', 'restrict', 'setNull'];
+    const fkChildren = payload.softDeleteFkChildren;
+    const cascadeTree = payload.softDeleteCascadeTree;
+
+    // --- softDeleteFkChildren: shape (G4) + G1 (cascade→non-SD) + G2 (setNull) ---
+    if (fkChildren !== undefined) {
+      if (!Array.isArray(fkChildren)) {
+        throw new Error(
+          `softDeleteFkChildren in ${fileName} must be an array of FK child entries ` +
+          `{ childTable, childColumns, parentColumn, onDelete, childSoftDelete }.`
+        );
+      }
+
+      for (let i = 0; i < fkChildren.length; i++) {
+        const entry = fkChildren[i];
+
+        // G4 shape per-entry.
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+          throw new Error(`softDeleteFkChildren[${i}] in ${fileName} must be an object`);
+        }
+        if (typeof entry.childTable !== 'string' || entry.childTable.trim() === '') {
+          throw new Error(
+            `softDeleteFkChildren[${i}].childTable in ${fileName} is required and must be a non-empty string`
+          );
+        }
+        if (
+          !Array.isArray(entry.childColumns) ||
+          entry.childColumns.length === 0 ||
+          !entry.childColumns.every((c) => typeof c === 'string' && c.trim() !== '')
+        ) {
+          throw new Error(
+            `softDeleteFkChildren[${i}].childColumns (child '${entry.childTable}') in ${fileName} ` +
+            `must be a non-empty array of non-empty strings`
+          );
+        }
+        if (typeof entry.parentColumn !== 'string' || entry.parentColumn.trim() === '') {
+          throw new Error(
+            `softDeleteFkChildren[${i}].parentColumn (child '${entry.childTable}') in ${fileName} ` +
+            `is required and must be a non-empty string`
+          );
+        }
+        if (!VALID_ON_DELETE.includes(entry.onDelete)) {
+          throw new Error(
+            `softDeleteFkChildren[${i}].onDelete '${entry.onDelete}' (child '${entry.childTable}') in ` +
+            `${fileName} is invalid. Valid values: ${VALID_ON_DELETE.join(', ')}.`
+          );
+        }
+        if (typeof entry.childSoftDelete !== 'boolean') {
+          throw new Error(
+            `softDeleteFkChildren[${i}].childSoftDelete (child '${entry.childTable}') in ${fileName} ` +
+            `must be a boolean`
+          );
+        }
+
+        // G2 — setNull ditunda di Fase 1.5. Dicek sebelum G1 (keduanya eksklusif per entry):
+        // setNull menuntut mutasi kolom FK anak (interaksi notnull) yang belum dikerjakan.
+        if (entry.onDelete === 'setNull') {
+          throw new Error(
+            `softDeleteFkChildren references child '${entry.childTable}' with onDelete: 'setNull' in ` +
+            `${fileName}, which is not supported in Phase 1.5. SET NULL requires mutating the child FK ` +
+            `column (interaction with notnull) and is deferred to a later phase. Change onDelete to ` +
+            `'restrict' or 'cascade'.`
+          );
+        }
+
+        // G1 — cascade ke anak non-soft-delete. Cascade men-soft-delete anak, tetapi tabel anak
+        // tanpa kolom soft-delete tidak dapat di-soft-delete. restrict ke anak non-SD tetap VALID.
+        if (entry.onDelete === 'cascade' && entry.childSoftDelete === false) {
+          throw new Error(
+            `softDeleteFkChildren references child '${entry.childTable}' with onDelete: 'cascade' but ` +
+            `the child table is not soft-delete-enabled (childSoftDelete: false) in ${fileName}. Cascade ` +
+            `soft-deletes the child, but a table without soft-delete columns cannot be soft-deleted. ` +
+            `Either make '${entry.childTable}' soft-delete-enabled, or change onDelete to 'restrict'.`
+          );
+        }
+      }
+    }
+
+    // --- softDeleteCascadeTree: shape (G4) + G3 (composite-PK node) ---
+    if (cascadeTree !== undefined) {
+      if (typeof cascadeTree !== 'object' || cascadeTree === null || Array.isArray(cascadeTree)) {
+        throw new Error(
+          `softDeleteCascadeTree in ${fileName} must be a non-null object { master, order, nodes }`
+        );
+      }
+      const nodes = cascadeTree.nodes;
+      if (typeof nodes !== 'object' || nodes === null || Array.isArray(nodes)) {
+        throw new Error(
+          `softDeleteCascadeTree.nodes in ${fileName} must be an object keyed by qualified table name`
+        );
+      }
+
+      for (const key of Object.keys(nodes)) {
+        const node = nodes[key];
+        if (!node || typeof node !== 'object' || Array.isArray(node)) {
+          throw new Error(`softDeleteCascadeTree.nodes['${key}'] in ${fileName} must be an object`);
+        }
+        const label = (typeof node.table === 'string' && node.table) || key;
+        const pk = node.pk;
+
+        // G3 — composite (multi-column) PK di luar scope FK-SD-3 Fase 1.5. Walk cascade memakai
+        // `row[node.pk]` single-column sebagai identitas visited-set/lock; pk array (composite,
+        // atau kosong dari IR tanpa PK) tidak dapat dipakai.
+        if (Array.isArray(pk)) {
+          throw new Error(
+            `softDeleteCascadeTree node '${label}' in ${fileName} has a composite (multi-column) ` +
+            `primary key (pk: [${pk.join(', ')}]), which is out of scope for Phase 1.5 cascade ` +
+            `(FK-SD-3). The cascade walk uses a single-column pk (row[node.pk]) as the visited-set/lock ` +
+            `identity. Composite-PK cascade is deferred to a later phase.`
+          );
+        }
+
+        // G4 shape — pk single harus string non-kosong (identitas walk).
+        if (typeof pk !== 'string' || pk.trim() === '') {
+          throw new Error(
+            `softDeleteCascadeTree node '${label}' in ${fileName} must have a non-empty string 'pk' ` +
+            `(single-column primary key used as the cascade walk identity)`
+          );
+        }
+      }
+    }
+
+    // --- softDeleteFkParents: shape (G5) ---
+    // Forward registry FK-SD-1: tiap entry { columns:[string], refTable:string, refColumns:[string] }.
+    // Berbeda dari softDeleteFkChildren/softDeleteCascadeTree (hanya pada tabel soft-delete), field
+    // ini dipersist juga pada tabel anak NON-soft-delete (mis. visitors), sehingga shape guard di sini
+    // adalah satu-satunya gate defensif untuknya — simetri dengan G4 softDeleteFkChildren. Hanya
+    // memeriksa bentuk dasar (array/object/string non-kosong); semantik FK (kolom benar-benar FK ke
+    // parent soft-delete) ditegakkan SDF saat schema validate, bukan diduplikasi di sini.
+    const fkParents = payload.softDeleteFkParents;
+    if (fkParents !== undefined) {
+      if (!Array.isArray(fkParents)) {
+        throw new Error(
+          `softDeleteFkParents in ${fileName} must be an array of FK parent entries ` +
+          `{ columns, refTable, refColumns }.`
+        );
+      }
+
+      for (let i = 0; i < fkParents.length; i++) {
+        const entry = fkParents[i];
+
+        // G5 shape per-entry.
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+          throw new Error(`softDeleteFkParents[${i}] in ${fileName} must be an object`);
+        }
+        if (
+          !Array.isArray(entry.columns) ||
+          entry.columns.length === 0 ||
+          !entry.columns.every((c) => typeof c === 'string' && c.trim() !== '')
+        ) {
+          throw new Error(
+            `softDeleteFkParents[${i}].columns in ${fileName} must be a non-empty array of non-empty strings`
+          );
+        }
+        if (typeof entry.refTable !== 'string' || entry.refTable.trim() === '') {
+          throw new Error(
+            `softDeleteFkParents[${i}].refTable in ${fileName} is required and must be a non-empty string`
+          );
+        }
+        if (
+          !Array.isArray(entry.refColumns) ||
+          entry.refColumns.length === 0 ||
+          !entry.refColumns.every((c) => typeof c === 'string' && c.trim() !== '')
+        ) {
+          throw new Error(
+            `softDeleteFkParents[${i}].refColumns (refTable '${entry.refTable}') in ${fileName} ` +
+            `must be a non-empty array of non-empty strings`
+          );
+        }
+      }
+    }
+  }
+
   /**
    * Validasi khusus untuk fieldName array
    * @param {Array} fieldNames - Array nama field
@@ -705,22 +1132,22 @@ class PayloadValidator {
    */
   static validateSearchColumns(searchColumns, fileName) {
     if (!Array.isArray(searchColumns)) {
-      throw new Error(`Property 'searchColumns' di ${fileName} harus berupa array`);
+      throw new Error(`Property 'searchColumns' in ${fileName} must be an array`);
     }
 
     for (let i = 0; i < searchColumns.length; i++) {
       const column = searchColumns[i];
       
       if (typeof column !== 'object' || column === null) {
-        throw new Error(`Search column index ${i} di ${fileName} harus berupa object`);
+        throw new Error(`Search column index ${i} in ${fileName} must be an object`);
       }
 
       if (!column.name || typeof column.name !== 'string') {
-        throw new Error(`Search column index ${i} di ${fileName} harus memiliki property 'name' berupa string`);
+        throw new Error(`Search column index ${i} in ${fileName} must have a 'name' property of type string`);
       }
 
       if (column.searchable !== undefined && typeof column.searchable !== 'boolean') {
-        throw new Error(`Search column '${column.name}' di ${fileName} property 'searchable' harus boolean`);
+        throw new Error(`Search column '${column.name}' in ${fileName}: property 'searchable' must be a boolean`);
       }
     }
   }
@@ -733,7 +1160,7 @@ class PayloadValidator {
    */
   static validateFilters(filters, fileName) {
     if (!Array.isArray(filters)) {
-      throw new Error(`Property 'filters' di ${fileName} harus berupa array`);
+      throw new Error(`Property 'filters' in ${fileName} must be an array`);
     }
 
     const validFilterTypes = ['combobox', 'select', 'daterange', 'text', 'number'];
@@ -742,35 +1169,35 @@ class PayloadValidator {
       const filter = filters[i];
       
       if (typeof filter !== 'object' || filter === null) {
-        throw new Error(`Filter index ${i} di ${fileName} harus berupa object`);
+        throw new Error(`Filter index ${i} in ${fileName} must be an object`);
       }
 
       // Required properties
       if (!filter.name || typeof filter.name !== 'string') {
-        throw new Error(`Filter index ${i} di ${fileName} harus memiliki property 'name' berupa string`);
+        throw new Error(`Filter index ${i} in ${fileName} must have a 'name' property of type string`);
       }
 
       if (!filter.type || typeof filter.type !== 'string') {
-        throw new Error(`Filter '${filter.name}' di ${fileName} harus memiliki property 'type' berupa string`);
+        throw new Error(`Filter '${filter.name}' in ${fileName} must have a 'type' property of type string`);
       }
 
       if (!validFilterTypes.includes(filter.type)) {
-        throw new Error(`Filter '${filter.name}' di ${fileName} memiliki type tidak valid: ${filter.type}. Valid types: ${validFilterTypes.join(', ')}`);
+        throw new Error(`Filter '${filter.name}' in ${fileName} has an invalid type: ${filter.type}. Valid types: ${validFilterTypes.join(', ')}`);
       }
 
       // Type-specific validation
       if (['combobox', 'select'].includes(filter.type)) {
         if (!filter.targetField || typeof filter.targetField !== 'string') {
-          throw new Error(`Filter '${filter.name}' type '${filter.type}' di ${fileName} harus memiliki property 'targetField'`);
+          throw new Error(`Filter '${filter.name}' of type '${filter.type}' in ${fileName} must have a 'targetField' property`);
         }
       }
 
       if (filter.type === 'daterange') {
         if (!filter.startField || typeof filter.startField !== 'string') {
-          throw new Error(`Filter '${filter.name}' type 'daterange' di ${fileName} harus memiliki property 'startField'`);
+          throw new Error(`Filter '${filter.name}' of type 'daterange' in ${fileName} must have a 'startField' property`);
         }
         if (!filter.endField || typeof filter.endField !== 'string') {
-          throw new Error(`Filter '${filter.name}' type 'daterange' di ${fileName} harus memiliki property 'endField'`);
+          throw new Error(`Filter '${filter.name}' of type 'daterange' in ${fileName} must have an 'endField' property`);
         }
       }
     }
@@ -784,17 +1211,17 @@ class PayloadValidator {
    */
   static validateAdvancedQueries(advancedQueries, fileName) {
     if (typeof advancedQueries !== 'object' || advancedQueries === null) {
-      throw new Error(`Property 'advancedQueries' di ${fileName} harus berupa object`);
+      throw new Error(`Property 'advancedQueries' in ${fileName} must be an object`);
     }
 
     for (const [queryName, querySource] of Object.entries(advancedQueries)) {
       if (typeof querySource !== 'string' || querySource.trim().length === 0) {
-        throw new Error(`Advanced query '${queryName}' di ${fileName} harus berupa string non-empty`);
+        throw new Error(`Advanced query '${queryName}' in ${fileName} must be a non-empty string`);
       }
 
       // Validate query name
       if (!/^[a-zA-Z][a-zA-Z0-9_]*$/.test(queryName)) {
-        throw new Error(`Advanced query name '${queryName}' di ${fileName} tidak valid. Harus dimulai dengan huruf dan hanya mengandung huruf, angka, underscore`);
+        throw new Error(`Advanced query name '${queryName}' in ${fileName} is invalid. It must start with a letter and contain only letters, numbers, and underscores`);
       }
 
       // Validate file reference if applicable
@@ -815,22 +1242,22 @@ class PayloadValidator {
    */
   static validateNestedQueries(nestedQueries, fileName) {
     if (!Array.isArray(nestedQueries)) {
-      throw new Error(`Property 'nestedQueries' di ${fileName} harus berupa array`);
+      throw new Error(`Property 'nestedQueries' in ${fileName} must be an array`);
     }
 
     for (let i = 0; i < nestedQueries.length; i++) {
       const nestedQuery = nestedQueries[i];
       
       if (typeof nestedQuery !== 'object' || nestedQuery === null) {
-        throw new Error(`Nested query index ${i} di ${fileName} harus berupa object`);
+        throw new Error(`Nested query index ${i} in ${fileName} must be an object`);
       }
 
       if (!nestedQuery.name || typeof nestedQuery.name !== 'string') {
-        throw new Error(`Nested query index ${i} di ${fileName} harus memiliki property 'name' berupa string`);
+        throw new Error(`Nested query index ${i} in ${fileName} must have a 'name' property of type string`);
       }
 
       if (!nestedQuery.query || typeof nestedQuery.query !== 'string') {
-        throw new Error(`Nested query '${nestedQuery.name}' di ${fileName} harus memiliki property 'query' berupa string`);
+        throw new Error(`Nested query '${nestedQuery.name}' in ${fileName} must have a 'query' property of type string`);
       }
 
       // Validate file reference if applicable
@@ -852,13 +1279,13 @@ class PayloadValidator {
    */
   static validateFileReference(fileReference, fileName, context) {
     if (!fileReference.startsWith('file:')) {
-      throw new Error(`File reference untuk ${context} di ${fileName} harus dimulai dengan 'file:'`);
+      throw new Error(`File reference for ${context} in ${fileName} must start with 'file:'`);
     }
 
     const relativePath = fileReference.substring(5);
     
     if (!relativePath || relativePath.trim().length === 0) {
-      throw new Error(`File reference untuk ${context} di ${fileName} tidak memiliki path yang valid`);
+      throw new Error(`File reference for ${context} in ${fileName} does not have a valid path`);
     }
 
     // Validate file extension - allow both .sql and .json for queries
@@ -904,7 +1331,7 @@ class PayloadValidator {
     
     for (const pattern of dangerousPatterns) {
       if (pattern.test(trimmedSql)) {
-        throw new Error(`Inline SQL untuk ${context} di ${fileName} mengandung keyword berbahaya: ${pattern.source}`);
+        throw new Error(`Inline SQL for ${context} in ${fileName} contains a dangerous keyword: ${pattern.source}`);
       }
     }
   }
@@ -949,8 +1376,8 @@ class PayloadValidator {
         );
         
         if (conflictingFields.length > 0) {
-          result.warnings.push(`Field names berpotensi konflik dengan Oracle reserved words: ${conflictingFields.join(', ')}`);
-          result.recommendations.push('Pertimbangkan untuk mengganti nama field atau gunakan quoted identifiers');
+          result.warnings.push(`Field names may conflict with Oracle reserved words: ${conflictingFields.join(', ')}`);
+          result.recommendations.push('Consider renaming the fields or using quoted identifiers');
         }
       }
 
@@ -1141,7 +1568,7 @@ class PayloadValidator {
       );
       
       if (missingActions.length > 0) {
-        throw new Error(`Payload harus memiliki actions berikut: ${missingActions.join(', ')}`);
+        throw new Error(`Payload must include the following actions: ${missingActions.join(', ')}`);
       }
     }
 
@@ -1153,7 +1580,7 @@ class PayloadValidator {
       );
       
       if (missingFields.length > 0) {
-        throw new Error(`Payload harus memiliki fields berikut: ${missingFields.join(', ')}`);
+        throw new Error(`Payload must include the following fields: ${missingFields.join(', ')}`);
       }
     }
 
@@ -1161,7 +1588,7 @@ class PayloadValidator {
     if (requirements.minFieldCount && typeof requirements.minFieldCount === 'number') {
       const fieldCount = payload.fieldName ? payload.fieldName.length : 0;
       if (fieldCount < requirements.minFieldCount) {
-        throw new Error(`Payload harus memiliki minimal ${requirements.minFieldCount} fields, ditemukan ${fieldCount}`);
+        throw new Error(`Payload must have at least ${requirements.minFieldCount} fields, found ${fieldCount}`);
       }
     }
 
@@ -1169,7 +1596,7 @@ class PayloadValidator {
     if (requirements.maxFieldCount && typeof requirements.maxFieldCount === 'number') {
       const fieldCount = payload.fieldName ? payload.fieldName.length : 0;
       if (fieldCount > requirements.maxFieldCount) {
-        throw new Error(`Payload tidak boleh memiliki lebih dari ${requirements.maxFieldCount} fields, ditemukan ${fieldCount}`);
+        throw new Error(`Payload must not have more than ${requirements.maxFieldCount} fields, found ${fieldCount}`);
       }
     }
 
@@ -1177,7 +1604,7 @@ class PayloadValidator {
     if (requirements.tableNamePattern && typeof requirements.tableNamePattern === 'string') {
       const pattern = new RegExp(requirements.tableNamePattern);
       if (!pattern.test(payload.tableName)) {
-        throw new Error(`Table name '${payload.tableName}' tidak sesuai dengan pattern yang diperlukan: ${requirements.tableNamePattern}`);
+        throw new Error(`Table name '${payload.tableName}' does not match the required pattern: ${requirements.tableNamePattern}`);
       }
     }
 
@@ -1285,7 +1712,7 @@ class PayloadValidator {
       // Check file existence
       const payloadPath = this.findPayloadFile(payloadFileName);
       if (!payloadPath) {
-        result.errors.push('File payload tidak ditemukan');
+        result.errors.push('Payload file not found');
         return result;
       }
 
@@ -1297,12 +1724,12 @@ class PayloadValidator {
       result.size = stats.size;
 
       if (result.size === 0) {
-        result.errors.push('File payload kosong');
+        result.errors.push('Payload file is empty');
         return result;
       }
 
       if (result.size > 10 * 1024 * 1024) { // 10MB limit
-        result.errors.push('File payload terlalu besar (>10MB)');
+        result.errors.push('Payload file is too large (>10MB)');
         return result;
       }
 
@@ -1312,7 +1739,7 @@ class PayloadValidator {
         JSON.parse(content);
         result.isValidJson = true;
       } catch (jsonError) {
-        result.errors.push(`Format JSON tidak valid: ${jsonError.message}`);
+        result.errors.push(`Invalid JSON format: ${jsonError.message}`);
       }
 
     } catch (error) {