@ecopex/ecopex-framework 1.0.0

package/utils/middleware.js

@@ -0,0 +1,154 @@
+const i18n = require('./i18n');
+const db = require('@root/libraries/knex');
+/**
+ * Middleware utilities for Fastify
+ */
+class Middleware {
+  /**
+   * Language detection middleware
+   * Adds detected language to request object
+   */
+  static languageDetection() {
+    return async (request, reply) => {
+      // Detect language from request
+      const locale = i18n.detectLanguage(request);
+      
+      // Add locale to request object
+      request.locale = locale;
+      request.t = (key, params = {}) => i18n.t(key, locale, params);
+
+      const language = await db('languages').where('code', locale).first();
+      
+      request.language = language ? language.language_id : 1;
+      
+      // Add locale to reply headers
+      reply.header('Content-Language', locale);
+    };
+  }
+
+  /**
+   * Error handler middleware with custom response format
+   */
+  static errorHandler(error, request, reply) {
+
+      if(process.env.NODE_ENV === 'development') {
+        console.log(error);
+      }
+      
+      const locale = request.locale || i18n.detectLanguage(request);
+
+      if(error.data?.sqlMessage) {
+        return sqlErrorHandler(error, request, reply);
+      }
+      
+      // Handle validation errors
+      if (error.validation) {
+        const validationErrors = error.validation.map(err => {
+          const field_name = err.instancePath?.replace('/', '') || err.dataPath?.replace('/', '') || err.params?.missingProperty || 'field'
+          return {
+            field: field_name,
+            message: i18n.t('validation.' + err.keyword, locale, { field: i18n.t('validation.fields.' + field_name, locale) })
+          }
+        });
+
+        return reply.status(400).send({
+          status: false,
+          message: i18n.t('validation.errors.validation', locale),
+          details: validationErrors,
+          code: 400
+        });
+      }
+
+      // Handle 404 Not Found errors
+      if (error.statusCode === 404) {
+        return reply.status(404).send({
+          status: false,
+          message: error.message || 'Route not found',
+          code: 404
+        });
+      }
+
+      // Handle other errors
+      const statusCode = error.statusCode || 500;
+      
+      reply.status(statusCode).send({
+        status: false,
+        message: error.message || 'Internal server error',
+        code: statusCode
+      });
+  }
+
+  static errorNotFoundHandler(request, reply) {
+    reply.status(404).send({
+      status: false,
+      message: request.method + ':' + request.url + ' not found',
+      code: 404
+    });
+  }
+
+  /**
+   * Get error key based on status code
+   * @param {number} statusCode - HTTP status code
+   * @returns {string} Error key
+   */
+  static getErrorKey(statusCode) {
+    switch (statusCode) {
+      case 400:
+        return 'errors.badRequest';
+      case 401:
+        return 'errors.unauthorized';
+      case 403:
+        return 'errors.forbidden';
+      case 404:
+        return 'errors.notFound';
+      case 409:
+        return 'errors.conflict';
+      case 500:
+      default:
+        return 'errors.server';
+    }
+  }
+
+  /**
+   * Response formatter middleware
+   * Adds consistent response format with i18n support
+   */
+  static responseFormatter() {
+    return async (request, reply) => {
+      
+      // Skip response formatting for Swagger routes
+      if (request.routeOptions.url.startsWith('/docs') || request.routeOptions.url.startsWith('/docs/')) {
+        return;
+      }
+      
+      const originalSend = reply.send;
+      
+      reply.send = function(payload) {
+        // If payload is already formatted (success or error), send as is
+        if (payload && typeof payload === 'object' && 
+            (payload.success !== undefined || payload.status !== undefined || payload.error !== undefined)) {
+          return originalSend.call(this, payload);
+        }
+
+        // Format success response
+        const locale = request.locale || 'en';
+        return originalSend.call(this, {
+          status: true,
+          data: payload,
+          locale,
+          timestamp: new Date().toISOString()
+        });
+      };
+    };
+  }
+
+}
+
+const sqlErrorHandler = (error, request, reply) => {
+  return reply.status(500).send({
+    status: false,
+    message: i18n.t('sql.' + error.data.code.toLowerCase(), request.headers.locale || 'en', {...request.body, ...request.query, ...request.params})
+  });
+}
+
+module.exports = Middleware;

package/utils/routeLoader.js

