@restforgejs/platform 4.3.8 → 5.0.1

package/generators/lib/migrate/label-generator.js

@@ -1,38 +1,38 @@
-'use strict';
-
-/**
- * Port dari packages/designer/src/migrators/label_generator.rs.
- * Generator label field dari snake_case ke human-readable format.
- */
-
-const { snakeToTitle } = require('./naming');
-
-const LABEL_OVERRIDES = {
-    is_active: 'Status',
-    uom: 'UOM',
-    sku: 'SKU',
-    email: 'Email',
-    phone: 'Phone',
-    url: 'URL',
-    ip: 'IP',
-    id: 'ID'
-};
-
-function generateLabel(fieldName, isForeignKey) {
-    const name = String(fieldName || '');
-
-    if (Object.prototype.hasOwnProperty.call(LABEL_OVERRIDES, name)) {
-        return LABEL_OVERRIDES[name];
-    }
-
-    if (isForeignKey && name.endsWith('_id')) {
-        const stripped = name.slice(0, -3);
-        if (stripped.length > 0) {
-            return snakeToTitle(stripped);
-        }
-    }
-
-    return snakeToTitle(name);
-}
-
-module.exports = { generateLabel };
+'use strict';
+
+/**
+ * Port dari packages/designer/src/migrators/label_generator.rs.
+ * Generator label field dari snake_case ke human-readable format.
+ */
+
+const { snakeToTitle } = require('./naming');
+
+const LABEL_OVERRIDES = {
+    is_active: 'Status',
+    uom: 'UOM',
+    sku: 'SKU',
+    email: 'Email',
+    phone: 'Phone',
+    url: 'URL',
+    ip: 'IP',
+    id: 'ID'
+};
+
+function generateLabel(fieldName, isForeignKey) {
+    const name = String(fieldName || '');
+
+    if (Object.prototype.hasOwnProperty.call(LABEL_OVERRIDES, name)) {
+        return LABEL_OVERRIDES[name];
+    }
+
+    if (isForeignKey && name.endsWith('_id')) {
+        const stripped = name.slice(0, -3);
+        if (stripped.length > 0) {
+            return snakeToTitle(stripped);
+        }
+    }
+
+    return snakeToTitle(name);
+}
+
+module.exports = { generateLabel };

package/generators/lib/migrate/migrate-runner.js

@@ -8,10 +8,15 @@
  *  2. Baca SERVER_ADDRESS dan SERVER_PORT dari config → konstruksi apiBaseUrl
  *     dengan format `http://{host}:{port}/api/{project}`
  *  3. Load file payload backend (RDF) dari --name (relative ke cwd/payload/
- *     atau absolute)
- *  4. Jalankan migrasi RDF → UDF via BackendPayloadMigrator
- *  5. Tulis output JSON ke directory --output (file name = basename tanpa ext +
- *     suffix `-app.json`)
+ *     atau absolute) dan resolve referensi `file:` pada datatablesQuery/viewQuery
+ *  4. Discovery RDF terkait via JOIN di datatablesQuery: setiap tabel yang
+ *     di-JOIN dimuat RDF-nya dari folder yang sama lalu dikonversi menjadi page
+ *     tersendiri (1 RDF utama → multi page)
+ *  5. Jalankan migrasi RDF → UDF via BackendPayloadMigrator
+ *  6. Tulis output dalam format SPLIT multi-file:
+ *       <output>/app-config.json          → { appConfig }
+ *       <output>/pages/<pageId>.json       → { pages: [ <page> ] }
+ *       <output>/<appCode>.json            → aggregator (extends/homepage/include/navigation)
  */
 
 const fs = require('fs');
@@ -20,6 +25,8 @@ const path = require('path');
 const { resolveConfig, printDefaultConfigWarning } = require('../utils/config-resolver');
 const { readEnvFile } = require('../utils/env-manager');
 const { migrate } = require('./backend-payload-migrator');
+const { parseDatatablesQuery } = require('./sql-parser');
+const { kebabToTitle, snakeToKebab } = require('./naming');
 
 const DEFAULT_APP_NAME = 'My Application';
 const DEFAULT_APP_CODE_FALLBACK = 'my-app';
@@ -28,6 +35,8 @@ const DEFAULT_HOST = '127.0.0.1';
 const DEFAULT_BACKEND_PORT = 3000;
 const DEFAULT_FRONTEND_PORT = 8000;
 
