@restforgejs/platform 4.2.8 → 4.3.1

package/generators/tests/baseline/oracle/mini_inventory_item/src/modules/mini-inventory.js

@@ -1,336 +0,0 @@
-const express = require('express');
-const bodyParser = require('body-parser');
-const path = require('path');
-const fs = require('fs');
-const { v4: uuidv4 } = require('uuid');
-const { logger, logServerReady, logEndpointRegistered, createRequestLogger, logRequest } = require('restforgejs/src/utils/logger');
-const ExportHandler = require('restforgejs/src/components/handlers/export_handler');
-const ImportHandler = require('restforgejs/src/components/handlers/import_handler');
-const UploadHandler = require('restforgejs/src/components/handlers/upload_handler');
-const { extractExportConfigFromEndpoint, extractImportConfigFromEndpoint, extractUploadConfigFromEndpoint } = require('restforgejs/src/utils/config-extractor');
-const rateLimiter = require('restforgejs/src/middleware/rate-limiter');
-const idempotencyMiddleware = require('restforgejs/src/middleware/idempotency');
-const bodyOptionsMiddleware = require('restforgejs/src/middleware/body-options');
-const corsMiddleware = require('restforgejs/src/middleware/cors');
-const securityHeaders = require('restforgejs/src/middleware/security-headers');
-
-/**
- * Fungsi untuk mengeksekusi modul mini-inventory (Oracle Database)
- * @param {Object} config - Konfigurasi untuk menjalankan modul
- * @param {number} config.port - Port untuk server
- * @param {string} config.key - API Key (opsional)
- * @returns {Promise<void>} Promise yang tidak pernah resolve agar server tetap berjalan
- */
-async function execute(config) {
-  return new Promise((resolve) => {
-    const app = express();
-    const port = config.port || 3000;
-    const serverAddress = config.serverAddress || '0.0.0.0';
-    const moduleNameCapitalized = 'MiniInventory';
-
-    // Configuration options
-    const loggingEnabled = config.logging !== false;
-    const apiKeyRequired = !!config.key;
-
-    logger.info({
-      event: 'module_starting',
-      module: moduleNameCapitalized,
-      port,
-      cors: process.env.CORS_ENABLED !== 'false',
-      helmet: process.env.HELMET_ENABLED === 'true',
-      logging: loggingEnabled,
-      apiKey: apiKeyRequired
-    }, `Starting ${moduleNameCapitalized} module`);
-
-    // CORS middleware (konfigurasi via CORS_ENABLED dan CORS_ORIGINS di .env)
-    app.use(corsMiddleware.middleware());
-
-    // Security headers middleware (konfigurasi via HELMET_ENABLED di .env)
-    app.use(securityHeaders.middleware());
-
-    // Middleware untuk parsing JSON dengan penanganan error
-    app.use(bodyParser.json({
-      verify: (req, res, buf, encoding) => {
-        if (buf.length === 0) {
-          return;
-        }
-        try {
-          JSON.parse(buf);
-        } catch (error) {
-          res.status(400).json({
-            success: false,
-            error: 'Invalid JSON payload',
-            message: 'The payload sent is not a valid JSON format',
-            details: error.message
-          });
-          throw new Error('Invalid JSON');
-        }
-      }
-    }));
-
-    app.use(bodyParser.urlencoded({ extended: true }));
-
-    // Request logging middleware (Pino-based)
-    app.use((req, res, next) => {
-      req.id = req.headers['x-request-id'] || uuidv4();
-      res.set('X-Request-ID', req.id);
-
-      req.log = createRequestLogger({
-        requestId: req.id,
-        method: req.method,
-        path: req.path,
-        ip: req.ip
-      });
-
-      const startTime = process.hrtime();
-
-      res.on('finish', () => {
-        const [seconds, nanoseconds] = process.hrtime(startTime);
-        const durationMs = parseFloat((seconds * 1000 + nanoseconds / 1e6).toFixed(2));
-        logRequest(req, res, durationMs);
-      });
-
-      next();
-    });
-
-    // Middleware untuk validasi API key jika diperlukan
-    if (config.key) {
-      app.use((req, res, next) => {
-        const apiKey = req.headers['x-api-key'];
-        if (!apiKey || apiKey !== config.key) {
-          return res.status(401).json({ error: 'Unauthorized: Invalid API Key' });
-        }
-        next();
-      });
-    }
-
-    // Rate limiting middleware (store: memory untuk single mode, Redis untuk cluster mode)
-    rateLimiter.setStore(config.cluster ? 'redis' : 'memory');
-    app.use('/api', rateLimiter.middleware());
-
-    // Idempotency middleware (protects mutation endpoints from duplicate execution)
-    if (process.env.IDEMPOTENCY_ENABLED === 'true') {
-      app.use('/api', idempotencyMiddleware.middleware());
-    }
-
-    // Body options middleware (extract {data, options} format dari request body)
-    app.use('/api', bodyOptionsMiddleware.middleware());
-
-    // Auto-load plugin (jika ada)
-    const moduleName = 'mini-inventory';
-    const pluginPath = path.join(__dirname, '..', 'plugins', `${moduleName}-plugin.js`);
-    let plugin = null;
-    if (fs.existsSync(pluginPath)) {
-      try {
-        plugin = require(pluginPath);
-        if (plugin.onBeforeEndpointsLoad) {
-          plugin.onBeforeEndpointsLoad(app, config);
-        }
-        logger.info({ event: 'plugin_loaded', plugin: `${moduleName}-plugin` }, `Plugin loaded: ${moduleName}-plugin.js`);
-      } catch (pluginError) {
-        logger.error({ event: 'plugin_load_error', error: pluginError.message }, `Failed to load plugin: ${moduleName}-plugin.js`);
-      }
-    }
-
-    // Health check endpoint
-    app.get('/api/mini-inventory/health', (req, res) => {
-      const healthInfo = {
-        status: 'ok',
-        timestamp: new Date().toISOString().replace('T', ' ').replace(/\.\d{3}Z$/, ''),
-        service: 'mini-inventory',
-        uptime: process.uptime(),
-        memory: process.memoryUsage(),
-        system: {
-          platform: process.platform,
-          nodeVersion: process.version,
-          pid: process.pid
-        }
-      };
-
-      res.json(healthInfo);
-    });
-
-    // Muat semua rute dari folder mini-inventory
-    const modulesDir = path.join(__dirname, 'mini-inventory');
-
-    try {
-      if (!fs.existsSync(modulesDir)) {
-        fs.mkdirSync(modulesDir, { recursive: true });
-        console.log(`Directory ${modulesDir} created successfully`);
-      }
-
-      const files = fs.readdirSync(modulesDir);
-      const endpointFiles = files.filter(file => file.endsWith('.js'));
-
-      if (endpointFiles.length === 0) {
-        console.log(`No endpoint files found in ${modulesDir}`);
-        console.log(`Add endpoint files to enable API functionality`);
-      } else {
-        logger.info({ event: 'endpoints_loading', count: endpointFiles.length }, `Loading ${endpointFiles.length} endpoint(s)`);
-      }
-
-      for (const file of endpointFiles) {
-        try {
-          const endpointName = path.basename(file, '.js');
-          const endpointPath = path.join(modulesDir, file);
-
-          // Clear module cache untuk development
-          if (require.cache[endpointPath]) {
-            delete require.cache[endpointPath];
-          }
-
-          const moduleRoutes = require(endpointPath);
-
-          const endpointPrefix = `/api/mini-inventory/${endpointName}`;
-          app.use(endpointPrefix, moduleRoutes);
-          logEndpointRegistered(endpointName, endpointPrefix);
-
-          // Register export routes via centralized handler
-          try {
-            const exportConfig = extractExportConfigFromEndpoint(endpointPath);
-            if (exportConfig) {
-              ExportHandler.registerRoutes(app, 'mini-inventory', endpointName, exportConfig);
-              logger.info({ event: 'export_routes_registered', endpoint: endpointName }, `Export routes registered for ${endpointName}`);
-            }
-          } catch (exportError) {
-            logger.error({ event: 'export_registration_error', endpoint: endpointName, error: exportError.message }, `Export registration failed for ${endpointName}: ${exportError.message}`);
-          }
-
-          // Register import routes via centralized handler
-          try {
-            const importConfig = extractImportConfigFromEndpoint(endpointPath);
-            if (importConfig) {
-              ImportHandler.registerRoutes(app, 'mini-inventory', endpointName, importConfig);
-              logger.info({ event: 'import_routes_registered', endpoint: endpointName }, `Import routes registered for ${endpointName}`);
-            }
-          } catch (importError) {
-            logger.error({ event: 'import_registration_error', endpoint: endpointName, error: importError.message }, `Import registration failed for ${endpointName}: ${importError.message}`);
-          }
-
-          // Register upload routes via centralized handler
-          try {
-            const uploadConfig = extractUploadConfigFromEndpoint(endpointPath);
-            if (uploadConfig) {
-              UploadHandler.registerRoutes(app, 'mini-inventory', endpointName, uploadConfig);
-              logger.info({ event: 'upload_routes_registered', endpoint: endpointName, fields: Object.keys(uploadConfig.fields || {}) }, `Upload routes registered for ${endpointName}`);
-            }
-          } catch (uploadError) {
-            logger.error({ event: 'upload_registration_error', endpoint: endpointName, error: uploadError.message }, `Upload registration failed for ${endpointName}: ${uploadError.message}`);
-          }
-        } catch (error) {
-          console.error(`Error loading module ${file} from mini-inventory:`, error);
-          throw error;
-        }
-      }
-
-      // Register export cleanup route
-      try {
-        ExportHandler.registerCleanupRoute(app);
-      } catch (cleanupError) {
-        console.error('Export cleanup route registration failed:', cleanupError.message);
-      }
-
-      app.get('/', (req, res) => {
-        res.json({
-          message: 'mini-inventory API (Oracle Database)',
-          status: 'running',
-          database: 'Oracle'
-        });
-      });
-
-      // Error handling middleware
-      app.use((err, req, res, next) => {
-        console.error('Error:', err);
-
-        if (err instanceof SyntaxError && err.status === 400 && 'body' in err && !res.headersSent) {
-          return res.status(400).json({
-            success: false,
-            error: 'Invalid JSON payload',
-            message: 'The payload sent is not a valid JSON format',
-            details: err.message
-          });
-        }
-
-        if (!res.headersSent) {
-          return res.status(500).json({
-            success: false,
-            error: 'Internal Server Error',
-            message: 'An error occurred on the server',
-            details: err.message
-          });
-        }
-
-        next(err);
-      });
-
-      // Hook untuk mount middleware tambahan sebelum catch-all 403
-      // Digunakan oleh runtime untuk register admin endpoint dan middleware eksternal lainnya
-      if (config.onAppReady && typeof config.onAppReady === 'function') {
-        config.onAppReady(app);
-      }
-
-      app.use((req, res) => {
-        res.status(403).json({
-          success: false,
-          error: 'Forbidden',
-          message: 'Access to the requested resource is forbidden',
-          timestamp: new Date().toISOString()
-        });
-      });
-
-      const server = app.listen(port, serverAddress, (err) => {
-        if (err) {
-          console.error(`Failed to start ${moduleNameCapitalized} server:`, err);
-          return;
-        }
-
-        console.log(`${moduleNameCapitalized} server started successfully!`);
-
-        // Determine display URL based on serverAddress
-        const displayHost = (serverAddress === '0.0.0.0' || !serverAddress) ? 'localhost' : serverAddress;
-
-        logServerReady({
-          port,
-          module: 'mini-inventory',
-          healthCheck: `http://${displayHost}:${port}/api/mini-inventory/health`,
-          serviceInfo: `http://${displayHost}:${port}/api/mini-inventory/info`,
-          baseUrl: `http://${displayHost}:${port}`
-        });
-        console.log('');
-
-        // Execute plugin onAfterServerStart hook (jika ada)
-        if (plugin && plugin.onAfterServerStart) {
-          try {
-            plugin.onAfterServerStart(app, config);
-          } catch (pluginError) {
-            logger.error({ event: 'plugin_after_start_error', error: pluginError.message }, 'Plugin onAfterServerStart failed');
-          }
-        }
-      });
-
-      process.on('SIGINT', () => {
-        console.log('Menerima sinyal SIGINT, shutting down...');
-        process.exit(0);
-      });
-
-      process.on('SIGTERM', () => {
-        console.log('Menerima sinyal SIGTERM, shutting down...');
-        process.exit(0);
-      });
-
-      process.on('uncaughtException', (error) => {
-        console.error('Uncaught Exception:', error);
-      });
-
-      process.on('unhandledRejection', (reason, promise) => {
-        console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-      });
-
-    } catch (error) {
-      console.error('Error saat menjalankan modul mini-inventory:', error);
-      resolve();
-    }
-  });
-}
-
-module.exports = { execute };