@@ -0,0 +1,227 @@
+const fs = require('fs');
+const path = require('path');
+const JsonRouteLoader = require('./jsonRouteLoader');
+const general = require('@root/libraries/general');
+
+/**
+ * Automatically loads routes from the routes directory
+ * @param {Object} fastify - Fastify instance
+ * @param {string} routesDir - Path to routes directory
+ * @param {boolean} includeCommon - Whether to include common routes
+ * @param {boolean} includeAuto - Whether to include auto routes
+ */
+async function loadRoutes(fastify, routesDir = './routes', includeCommon = false, workerName) {
+  const routesPath = path.resolve(routesDir);
+  
+  if (!fs.existsSync(routesPath)) {
+    console.warn(`Routes directory ${routesPath} does not exist`);
+    return;
+  }
+
+  if(!fs.existsSync(routesPath + '/spec')) {
+    fs.mkdirSync(routesPath + '/spec');
+  }
+  
+  // Load routes from each subdirectory (admin, api, etc.)
+  const routeGroups = fs.readdirSync(routesPath + '/spec', { withFileTypes: true })
+    .filter(dirent => {
+      return dirent.name.includes('.js') && dirent.isFile();
+    })
+    .map(dirent => dirent.name);
+  
+  for (const group of routeGroups) {
+    const groupPath = path.join(routesPath + '/spec', group);
+    await loadRouteGroup(fastify, group, groupPath, workerName);
+  }
+
+  // Load JSON routes from routes/admin folder
+  const jsonLoader = new JsonRouteLoader();
+  await jsonLoader.loadJsonRoutes(fastify, routesPath + '/auto', workerName);
+
+  // // Load common routes if requested
+  if (includeCommon) {
+    const commonPath = path.resolve(__dirname + '/../routes/common');
+
+    if (fs.existsSync(commonPath)) {
+
+      if(!fs.existsSync(commonPath + '/spec')) {
+        fs.mkdirSync(commonPath + '/spec');
+      }
+
+      const routeGroupsCommon = fs.readdirSync(commonPath + '/spec', { withFileTypes: true })
+      .filter(dirent => {
+        return dirent.name.includes('.js') && dirent.isFile();
+      })
+      .map(dirent => dirent.name);
+
+      for (const group of routeGroupsCommon) {
+        const groupPath = path.join(commonPath + '/spec', group);
+        await loadRouteGroup(fastify, group, groupPath, workerName);
+      }
+
+      await jsonLoader.loadJsonRoutes(fastify, commonPath + '/auto', workerName);
+    }
+  }
+}
+
+/**
+ * Load routes from a specific group (admin, api, etc.)
+ * @param {Object} fastify - Fastify instance
+ * @param {string} groupName - Name of the route group
+ * @param {string} groupPath - Path to the route group directory
+ */
+async function loadRouteGroup(fastify, groupName, groupPath, workerName) {
+  await loadRouteModule(fastify, groupName, groupPath, workerName);
+}
+
+/**
+ * Load a specific route module
+ * @param {Object} fastify - Fastify instance
+ * @param {string} groupName - Name of the route group
+ * @param {string} moduleName - Name of the route module
+ * @param {string} modulePath - Path to the route module directory
+ */
+async function loadRouteModule(fastify, groupName, modulePath, workerName) {
+  
+  // Check if route file exists
+  if (!fs.existsSync(modulePath)) {
+    console.warn(`Route file not found: ${modulePath}`);
+    return;
+  }
+  const moduleName = modulePath.split('/').pop().split('.')[0];
+  
+  try {
+
+    // Load route configuration
+    const moduleFile = require(modulePath);
+    
+    if(Array.isArray(moduleFile)) {
+      
+      for (const route of moduleFile) {
+        if(!route.method) {
+          console.warn(`Route method is required for route ${route.path}`);
+          continue;
+        }
+        if(!route.handler) {
+          console.warn(`Route handler is required for route ${route.path}`);
+          continue;
+        }
+        
+        if(route.path) {
+          route.path = `/${moduleName}/${route.path}`;
+        } else {
+          route.path = `/${moduleName}`;
+        }
+        
+        await registerRoute(fastify, route, moduleName, workerName);
+      }
+    }
+
+  } catch (error) {
+    console.error(`Error loading route module ${modulePath}:`, error);
+  }
+}
+
+/**
+ * Register a single route
+ * @param {Object} fastify - Fastify instance
+ * @param {Object} routeConfig - Route configuration
+ * @param {Object} handler - Route handler
+ * @param {Object} validation - Route validation
+ * @param {string} prefix - Route prefix
+ */
+async function registerRoute(fastify, routeConfig, moduleName, workerName) {
+  const {
+    method = 'GET',
+    path = '',
+    schema = {},
+    preHandler = undefined,
+    handler = () => {},
+    security = undefined
+  } = routeConfig;
+  
+  // Build full URL
+  const fullUrl = path;
+
+  if(schema.success_response && schema.success_response.type === 'object' && schema.success_response.properties && schema.success_response.properties.pagination) {
+    schema.success_response.properties.pagination = {
+      type: 'object',
+      properties: {
+        total: { type: 'integer' },
+        page: { type: 'integer' },
+        limit: { type: 'integer' },
+        totalPages: { type: 'integer' }
+      }
+    }
+  }
+
+  const schemaRoute = {
+    tags: [general.titleCase(moduleName)],
+    response: {
+      200: schema.success_response ? { ...schema.success_response, additionalProperties: schema.success_response.additionalProperties || false } : {
+        type: 'object',
+        properties: {
+          status: { type: 'boolean', default: true },
+          data: { type: 'object' }
+        },
+        additionalProperties: false
+      },
+      400: schema.error_response || {
+        type: 'object',
+        properties: {
+          status: { type: 'boolean', default: false },
+          message: { type: 'string' },
+          details: { type: 'array', items: { type: 'object', properties: { field: { type: 'string' }, message: { type: 'string' } } } }
+        }
+      }
+    }
+  }
+
+  if(schema.body) {
+    schemaRoute.body = schema.body;
+  }
+
+  if(schema.params) {
+    schemaRoute.params = schema.params;
+  }
+
+  if(schema.headers) {
+    schemaRoute.headers = schema.headers;
+  }
+
+  if(schema.querystring) {
+    schemaRoute.querystring = schema.querystring;
+  }
+
+  if(schema.security) {
+    schemaRoute.security = schema.security;
+  }
+
+  if(schema.summary) {
+    schemaRoute.summary = schema.summary;
+  }
+
+  if(schema.description) {
+    schemaRoute.description = schema.description;
+  }
+
+  if(security && security === 'auth') {
+    schemaRoute.security = [{ bearer: [] }];
+  }
+
+  // Register the route
+  fastify.route({
+    method: method.toUpperCase(),
+    url: fullUrl,
+    schema: schemaRoute,
+    preHandler: async (request, reply, done) => {
+
+      if(security) {
+        await require(`@root/routes/${workerName}/middlewares`)[security](request, reply);
+      }
+    },
+    handler: handler
+  });
+}
+
+module.exports = { loadRoutes };

