@restforgejs/platform 5.2.16 → 5.3.5

package/generators/lib/sdk/generator.js

@@ -0,0 +1,719 @@
+'use strict';
+
+/**
+ * Generator SDK JavaScript untuk satu project RESTForge.
+ *
+ * Rujukan desain: docs/plan/sdk-generator-command.md (versi awal, TANPA auth).
+ *
+ * Sumber kebenaran tunggal = `metadata/<project>.json`:
+ * - key endpoint  -> slug (= segment route nyata `/api/<project>/<slug>/<verb>`)
+ * - `actions`     -> action map untuk generic verb builder (core/resource-client.js)
+ * - `type: module`-> hanya endpoint REST yang digenerate (processor/dashboard/consumer dilewati)
+ *
+ * `primaryKey` tidak ada di metadata, jadi diambil dari file payload
+ * `payload/<slug>.json`. Bila payload tidak ditemukan, SELURUH generate dibatalkan
+ * (tidak ada SDK parsial) — sesuai keputusan desain.
+ *
+ * Core generik (http-client.js, resource-client.js) identik antar project, jadi
+ * cukup disalin dari ./runtime/ tanpa template per-project.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { toCamel, toPascal, toKebab } = require('./naming');
+const { resolveConfig } = require('../utils/config-resolver');
+const { readEnvFile } = require('../utils/env-manager');
+
+const RUNTIME_DIR = path.resolve(__dirname, 'runtime');
+const RUNTIME_FILES = ['http-client.js', 'resource-client.js'];
+// Core tambahan, disalin HANYA bila project punya auth extension (project auth).
+const AUTH_RUNTIME_FILES = ['auth-client.js', 'storage.js'];
+
+/**
+ * Error generate dengan exit code eksplisit untuk dipakai cli-entry.js.
+ */
+function generateError(message, exitCode = 1) {
+    const err = new Error(message);
+    err.exitCode = exitCode;
+    return err;
+}
+
+/**
+ * Tentukan lokasi metadata + payload. Mendukung dua layout:
+ * - flat (fast-track): metadata/payload langsung di root (cwd)
+ * - split: backend ada di `<cwd>/backend/`, metadata/payload di sana
+ *
+ * Output SDK default selalu sibling root-level (`<cwd>/sdk`), bukan di dalam backend/.
+ */
+function resolveLayout(workingDir, project) {
+    const candidates = [
+        { baseDir: workingDir, label: 'flat' },
+        { baseDir: path.join(workingDir, 'backend'), label: 'split' }
+    ];
+
+    for (const candidate of candidates) {
+        const metadataPath = path.join(candidate.baseDir, 'metadata', `${project}.json`);
+        if (fs.existsSync(metadataPath)) {
+            return {
+                layout: candidate.label,
+                baseDir: candidate.baseDir,
+                metadataPath,
+                payloadDir: path.join(candidate.baseDir, 'payload')
+            };
+        }
+    }
+
+    throw generateError(
+        `Metadata for project '${project}' not found. Looked in:\n` +
+        candidates.map((c) => `  - ${path.join(c.baseDir, 'metadata', `${project}.json`)}`).join('\n') +
+        `\nMake sure the project has been generated (endpoint create / fast-track) before creating an SDK.`,
+        1
+    );
+}
+
+/**
+ * Baca metadata, kembalikan daftar endpoint REST (type module) beserta action map
+ * yang sudah difilter hanya yang aktif (true).
+ */
+function readModuleEndpoints(metadataPath) {
+    let metadata;
+    try {
+        metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+    } catch (err) {
+        throw generateError(`Failed to read metadata ${metadataPath}: ${err.message}`, 1);
+    }
+
+    const endpoints = metadata && metadata.endpoints;
+    if (!endpoints || typeof endpoints !== 'object') {
+        throw generateError(`Metadata ${metadataPath} has no 'endpoints' field.`, 1);
+    }
+
+    const result = [];
+    for (const [slug, info] of Object.entries(endpoints)) {
+        if (!info || info.type !== 'module') continue;
+        if (!info.actions || typeof info.actions !== 'object') continue;
+
+        const activeAction = {};
+        for (const [verb, enabled] of Object.entries(info.actions)) {
+            if (enabled === true) activeAction[verb] = true;
+        }
+
+        result.push({
+            slug,
+            tableName: info.tableName || null,
+            action: activeAction
+        });
+    }
+
+    return result;
+}
+
+/**
+ * Cari file payload untuk sebuah resource. Konvensi utama: `payload/<slug>.json`.
+ * Fallback ke nama berbasis tableName untuk berjaga-jaga.
+ */
+function resolvePayloadFile(payloadDir, slug, tableName) {
+    const candidates = [`${slug}.json`];
+    if (tableName) {
+        candidates.push(`${tableName}.json`);
+        candidates.push(`${toKebab(tableName)}.json`);
+    }
+
+    for (const name of candidates) {
+        const full = path.join(payloadDir, name);
+        if (fs.existsSync(full)) return full;
+    }
+    return null;
+}
+
+/**
+ * Baca metadata payload yang dibutuhkan SDK: primaryKey + daftar field
+ * (dari fieldValidation). Abort bila payload/primaryKey tidak ada.
+ *
+ * @returns {{ primaryKey: string, fields: Array<{name,type,required,autoGenerate,primaryKey,enum,default,maxLength}> }}
+ */
+function readPayloadMeta(payloadDir, endpoint) {
+    const payloadFile = resolvePayloadFile(payloadDir, endpoint.slug, endpoint.tableName);
+    if (!payloadFile) {
+        throw generateError(
+            `Payload for resource '${endpoint.slug}' not found in ${payloadDir} ` +
+            `(looked for ${endpoint.slug}.json` + (endpoint.tableName ? `, ${endpoint.tableName}.json` : '') + `). ` +
+            `Generation aborted to avoid producing a partial SDK.`,
+            1
+        );
+    }
+
+    let payload;
+    try {
+        payload = JSON.parse(fs.readFileSync(payloadFile, 'utf8'));
+    } catch (err) {
+        throw generateError(`Failed to read payload ${payloadFile}: ${err.message}`, 1);
+    }
+
+    if (!payload.primaryKey || typeof payload.primaryKey !== 'string') {
+        throw generateError(
+            `Payload ${payloadFile} has no valid 'primaryKey' field. Generation aborted.`,
+            1
+        );
+    }
+
+    const fields = Array.isArray(payload.fieldValidation)
+        ? payload.fieldValidation.map((f) => {
+            const c = (f && f.constraints) || {};
+            return {
+                name: f.name,
+                type: f.type || 'string',
+                required: c.required === true,
+                autoGenerate: c.autoGenerate === true,
+                primaryKey: c.primaryKey === true,
+                enum: Array.isArray(c.enum) ? c.enum : null,
+                default: Object.prototype.hasOwnProperty.call(c, 'default') ? c.default : undefined,
+                maxLength: typeof c.maxLength === 'number' ? c.maxLength : null
+            };
+        }).filter((f) => f.name)
+        : [];
+
+    return { primaryKey: payload.primaryKey, fields };
+}
+
+/**
+ * Wrapper kompatibilitas: hanya primaryKey.
+ */
+function readPrimaryKey(payloadDir, endpoint) {
+    return readPayloadMeta(payloadDir, endpoint).primaryKey;
+}
+
+function renderActionLiteral(action) {
+    const keys = Object.keys(action);
+    if (keys.length === 0) return '{}';
+    const lines = keys.map((key) => `            ${key}: true`);
+    return '{\n' + lines.join(',\n') + '\n        }';
+}
+
+function renderResourceFile(resource) {
+    const factory = `create${toPascal(resource.slug)}Resource`;
+    return `// Auto-generated dari payload ${resource.slug}.json oleh \`restforge project sdk\` — JANGAN diedit manual.
+// Descriptor (primaryKey, action) disalin dari payload RDF backend; slug = nama endpoint terdeploy.
+
+import { createResource } from '../core/resource-client.js';
+
+export function ${factory}(http) {
+    return createResource(http, {
+        slug: '${resource.slug}',
+        primaryKey: '${resource.primaryKey}',
+        action: ${renderActionLiteral(resource.action)}
+    });
+}
+`;
+}
+
+function renderIndexFile(project, resources, hasAuth) {
+    const firstKey = resources.length > 0 ? resources[0].clientKey : 'resource';
+    const imports = resources
+        .map((r) => `import { ${r.factory} } from './resources/${r.slug}.js';`)
+        .join('\n');
+    const assignments = resources
+        .map((r) => `        ${r.clientKey}: ${r.factory}(http)`)
+        .join(',\n');
+
+    if (!hasAuth) {
+        return `// Entrypoint tunggal SDK ${project}. Auto-generated oleh \`restforge project sdk\` — JANGAN diedit manual.
+//
+// Project ini TANPA auth extension: createClient hanya butuh baseUrl.
+//
+// Pemakaian:
+//   import { createClient } from '${project}';
+//   const client = createClient({ baseUrl: 'http://127.0.0.1:3000/api/${project}' });
+//   const result = await client.${firstKey}.datatables({ start: 0, length: 10 });
+
+import { HttpClient } from './core/http-client.js';
+
+${imports}
+
+export function createClient({ baseUrl } = {}) {
+    if (!baseUrl) throw new Error('createClient: baseUrl wajib diisi');
+
+    const http = new HttpClient({ baseUrl });
+
+    const client = {
+${assignments}
+    };
+
+    return client;
+}
+
+export { ApiError } from './core/http-client.js';
+`;
+    }
+
+    return `// Entrypoint tunggal SDK ${project}. Auto-generated oleh \`restforge project sdk\` — JANGAN diedit manual.
+//
+// Project ini PUNYA auth extension (project auth). Endpoint auth di-mount di {baseUrl}/rfx_auth/*.
+// client.auth menyediakan login/logout/refresh/getMe; token otomatis dilampirkan ke setiap
+// pemanggilan resource (Bearer) dan di-refresh saat 401.
+//
+// Pemakaian:
+//   import { createClient } from '${project}';
+//   const client = createClient({ baseUrl: 'http://127.0.0.1:3000/api/${project}' });
+//   await client.auth.login('username', 'password');
+//   const result = await client.${firstKey}.datatables({ start: 0, length: 10 });
+
+import { HttpClient } from './core/http-client.js';
+import { createAuthClient } from './core/auth-client.js';
+import { createLocalStorageAdapter } from './core/storage.js';
+
+${imports}
+
+export function createClient({ baseUrl, storage } = {}) {
+    if (!baseUrl) throw new Error('createClient: baseUrl wajib diisi');
+
+    const resolvedStorage = storage || createLocalStorageAdapter();
+    const auth = createAuthClient({ baseUrl: baseUrl + '/rfx_auth', storage: resolvedStorage });
+
+    const http = new HttpClient({
+        baseUrl,
+        getAccessToken: () => auth.getAccessToken(),
+        refreshAccessToken: () => auth.refresh(),
+        onSessionExpired: () => auth.logout()
+    });
+
+    const client = {
+${assignments}
+    };
+
+    client.auth = auth;
+
+    return client;
+}
+
+export { ApiError } from './core/http-client.js';
+export { createLocalStorageAdapter, createMemoryStorageAdapter } from './core/storage.js';
+`;
+}
+
+function renderPackageJson(project) {
+    const pkg = {
+        name: project,
+        version: '0.1.0',
+        description: `SDK client untuk REST API ${project} (RESTForge).`,
+        type: 'module',
+        main: 'dist/index.cjs',
+        module: 'dist/index.js',
+        browser: 'dist/index.global.js',
+        exports: {
+            '.': {
+                import: './dist/index.js',
+                require: './dist/index.cjs'
+            }
+        },
+        files: ['dist/'],
+        scripts: {
+            build: 'tsup',
+            deploy: 'node deploy.mjs'
+        },
+        devDependencies: {
+            // tsup melakukan require('typescript') saat startup (bukan hanya untuk .d.ts),
+            // jadi typescript wajib ada walau source SDK murni JavaScript.
+            tsup: '^8.0.0',
+            typescript: '^6.0.3'
+        }
+    };
+    return JSON.stringify(pkg, null, 4) + '\n';
+}
+
+/**
+ * Tentukan baseUrl REST API untuk di-bake ke sdk-client.js.
+ * Prioritas: override eksplisit -> default config (.restforge/defaults.json -> env) -> fallback.
+ * SERVER_ADDRESS 0.0.0.0/kosong dipetakan ke 127.0.0.1 (tidak bisa dipakai browser).
+ */
+function resolveBaseUrl({ workingDir, project, override = null, log = () => {} }) {
+    const fallback = `http://127.0.0.1:3000/api/${project}`;
+    if (override) return override;
+
+    try {
+        const resolved = resolveConfig(null, workingDir);
+        if (resolved && fs.existsSync(resolved.path)) {
+            const { data } = readEnvFile(resolved.path);
+            let host = (data.SERVER_ADDRESS || '').trim();
+            if (!host || host === '0.0.0.0') host = '127.0.0.1';
+            const port = (data.SERVER_PORT || '3000').trim();
+            return `http://${host}:${port}/api/${project}`;
+        }
+    } catch (_e) {
+        // fall through ke fallback
+    }
+
+    log(`Default config not found — baseUrl falls back to ${fallback}`);
+    return fallback;
+}
+
+function renderBootstrapClient(project, baseUrl, hasAuth) {
+    const globalVar = toCamel(project);
+    const authNote = hasAuth
+        ? `// Auth extension detected: window.${globalVar}.auth is available (login/logout/refresh).`
+        : `// Generated WITHOUT auth: window.${globalVar}.auth does not exist.`;
+    return `// Bootstrap for the ${project} SDK — auto-generated by \`restforge project sdk\`.
+// Load this as <script type="module"> BEFORE other classic scripts.
+${authNote}
+//
+// After deploy this file lives in <app>/js/ and the SDK in <app>/js/sdk/.
+import { createClient } from './sdk/index.js';
+
+window.${globalVar} = createClient({ baseUrl: '${baseUrl}' });
+
+document.dispatchEvent(new Event('${project}:ready'));
+`;
+}
+
+function renderDeployScript(project) {
+    const template = fs.readFileSync(path.join(RUNTIME_DIR, 'deploy.mjs.tmpl'), 'utf8');
+    return template
+        .replace(/__PROJECT_GLOBAL__/g, toCamel(project))
+        .replace(/__PROJECT__/g, project);
+}
+
+/**
+ * Daftar nama method client untuk sebuah action map, MENGIKUTI pemetaan
+ * core/resource-client.js: workflow -> changeStatus, export/import dilewati,
+ * dan lookup aktif menambah lookupDynamic. Dipakai kolom Methods di README.
+ */
+function resourceMethods(action = {}) {
+    const SKIP = new Set(['export', 'import']);
+    const OVERRIDE = { workflow: 'changeStatus' };
+    const methods = [];
+    for (const [verb, enabled] of Object.entries(action)) {
+        if (!enabled || SKIP.has(verb)) continue;
+        methods.push(OVERRIDE[verb] || verb);
+    }
+    if (action.lookup) methods.push('lookupDynamic');
+    return methods;
+}
+
+/**
+ * Catatan ringkas constraint sebuah field untuk kolom Notes di tabel Fields.
+ */
+function fieldNote(field) {
+    const notes = [];
+    if (field.primaryKey) notes.push('primary key');
+    if (field.autoGenerate) notes.push('auto-generated');
+    if (field.enum) notes.push(`enum: ${field.enum.join(', ')}`);
+    if (field.maxLength) notes.push(`max ${field.maxLength}`);
+    if (field.default !== undefined) notes.push(`default: ${field.default}`);
+    return notes.join('; ');
+}
+
+// Kolom audit diisi runtime, tidak dikirim user.
+const AUDIT_COLUMNS = new Set(['created_at', 'created_by', 'updated_at', 'updated_by']);
+
+/**
+ * Field yang relevan dikirim user saat create. Mengikuti prototype: yang dikecualikan
+ * hanya primary key auto-generated dan kolom audit. Field autoGenerate non-PK (mis.
+ * tanggal default) TETAP boleh dikirim, jadi ikut ditampilkan.
+ */
+function writableFields(fields) {
+    return fields.filter((f) => {
+        if (f.primaryKey && f.autoGenerate) return false;
+        if (AUDIT_COLUMNS.has(f.name)) return false;
+        return true;
+    });
+}
+
+/**
+ * Nilai contoh placeholder per field (berdasar tipe / enum).
+ */
+function exampleValue(field) {
+    if (field.enum && field.enum.length > 0) return `'${field.enum[0]}'`;
+    switch (field.type) {
+        case 'integer':
+        case 'number':
+        case 'decimal':
+        case 'float':
+            return '0';
+        case 'boolean':
+            return 'true';
+        case 'date':
+        case 'datetime':
+        case 'timestamp':
+            return "'2026-01-01 00:00'";
+        default:
+            return "'text'";
+    }
+}
+
+/**
+ * Object literal contoh untuk pemanggilan create resource pertama.
+ */
+function createExampleBody(fields) {
+    const writable = writableFields(fields);
+    if (writable.length === 0) return '{ /* fields */ }';
+    const lines = writable.map((f) => `    ${f.name}: ${exampleValue(f)}`);
+    return '{\n' + lines.join(',\n') + '\n}';
+}
+
+/**
+ * Section "Fields per Resource": satu sub-tabel per resource dari fieldValidation.
+ */
+function renderFieldsSection(resources) {
+    return resources.map((r) => {
+        const heading = `### \`${r.slug}\` (\`client.${r.clientKey}\`)`;
+        if (!r.fields || r.fields.length === 0) {
+            return `${heading}\n\n_Field tidak dideklarasikan di payload._`;
+        }
+        const rows = r.fields.map((f) => {
+            const note = fieldNote(f);
+            return `| \`${f.name}\` | ${f.type} | ${f.required ? 'yes' : 'no'} | ${note} |`;
+        }).join('\n');
+        return `${heading}\n\n| Field | Type | Required | Notes |\n|-------|------|----------|-------|\n${rows}`;
+    }).join('\n\n');
+}
+
+function renderAuthOverview(hasAuth) {
+    return hasAuth
+        ? 'enabled via `client.auth` (tokens attached automatically, refreshed on 401).'
+        : 'not included (project has no auth extension); `createClient` only accepts `baseUrl`.';
+}
+
+function renderAuthSection(project, hasAuth) {
+    if (!hasAuth) return '';
+    const g = toCamel(project);
+    return `## Authentication
+
+This project has the auth extension (\`project auth\`). The client exposes \`client.auth\`, and
+every resource call automatically attaches \`Authorization: Bearer <token>\` and retries once
+after refreshing on a 401. Auth endpoints are mounted under \`<baseUrl>/rfx_auth\`.
+
+\`\`\`js
+// log in (tokens stored via the storage adapter; localStorage by default)
+await window.${g}.auth.login('username', 'password');
+
+// or sign in with Google (pass the ID token from Google Identity Services)
+// await window.${g}.auth.google(googleIdToken);
+
+// authenticated resource calls just work afterwards
+// ...getResource().datatables(...)
+
+// session helpers
+window.${g}.auth.isAuthenticated();   // boolean
+window.${g}.auth.getCurrentUser();    // cached user (or null)
+await window.${g}.auth.getMe();       // fetch fresh profile
+
+// log out (clears local tokens, invalidates refresh token on server)
+window.${g}.auth.logout();
+\`\`\`
+
+### Auth methods
+
+| Method | Endpoint |
+|--------|----------|
+| \`auth.login(username, password)\` | \`POST /rfx_auth/login\` |
+| \`auth.google(credential)\` | \`POST /rfx_auth/google\` (Google ID token) |
+| \`auth.register({ username, password, email?, full_name? })\` | \`POST /rfx_auth/register\` |
+| \`auth.refresh()\` | \`POST /rfx_auth/refresh\` (auto on 401) |
+| \`auth.logout()\` | \`POST /rfx_auth/logout\` |
+| \`auth.getMe()\` | \`GET /rfx_auth/me\` |
+| \`auth.resetPassword({ email, new_password, confirm_password })\` | \`POST /rfx_auth/reset-password\` |
+| \`auth.getAccessToken()\` / \`getRefreshToken()\` / \`getCurrentUser()\` / \`isAuthenticated()\` | local accessors |
+
+Tokens are stored under \`auth_access_token\`, \`auth_refresh_token\`, \`auth_user\`. For SSR or
+non-browser environments, pass a custom \`storage\` adapter:
+\`createClient({ baseUrl, storage })\` (see \`createMemoryStorageAdapter\`).
+
+`;
+}
+
+function renderReadme(project, resources, baseUrl, hasAuth) {
+    const template = fs.readFileSync(path.join(RUNTIME_DIR, 'README.md.tmpl'), 'utf8');
+    const first = resources[0];
+    const tableRows = resources
+        .map((r) => {
+            const methods = resourceMethods(r.action).join(', ') || '—';
+            return `| \`${r.slug}\` | \`client.${r.clientKey}\` | \`${r.primaryKey}\` | ${methods} |`;
+        })
+        .join('\n');
+    const treeLines = resources
+        .map((r, i) => `    │   ${i === resources.length - 1 ? '└──' : '├──'} ${r.slug}.js`)
+        .join('\n');
+    const coreFiles = hasAuth
+        ? ['http-client.js', 'resource-client.js', 'auth-client.js', 'storage.js']
+        : ['http-client.js', 'resource-client.js'];
+    const coreTree = coreFiles
+        .map((f, i) => `    │   ${i === coreFiles.length - 1 ? '└──' : '├──'} ${f}`)
+        .join('\n');
+
+    return template
+        .replace(/__RESOURCE_TABLE__/g, tableRows)
+        .replace(/__RESOURCE_TREE__/g, treeLines)
+        .replace(/__CORE_TREE__/g, coreTree)
+        .replace(/__RESOURCE_FIELDS__/g, renderFieldsSection(resources))
+        .replace(/__FIRST_CREATE_BODY__/g, createExampleBody(first.fields || []))
+        .replace(/__AUTH_OVERVIEW__/g, renderAuthOverview(hasAuth))
+        .replace(/__AUTH_SECTION__/g, renderAuthSection(project, hasAuth))
+        .replace(/__GLOBAL__/g, toCamel(project))
+        .replace(/__BASEURL__/g, baseUrl)
+        .replace(/__FIRST_KEY__/g, first.clientKey)
+        .replace(/__FIRST_PK__/g, first.primaryKey)
+        .replace(/__PROJECT__/g, project);
+}
+
+function renderTsupConfig(project) {
+    const globalName = toPascal(project);
+    return `import { defineConfig } from 'tsup';
+
+// Entry utama: 3 format sekaligus (ESM untuk bundler modern, CJS untuk Node/SSR,
+// IIFE/global untuk <script> classic biasa — window.${globalName}).
+export default defineConfig([
+    {
+        entry: { index: 'src/index.js' },
+        format: ['esm', 'cjs', 'iife'],
+        globalName: '${globalName}',
+        outDir: 'dist',
+        clean: true,
+        sourcemap: false,
+        minify: false
+    }
+]);
+`;
+}
+
+function copyRuntime(coreDir, hasAuth) {
+    const files = hasAuth ? RUNTIME_FILES.concat(AUTH_RUNTIME_FILES) : RUNTIME_FILES;
+    for (const file of files) {
+        const src = path.join(RUNTIME_DIR, file);
+        const dest = path.join(coreDir, file);
+        fs.copyFileSync(src, dest);
+    }
+}
+
+/**
+ * Deteksi apakah project sudah punya auth extension (project auth).
+ * Sinyal paling deterministik: file router rfx_auth + folder processor auth di src/modules/<project>/.
+ */
+function detectAuth(baseDir, project) {
+    const moduleDir = path.join(baseDir, 'src', 'modules', project);
+    const routerFile = path.join(moduleDir, 'rfx_auth.js');
+    const processorDir = path.join(moduleDir, 'processor', 'auth');
+    return fs.existsSync(routerFile) || fs.existsSync(processorDir);
+}
+
+/**
+ * Generate SDK source ke `outputDir`.
+ *
+ * @param {object} options
+ * @param {string} options.workingDir - root tempat command dijalankan (umumnya process.cwd())
+ * @param {string} options.project    - nama project (= nama package SDK)
+ * @param {string} [options.sdkPath]  - override folder output (relatif ke workingDir atau absolut)
+ * @param {boolean} [options.force]   - timpa SDK source yang sudah ada
+ * @param {function} [options.log]    - sink log (default console.log)
+ * @returns {{ outputDir: string, layout: string, resources: string[] }}
+ */
+function generateSdk(options = {}) {
+    const {
+        workingDir,
+        project,
+        sdkPath = null,
+        force = false,
+        log = console.log
+    } = options;
+
+    if (!workingDir) throw generateError('generateSdk: workingDir is required', 1);
+    if (!project) throw generateError('generateSdk: project is required', 1);
+
+    const baseUrl = options.baseUrl || `http://127.0.0.1:3000/api/${project}`;
+
+    const { layout, baseDir, metadataPath, payloadDir } = resolveLayout(workingDir, project);
+    log(`Detected layout : ${layout}`);
+    log(`Metadata        : ${metadataPath}`);
+
+    const hasAuth = detectAuth(baseDir, project);
+    log(`Auth extension  : ${hasAuth ? 'detected (rfx_auth) — SDK includes client.auth' : 'none'}`);
+
+    const endpoints = readModuleEndpoints(metadataPath);
+    if (endpoints.length === 0) {
+        throw generateError(
+            `No REST endpoints (type module) in metadata for project '${project}'. Nothing to generate.`,
+            1
+        );
+    }
+
+    // Lengkapi tiap endpoint dengan primaryKey + field + nama turunan (abort bila payload hilang).
+    const resources = endpoints.map((endpoint) => {
+        const { primaryKey, fields } = readPayloadMeta(payloadDir, endpoint);
+        return {
+            slug: endpoint.slug,
+            primaryKey,
+            fields,
+            action: endpoint.action,
+            clientKey: toCamel(endpoint.slug),
+            factory: `create${toPascal(endpoint.slug)}Resource`
+        };
+    });
+
+    const outputDir = sdkPath
+        ? path.resolve(workingDir, sdkPath)
+        : path.join(workingDir, 'sdk');
+
+    const indexMarker = path.join(outputDir, 'src', 'index.js');
+    if (fs.existsSync(indexMarker) && !force) {
+        throw generateError(
+            `An SDK already exists at ${outputDir} (found src/index.js). Use --force to overwrite.`,
+            1
+        );
+    }
+
+    const srcDir = path.join(outputDir, 'src');
+    const coreDir = path.join(srcDir, 'core');
+    const resourcesDir = path.join(srcDir, 'resources');
+
+    fs.mkdirSync(coreDir, { recursive: true });
+    fs.mkdirSync(resourcesDir, { recursive: true });
+
+    // Core generik (identik antar project) — salin dari runtime (+ auth bila terdeteksi).
+    copyRuntime(coreDir, hasAuth);
+    log(`Core copied     : ${(hasAuth ? RUNTIME_FILES.concat(AUTH_RUNTIME_FILES) : RUNTIME_FILES).join(', ')}`);
+
+    // Resource per endpoint.
+    for (const resource of resources) {
+        const file = path.join(resourcesDir, `${resource.slug}.js`);
+        fs.writeFileSync(file, renderResourceFile(resource), 'utf8');
+        log(`Resource        : ${resource.slug} (primaryKey=${resource.primaryKey})`);
+    }
+
+    // Entrypoint + build config.
+    fs.writeFileSync(path.join(srcDir, 'index.js'), renderIndexFile(project, resources, hasAuth), 'utf8');
+    fs.writeFileSync(path.join(outputDir, 'package.json'), renderPackageJson(project), 'utf8');
+    fs.writeFileSync(path.join(outputDir, 'tsup.config.js'), renderTsupConfig(project), 'utf8');
+    fs.writeFileSync(path.join(outputDir, 'deploy.mjs'), renderDeployScript(project), 'utf8');
+    fs.writeFileSync(path.join(outputDir, 'sdk-client.js'), renderBootstrapClient(project, baseUrl, hasAuth), 'utf8');
+    log(`Bootstrap       : sdk-client.js (baseUrl=${baseUrl})`);
+    fs.writeFileSync(path.join(outputDir, 'README.md'), renderReadme(project, resources, baseUrl, hasAuth), 'utf8');
+    log(`Readme          : README.md`);
+
+    return {
+        outputDir,
+        layout,
+        baseUrl,
+        hasAuth,
+        resources: resources.map((r) => r.slug)
+    };
+}
+
+module.exports = {
+    generateSdk,
+    resolveLayout,
+    readModuleEndpoints,
+    resolvePayloadFile,
+    readPrimaryKey,
+    readPayloadMeta,
+    detectAuth,
+    renderResourceFile,
+    renderIndexFile,
+    renderPackageJson,
+    renderTsupConfig,
+    renderDeployScript,
+    renderBootstrapClient,
+    renderReadme,
+    resourceMethods,
+    resolveBaseUrl,
+    generateError
+};