+const QUERY_REF_FIELDS = ['datatablesQuery', 'viewQuery'];
+
 function resolveInputPath(nameArg, cwd) {
     if (path.isAbsolute(nameArg)) return nameArg;
     const direct = path.resolve(cwd, nameArg);
@@ -38,21 +47,15 @@ function resolveInputPath(nameArg, cwd) {
     return direct;
 }
 
-function buildOutputPath(outputArg, inputBaseName, cwd) {
-    const targetFileName = inputBaseName;
-
+function buildOutputDir(outputArg, cwd) {
     if (!outputArg) {
-        const defaultDir = path.resolve(cwd, 'frontend', 'payload');
-        return path.join(defaultDir, targetFileName);
+        return path.resolve(cwd, 'frontend', 'payload');
     }
-
     const abs = path.isAbsolute(outputArg) ? outputArg : path.resolve(cwd, outputArg);
-
-    // Treat as file path bila berakhiran .json (case insensitive)
-    if (/\.json$/i.test(abs)) return abs;
-
-    // Else treat as directory
-    return path.join(abs, targetFileName);
+    // Toleransi bila --output diakhiri .json: pakai direktori induknya sebagai
+    // root output split (output bukan file tunggal lagi).
+    if (/\.json$/i.test(abs)) return path.dirname(abs);
+    return abs;
 }
 
 function readServerConfig(envFilePath) {
@@ -73,6 +76,116 @@ function buildApiBaseUrl(host, port, project) {
     return `http://${host}:${port}/api${projectSegment}`;
 }
 
+/**
+ * Gabungkan aggregator `<project>.json` yang sudah ada dengan hasil run saat ini.
+ * Karena nama file aggregator = nama project, run berikutnya untuk project yang
+ * sama akan menambahkan (akumulasi) page baru, bukan menimpa.
+ *
+ * Aturan merge:
+ *  - `pages[]`        : union berdasarkan path `include` (entry existing didahulukan,
+ *                       page baru di-append). Re-migrate page yang sama = idempoten.
+ *  - `navigation.items`: union berdasarkan `pageRef` (type=page). Item existing
+ *                       dipertahankan sehingga kustomisasi manual (mis. icon/label)
+ *                       pada page lama tidak hilang.
+ *  - `homepage`       : dipertahankan dari file existing (run pertama yang menetapkan).
+ *  - `extends`        : dipertahankan.
+ */
+function mergeAggregator(existing, fresh) {
+    if (!existing || typeof existing !== 'object' || Array.isArray(existing)) {
+        return fresh;
+    }
+
+    const seenInclude = new Set();
+    const mergedPages = [];
+    const pushPages = (list) => {
+        if (!Array.isArray(list)) return;
+        for (const entry of list) {
+            const key = (entry && typeof entry.include === 'string')
+                ? entry.include
+                : JSON.stringify(entry);
+            if (seenInclude.has(key)) continue;
+            seenInclude.add(key);
+            mergedPages.push(entry);
+        }
+    };
+    pushPages(existing.pages);
+    pushPages(fresh.pages);
+
+    const seenNav = new Set();
+    const mergedNav = [];
+    const pushNav = (items) => {
+        if (!Array.isArray(items)) return;
+        for (const item of items) {
+            const key = (item && item.type === 'page' && item.pageRef)
+                ? `page:${item.pageRef}`
+                : JSON.stringify(item);
+            if (seenNav.has(key)) continue;
+            seenNav.add(key);
+            mergedNav.push(item);
+        }
+    };
+    const existingNav = (existing.navigation && Array.isArray(existing.navigation.items))
+        ? existing.navigation.items : [];
+    const freshNav = (fresh.navigation && Array.isArray(fresh.navigation.items))
+        ? fresh.navigation.items : [];
+    pushNav(existingNav);
+    pushNav(freshNav);
+
+    return {
+        extends: existing.extends || fresh.extends,
+        homepage: (typeof existing.homepage === 'string' && existing.homepage)
+            ? existing.homepage
+            : fresh.homepage,
+        pages: mergedPages,
+        navigation: { items: mergedNav }
+    };
+}
+
+/**
+ * Resolve referensi `file:` pada query fields (datatablesQuery, viewQuery)
+ * menjadi isi SQL inline. Dibaca langsung dari disk relatif terhadap lokasi
+ * file RDF, independen dari mode pkg (file SQL ada di project user, bukan
+ * di-bundle ke binary). Bila file tidak ditemukan, query di-kosongkan dan
+ * sebuah warning dikumpulkan agar parsing JOIN tidak crash.
+ */
+function resolveQueryRefs(payload, payloadPath, warnings) {
+    const dir = path.dirname(payloadPath);
+    const out = Object.assign({}, payload);
+    for (const key of QUERY_REF_FIELDS) {
+        const val = out[key];
+        if (typeof val === 'string' && val.startsWith('file:')) {
+            const rel = val.slice(5);
+            const full = path.isAbsolute(rel) ? rel : path.resolve(dir, rel);
+            if (fs.existsSync(full)) {
+                out[key] = fs.readFileSync(full, 'utf8');
+            } else {
+                out[key] = '';
+                warnings.push(`${key} reference not found: ${full} (referenced by ${path.basename(payloadPath)})`);
+            }
+        }
+    }
+    return out;
+}
+
+function loadRdf(filePath) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(content);
+}
+
+/**
+ * Petakan nama tabel JOIN (snake_case, mis. visitor_categories) ke file RDF
+ * sibling di folder payload. Coba bentuk kebab dulu (visitor-categories.json),
+ * lalu bentuk snake (visitor_categories.json).
+ */
+function findRelatedRdfPath(tableName, payloadDir) {
+    const candidates = [`${snakeToKebab(tableName)}.json`, `${tableName}.json`];
+    for (const c of candidates) {
+        const p = path.join(payloadDir, c);
+        if (fs.existsSync(p)) return { path: p, candidates };
+    }
+    return { path: null, candidates };
+}
+
 async function run(args) {
     const cwd = process.cwd();
 
@@ -110,7 +223,7 @@ async function run(args) {
         ? args.port
         : DEFAULT_FRONTEND_PORT;
 
-    const appName = args.appName || DEFAULT_APP_NAME;
+    const appName = args.appName || kebabToTitle(project) || DEFAULT_APP_NAME;
     const appCode = args.appCode || project || DEFAULT_APP_CODE_FALLBACK;
     const plugin = args.plugin || DEFAULT_PLUGIN;
 
@@ -120,26 +233,49 @@ async function run(args) {
         err.exitCode = 3;
         throw err;
     }
-    let backendPayload;
+
+    const warnings = [];
+
+    let mainPayloadRaw;
     try {
-        const content = fs.readFileSync(inputPath, 'utf8');
-        backendPayload = JSON.parse(content);
+        mainPayloadRaw = loadRdf(inputPath);
     } catch (e) {
         const err = new Error(`Failed to parse JSON from ${inputPath}: ${e.message}`);
         err.exitCode = 3;
         throw err;
     }
 
-    const inputBaseName = path.basename(inputPath);
-    const outputPath = buildOutputPath(args.output, inputBaseName, cwd);
+    // Resolve file: refs pada RDF utama agar JOIN dapat di-parse
+    const mainPayload = resolveQueryRefs(mainPayloadRaw, inputPath, warnings);
+    const mainTableClean = String(mainPayload.tableName || '').split('.').pop() || '';
 
-    if (fs.existsSync(outputPath) && !args.overwrite) {
-        const err = new Error(`Output file already exists: ${outputPath}. Use --overwrite to replace.`);
-        err.exitCode = 1;
-        throw err;
+    // Discovery tabel terkait via JOIN (1 level dari RDF utama)
+    const payloadDir = path.dirname(inputPath);
+    const parsedMain = parseDatatablesQuery(mainPayload.datatablesQuery || '');
+    const relatedPayloads = [];
+    const seenTables = new Set([mainTableClean]);
+    for (const join of parsedMain.joins) {
+        const t = String(join.tableName || '').split('.').pop() || '';
+        if (!t || seenTables.has(t)) continue;
+        seenTables.add(t);
+
+        const { path: relPath, candidates } = findRelatedRdfPath(t, payloadDir);
+        if (!relPath) {
+            warnings.push(`Related table '${t}' referenced by JOIN but no RDF file found in ${payloadDir} (tried: ${candidates.join(', ')}); page not generated, only the select reference is kept`);
+            continue;
+        }
+        try {
+            const relRaw = loadRdf(relPath);
+            relatedPayloads.push(resolveQueryRefs(relRaw, relPath, warnings));
+        } catch (e) {
+            warnings.push(`Failed to parse related RDF ${relPath}: ${e.message}`);
+        }
     }
 
-    const result = migrate([backendPayload], appName, appCode, plugin, apiBaseUrl, frontendPortArg);
+    // Urutan page: tabel terkait (master) lebih dulu, RDF utama (detail) terakhir
+    const orderedPayloads = relatedPayloads.concat([mainPayload]);
+
+    const result = migrate(orderedPayloads, appName, appCode, plugin, apiBaseUrl, frontendPortArg);
     if (!result.success) {
         const msg = (result.errors && result.errors.length > 0)
             ? result.errors.join('; ')
@@ -148,30 +284,97 @@ async function run(args) {
         err.exitCode = 1;
         throw err;
     }
+    for (const w of (result.warnings || [])) warnings.push(w);
+
+    const pages = result.payload.pages;
+    const appConfig = result.payload.appConfig;
+    // homepage = page dari RDF utama (entry terakhir karena di-append paling akhir)
+    const mainPageId = pages.length > 0 ? pages[pages.length - 1].pageId : '';
+
+    const outputDir = buildOutputDir(args.output, cwd);
 
-    const outputDir = path.dirname(outputPath);
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
+    // Susun semua file target untuk format split
+    const aggregatorPath = path.join(outputDir, `${appCode}.json`);
+
+    // File app-config + per-page: tunduk pada gate overwrite.
+    const pageTargets = [];
+    pageTargets.push({
+        path: path.join(outputDir, 'app-config.json'),
+        content: { appConfig }
+    });
+    for (const page of pages) {
+        pageTargets.push({
+            path: path.join(outputDir, 'pages', `${page.pageId}.json`),
+            content: { pages: [page] }
+        });
+    }
+
+    // Gate overwrite hanya untuk app-config + pages. Aggregator TIDAK dihitung
+    // sebagai konflik karena ia di-merge (akumulasi), bukan ditimpa.
+    if (!args.overwrite) {
+        const existing = pageTargets.filter(t => fs.existsSync(t.path)).map(t => t.path);
+        if (existing.length > 0) {
+            const err = new Error(`Output file(s) already exist:\n  ${existing.join('\n  ')}\nUse --overwrite to replace.`);
+            err.exitCode = 1;
+            throw err;
+        }
+    }
+
+    // Aggregator: gabungkan dengan file existing bila project sama (nama file sama)
+    const freshAggregator = {
+        extends: 'app-config.json',
+        homepage: mainPageId,
+        pages: pages.map(p => ({ include: `pages/${p.pageId}.json` })),
+        navigation: {
+            items: pages.map(p => ({ type: 'page', pageRef: p.pageId, label: p.pageTitle }))
+        }
+    };
+    let aggregatorMerged = false;
+    let aggregatorContent = freshAggregator;
+    if (fs.existsSync(aggregatorPath)) {
+        try {
+            const existingAgg = JSON.parse(fs.readFileSync(aggregatorPath, 'utf8'));
+            aggregatorContent = mergeAggregator(existingAgg, freshAggregator);
+            aggregatorMerged = true;
+        } catch (e) {
+            warnings.push(`Existing aggregator ${path.basename(aggregatorPath)} could not be parsed (${e.message}); it will be replaced`);
+        }
+    }
+
+    const targets = pageTargets.concat([{ path: aggregatorPath, content: aggregatorContent }]);
+    for (const t of targets) {
+        const dir = path.dirname(t.path);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(t.path, JSON.stringify(t.content, null, 2), 'utf8');
     }
-    fs.writeFileSync(outputPath, JSON.stringify(result.payload, null, 2), 'utf8');
 
     const stdout = process.stdout;
     stdout.write('============================================================\n');
-    stdout.write('PAYLOAD MIGRATE - RDF (backend) -> UDF (frontend)\n');
+    stdout.write('PAYLOAD MIGRATE - RDF (backend) -> UDF (frontend, split)\n');
     stdout.write('============================================================\n\n');
     stdout.write(`  Input        : ${inputPath}\n`);
-    stdout.write(`  Output       : ${outputPath}\n`);
+    stdout.write(`  Output dir   : ${outputDir}\n`);
     stdout.write(`  Project      : ${project}\n`);
     stdout.write(`  apiBaseUrl   : ${apiBaseUrl}\n`);
     stdout.write(`  Backend port : ${backendPort}\n`);
     stdout.write(`  Frontend port: ${frontendPortArg}\n`);
-    stdout.write(`  Pages        : ${result.pageResults.length}\n\n`);
+    stdout.write(`  Homepage     : ${aggregatorContent.homepage}\n`);
+    stdout.write(`  Pages (run)  : ${result.pageResults.length}\n`);
+    stdout.write(`  Pages (app)  : ${aggregatorContent.pages.length}${aggregatorMerged ? ' (merged with existing)' : ''}\n\n`);
     for (const pr of result.pageResults) {
         stdout.write(`  [OK] ${pr.pageId}: ${pr.fieldCount} field(s), ${pr.tableColCount} table column(s)\n`);
     }
-    if (result.warnings && result.warnings.length > 0) {
+    stdout.write('\n  Files written:\n');
+    for (const t of targets) {
+        const rel = path.relative(outputDir, t.path) || path.basename(t.path);
+        const tag = (t.path === aggregatorPath && aggregatorMerged) ? '  (merged)' : '';
+        stdout.write(`    - ${rel}${tag}\n`);
+    }
+    if (warnings.length > 0) {
         stdout.write('\n  Warnings:\n');
-        for (const w of result.warnings) {
+        for (const w of warnings) {
             stdout.write(`    - ${w}\n`);
         }
     }
@@ -181,7 +384,10 @@ async function run(args) {
 module.exports = {
     run,
     resolveInputPath,
-    buildOutputPath,
+    buildOutputDir,
+    resolveQueryRefs,
+    findRelatedRdfPath,
     readServerConfig,
-    buildApiBaseUrl
+    buildApiBaseUrl,
+    mergeAggregator
 };

package/generators/lib/migrate/naming.js

@@ -1,43 +1,52 @@
-'use strict';
-
-/**
- * Port dari packages/designer/src/utils/naming.rs.
- * Konversi naming convention: snake_case -> kebab-case / camelCase / PascalCase / Title Case.
- */
-
-function capitalize(s) {
-    if (!s || s.length === 0) return '';
-    return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
-}
-
-function snakeToKebab(name) {
-    return String(name || '').replace(/_/g, '-');
-}
-
-function snakeToCamel(name) {
-    const parts = String(name || '').split('_');
-    if (parts.length === 0) return '';
-    const first = parts.shift();
-    return first + parts.map(capitalize).join('');
-}
-
-function snakeToPascal(name) {
-    return String(name || '').split('_').map(capitalize).join('');
-}
-
-function snakeToTitle(name) {
-    return String(name || '').split('_').map(capitalize).join(' ');
-}
-
-function toClassName(appCode) {
-    return String(appCode || '').replace(/_/g, '-').split('-').map(capitalize).join('');
-}
-
-module.exports = {
-    capitalize,
-    snakeToKebab,
-    snakeToCamel,
-    snakeToPascal,
-    snakeToTitle,
-    toClassName
-};
+'use strict';
+
+/**
+ * Port dari packages/designer/src/utils/naming.rs.
+ * Konversi naming convention: snake_case -> kebab-case / camelCase / PascalCase / Title Case.
+ */
+
+function capitalize(s) {
+    if (!s || s.length === 0) return '';
+    return s.charAt(0).toUpperCase() + s.slice(1).toLowerCase();
+}
+
+function snakeToKebab(name) {
+    return String(name || '').replace(/_/g, '-');
+}
+
+function snakeToCamel(name) {
+    const parts = String(name || '').split('_');
+    if (parts.length === 0) return '';
+    const first = parts.shift();
+    return first + parts.map(capitalize).join('');
+}
+
+function snakeToPascal(name) {
+    return String(name || '').split('_').map(capitalize).join('');
+}
+
+function snakeToTitle(name) {
+    return String(name || '').split('_').map(capitalize).join(' ');
+}
+
+function kebabToTitle(name) {
+    return String(name || '')
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map(capitalize)
+        .join(' ');
+}
+
+function toClassName(appCode) {
+    return String(appCode || '').replace(/_/g, '-').split('-').map(capitalize).join('');
+}
+
+module.exports = {
+    capitalize,
+    snakeToKebab,
+    snakeToCamel,
+    snakeToPascal,
+    snakeToTitle,
+    kebabToTitle,
+    toClassName
+};