package/workers/admin.js

@@ -0,0 +1,124 @@
+require('module-alias/register')
+require('dotenv').config();
+
+const Store = require('@root/libraries/stores');
+
+const fastify = require('fastify')({
+  logger: {
+    level: process.env.LOG_LEVEL || 'info'
+  }
+});
+
+const { loadRoutes } = require('@root/utils/routeLoader');
+const Middleware = require('@root/utils/middleware');
+
+// Register plugins
+async function registerPlugins() {
+  // Set error handler first, before any plugins
+  fastify.setErrorHandler(Middleware.errorHandler);
+  fastify.setNotFoundHandler(Middleware.errorNotFoundHandler);
+  
+  // CORS plugin
+  await fastify.register(require('@fastify/cors'), {
+    origin: process.env.CORS_ORIGIN || '*',
+    credentials: true
+  });
+
+  // Swagger documentation
+  const swaggerConfig = require('@root/config/swagger/admin');
+  
+  await fastify.register(require('@fastify/swagger'), swaggerConfig.swagger);
+
+  // Swagger UI
+  await fastify.register(require('@fastify/swagger-ui'), swaggerConfig.swaggerUi);
+
+  // Fastify Multipart plugin
+  fastify.register(require('@fastify/multipart'), {
+    attachFieldsToBody: true, // Optional: attaches fields to the body object
+    throwFileSizeLimit: true, // Optional: throws an error if the file size limit is exceeded
+    limits: {
+      fieldNameSize: 100, // Max field name size in bytes
+      fieldSize: 100,     // Max field value size in bytes
+      fields: 10,         // Max number of non-file fields
+      fileSize: 1000000,  // For multipart forms, the max file size in bytes
+      files: 1,           // Max number of file fields
+      headerPairs: 2000,  // Max number of header key=>value pairs
+      parts: 1000         // For multipart forms, the max number of parts (fields + files)
+    }
+  });
+
+  // Register other middleware
+  fastify.addHook('preHandler', Middleware.languageDetection());
+  fastify.addHook('preHandler', Middleware.responseFormatter());
+
+  // Health check endpoint
+  fastify.get('/health', async (request, reply) => {
+    return { 
+      status: 'ok', 
+      service: 'admin',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+      pid: process.pid
+    };
+  });
+}
+
+// Load admin routes, common routes, and auto routes
+async function loadAdminRoutes() {
+  try {
+    // Load admin routes
+    await loadRoutes(fastify, __dirname + '/../routes/admin', true, 'admin');
+  } catch (error) {
+    console.error('Error loading admin routes:', error);
+    process.exit(1);
+  }
+}
+
+// Start admin service
+async function start() {
+  try {
+
+    // Initialize Store
+    await Store.init();
+
+    // Register plugins
+    await registerPlugins();
+
+    // Load admin routes
+    await loadAdminRoutes();
+
+    // Start server
+    const port = process.env.ADMIN_PORT || 3001;
+    const host = process.env.HOST || '0.0.0.0';
+    
+    fastify.listen({ port, host });
+
+  } catch (error) {
+    console.error('Error starting admin service:', error);
+    process.exit(1);
+  }
+}
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  try {
+    await fastify.close();
+    process.exit(0);
+  } catch (error) {
+    console.error('Error during admin service shutdown:', error);
+    process.exit(1);
+  }
+});
+
+process.on('SIGTERM', async () => {
+  try {
+    await fastify.close();
+    process.exit(0);
+  } catch (error) {
+    console.error('Error during admin service shutdown:', error);
+    process.exit(1);
+  }
+});
+
+// Start the admin service
+start();

package/workers/api.js

@@ -0,0 +1,106 @@
+require('module-alias/register')
+require('dotenv').config();
+
+const fastify = require('fastify')({
+  logger: {
+    level: process.env.LOG_LEVEL || 'info'
+  }
+});
+
+const { loadRoutes } = require('@root/utils/routeLoader');
+const Middleware = require('@root/utils/middleware');
+
+// Register plugins
+async function registerPlugins() {
+  // Set error handler first, before any plugins
+  fastify.setErrorHandler(Middleware.errorHandler);
+  fastify.setNotFoundHandler(Middleware.errorNotFoundHandler);
+  
+  // CORS plugin
+  await fastify.register(require('@fastify/cors'), {
+    origin: process.env.CORS_ORIGIN || '*',
+    credentials: true
+  });
+
+  // Swagger documentation
+  const swaggerConfig = require('@root/config/swagger/api');
+  await fastify.register(require('@fastify/swagger'), swaggerConfig.swagger);
+
+  // Swagger UI
+  await fastify.register(require('@fastify/swagger-ui'), swaggerConfig.swaggerUi);
+
+  // Register other middleware
+  fastify.addHook('preHandler', Middleware.languageDetection());
+  fastify.addHook('preHandler', Middleware.responseFormatter());
+
+  // Health check endpoint
+  fastify.get('/health', async (request, reply) => {
+    return { 
+      status: 'ok', 
+      service: 'api',
+      timestamp: new Date().toISOString(),
+      uptime: process.uptime(),
+      pid: process.pid
+    };
+  });
+}
+
+// Load API routes, common routes, and auto routes
+async function loadApiRoutes() {
+  try {
+    // Load API routes
+    await loadRoutes(fastify, __dirname + '/../routes/api', true, 'api');
+    fastify.log.info('API routes loaded successfully');
+  } catch (error) {
+    console.error('Error loading API routes:', error);
+    process.exit(1);
+  }
+}
+
+// Start API service
+async function start() {
+  try {
+
+    // Register plugins
+    await registerPlugins();
+
+    // Load API routes
+    await loadApiRoutes();
+
+    // Start server
+    const port = process.env.API_PORT || 3000;
+    const host = process.env.HOST || '0.0.0.0';
+    
+    fastify.listen({ port, host });
+    
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+}
+
+// Graceful shutdown
+process.on('SIGINT', async () => {
+  fastify.log.info('API service received SIGINT, shutting down gracefully...');
+  try {
+    await fastify.close();
+    process.exit(0);
+  } catch (error) {
+    console.error('Error during API service shutdown:', error);
+    process.exit(1);
+  }
+});
+
+process.on('SIGTERM', async () => {
+  fastify.log.info('API service received SIGTERM, shutting down gracefully...');
+  try {
+    await fastify.close();
+    process.exit(0);
+  } catch (error) {
+    console.error('Error during API service shutdown:', error);
+    process.exit(1);
+  }
+});
+
+// Start the API service
+start();