@ecopex/ecopex-framework 1.0.8 → 1.0.10

package/config/swagger.js

@@ -2,12 +2,13 @@
  * Swagger configuration for Admin service
  */
 const { config } = require('../stores/config');
+
 module.exports = {
     swagger: {
         openapi: {
         info: {
-            title: config.name + ' API',
-            description: config.name + ' API documentation for ' + config.name,
+            title: (config.name || '').toUpperCase() + ' API',
+            description: (config.name || '').toUpperCase() + ' API DOCUMENTATION',
             version: '1.0.0'
         },
         host: `${config.host || 'localhost'}:${config.port || 3001}`,
@@ -40,6 +41,6 @@ module.exports = {
         }
     },
     swaggerUi: {
-        routePrefix: '/docs'
+        routePrefix: '/'
     }
 };

package/index.js

@@ -15,7 +15,7 @@ const start = async (config) => {
 
 module.exports = {
     start,
-    db: knex.instance,
+    db: knex.connection.db,
     date: date,
     jwt: jwt,
     bcrypt: bcrypt,

package/libraries/controls.js

@@ -98,6 +98,13 @@ const ipcheck = (req, whitelists = '') => {
     }
 }
 
+const toTitleCase = (str = '') => {
+  return str.replace(
+    /\w\S*/g,
+    text => text.charAt(0).toUpperCase() + text.substring(1).toLowerCase()
+  );
+}
+
 module.exports = {
     emailValidation,
     phoneValidation,
@@ -109,5 +116,6 @@ module.exports = {
     checkPassoword,
     ipcheck,
     sleep,
-    roundTo
+    roundTo,
+    toTitleCase
 }

package/libraries/fastify.js

@@ -1,6 +1,6 @@
 const { loadRoutes } = require('../utils/routeLoader');
 const Middleware = require('../utils/middleware');
-const { setConfig } = require('../stores/config');
+const { setConfig, config: configStore } = require('../stores/config');
 
 let fastifyInstance = null;
 
@@ -15,8 +15,8 @@ async function registerPlugins(config) {
     });
 
     // Set error handler first, before any plugins
-    fastifyInstance.setErrorHandler(Middleware.errorHandler);
-    fastifyInstance.setNotFoundHandler(Middleware.errorNotFoundHandler);
+    fastifyInstance.setErrorHandler((error, request, reply) => Middleware.errorHandler(error, request, reply, config));
+    fastifyInstance.setNotFoundHandler((request, reply) => Middleware.errorNotFoundHandler(request, reply));
     
     // CORS plugin
     await fastifyInstance.register(require('@fastify/cors'), {
@@ -52,14 +52,23 @@ async function registerPlugins(config) {
     fastifyInstance.addHook('preHandler', Middleware.responseFormatter());
 
     // Health check endpoint
-    fastifyInstance.get('/health', async (request, reply) => {
-        return { 
-            status: 'ok', 
-            service: config.name,
-            timestamp: new Date().toISOString(),
-            uptime: process.uptime(),
-            pid: process.pid
-        };
+    fastifyInstance.route({
+        method: 'GET',
+        url: '/' + (configStore.prefix ? configStore.prefix + '/' : '') + 'health',
+        schema: {
+            description: 'Health check',
+            summary: 'Health check',
+            tags: ['Global Services']
+        },
+        handler: async (request, reply) => {
+            return { 
+                status: 'ok', 
+                service: config.name,
+                timestamp: new Date().toISOString(),
+                uptime: process.uptime(),
+                pid: process.pid
+            };
+        }
     });
 
     return fastifyInstance;
@@ -70,7 +79,7 @@ async function loadAdminRoutes(config) {
     try {
         // Load admin routes
         if(fastifyInstance) {
-            await loadRoutes(fastifyInstance, './routes/' + config.name, true, config.name);
+            await loadRoutes(fastifyInstance, './routes/' + config.name, config.common || false, config.name);
         }
     } catch (error) {
         console.error('Error loading admin routes:', error);
@@ -83,7 +92,7 @@ async function start(config) {
     try {
         
         setConfig(config);
-
+        
         // Register plugins
         await registerPlugins(config);
         

package/libraries/knex.js

@@ -1,9 +1,10 @@
 const knex = require('knex');
 
-let instance = null;
+const connection = {
+    db: null
+}
 
-const initialize = async (config) => {
-    const { config: configStore } = require('../stores/config');
+const initialize = async (configStore) => {
     const databaseConfig = configStore?.database || {};
 
     const db_config = {
@@ -30,10 +31,12 @@ const initialize = async (config) => {
     }
 
     const db = knex(db_config[configStore.development ? 'development' : 'production']);
-    instance = db;
+    connection.db = db;
+
+    return connection.db;
 }
 
 module.exports = {
     initialize,
-    instance
+    connection
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopex/ecopex-framework",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Javascript Framework for API and Admin Panel",
   "main": "index.js",
   "scripts": {

package/routes/auto/handler.js

@@ -1,4 +1,4 @@
-const db = require('../../libraries/knex');
+const knex = require('../../libraries/knex');
 const BCRYPT = require('../../libraries/bcrypt');
 const bcrypt = new BCRYPT();
 const i18n = require('../../utils/i18n');
@@ -30,7 +30,7 @@ async function getAll(request, reply, routeOptions = {}) {
     const orderBy = `${tableName}.${(splitOrder[0] || primaryKey)}`;
     const orderDirection = splitOrder[1] || 'desc';
 
-    let query = db(tableName + ' as ' + tableName).select(`${tableName}.*`);
+    let query = knex.connection.db(tableName + ' as ' + tableName).select(`${tableName}.*`);
 
     // Apply search filter if provided
     if (search && routeConfig.searchable_fields) {
@@ -155,7 +155,7 @@ async function getById(request, reply, routeOptions = {}) {
     const tableName = routeOptions.tableName || 'users';
     const routeConfig = routeOptions.routeConfig || {};
 
-    const item_query = db(tableName)
+    const item_query = knex.connection.db(tableName)
       .select(`${tableName}.*`)
       .where(primaryKey, id);
 
@@ -261,14 +261,14 @@ async function create(request, reply, routeOptions = {}) {
     }
 
     try {
-      const [id] = await db(tableName)
+      const [id] = await knex.connection.db(tableName)
         .insert({
           ...data,
           created_at: new Date(),
           updated_at: new Date()
         });
 
-      const item = await db(tableName)
+      const item = await knex.connection.db(tableName)
         .where(primaryKey, id)
         .first();
 
@@ -345,7 +345,7 @@ async function update(request, reply, routeOptions = {}) {
 
 
     // Check if record exists
-    const existingItem = await db(tableName)
+    const existingItem = await knex.connection.db(tableName)
       .where(request.params)
       .first();
 
@@ -363,14 +363,14 @@ async function update(request, reply, routeOptions = {}) {
       }
     }
 
-    await db(tableName)
+    await knex.connection.db(tableName)
       .where(request.params)
       .update({
         ...data,
         updated_at: new Date()
       })
 
-    const updatedItem = await db(tableName)
+    const updatedItem = await knex.connection.db(tableName)
       .where(request.params)
       .first();
 
@@ -406,7 +406,7 @@ async function upload(request, reply, routeOptions = {}) {
     const { [primaryKey]: id } = request.params;
     const routeConfig = routeOptions.routeConfig || {};
 
-    const existingItem = await db(tableName)
+    const existingItem = await knex.connection.db(tableName)
       .where(primaryKey, id)
       .first();
 
@@ -425,7 +425,7 @@ async function upload(request, reply, routeOptions = {}) {
       });
     }
 
-    await db(tableName)
+    await knex.connection.db(tableName)
       .where(primaryKey, id)
       .update({
         [routeConfig.upload_field]: uploadResult.file.fileUrl
@@ -464,7 +464,7 @@ async function deleteRecord(request, reply, routeOptions = {}) {
     const tableName = routeOptions.tableName || 'users';
 
     // Check if record exists
-    const existingItem = await db(tableName)
+    const existingItem = await knex.connection.db(tableName)
       .where('id', id)
       .first();
 
@@ -475,7 +475,7 @@ async function deleteRecord(request, reply, routeOptions = {}) {
       });
     }
 
-    await db(tableName)
+    await knex.connection.db(tableName)
       .where('id', id)
       .del();
 
@@ -524,7 +524,7 @@ const generateRandomString = async (from_string = null, field_name = null, table
  * @returns {Promise<boolean>} - The unique status
  */
 const checkUnique = async (value = null, field_name = null, tableName = null) => {
-  const existing_item = await db(tableName).select(field_name).where(field_name, value).first();
+  const existing_item = await knex.connection.db(tableName).select(field_name).where(field_name, value).first();
   return existing_item ? true : false;
 }
 
@@ -594,7 +594,7 @@ const processJoinTables = async (items, joinTables) => {
       
       const personal_ids = items.map(item => item[joinTable.primary_key]);
       
-      const personal_items = db(joinTable.table).whereIn(joinTable.table + '.' + joinTable.foreign_key, personal_ids);
+      const personal_items = knex.connection.db(joinTable.table).whereIn(joinTable.table + '.' + joinTable.foreign_key, personal_ids);
 
       if(joinTable.extra_where) {
         personal_items.where(db.raw(joinTable.table + '.' + joinTable.extra_where));

package/stores/base.js

@@ -1,9 +1,9 @@
-const knex = require('../libraries/knex');
+const { connection } = require('../libraries/knex');
 
 module.exports = class StoreModel {
     constructor(name = 'store_model', primary_key = 'id', schema = {}) {
         this.name = name;
-        this.knex = knex;
+        this.knex = connection.db;
         this.data = new Map();
         this.primary_key = primary_key;
         this.schema = schema;

package/stores/config.js

@@ -1,7 +1,12 @@
-let config = {};
+const config = {};
 
-const setConfig = (config) => {
-    config = config;
+const setConfig = (newConfig) => {
+    if(Object.keys(newConfig).length > 0) {
+        for(const key in newConfig) {
+            config[key] = newConfig[key];
+        }
+    }
+    return config;
 }
 
 module.exports = {

package/utils/jsonRouteLoader.js

@@ -3,6 +3,7 @@ const path = require('path');
 const handlers = require('../routes/auto/handler');
 const general = require('../libraries/general');
 const { add_model } = require('../stores');
+const { config: configStore } = require('../stores/config');
 
 /**
  * JSON Route Loader
@@ -19,7 +20,7 @@ class JsonRouteLoader {
    * Load all JSON route configurations from routes/admin folder
    * @param {Object} fastify - Fastify instance
    */
-  async loadJsonRoutes(fastify, routesDir, workerName) {
+  async loadJsonRoutes(fastify, routesDir, workerName, type = 'service') {
     const adminPath = path.resolve(routesDir);
 
     if(!workerName) {
@@ -39,7 +40,7 @@ class JsonRouteLoader {
 
     for (const jsonFile of jsonFiles) {
       try {
-        await this.loadJsonRoute(fastify, path.join(adminPath, jsonFile), workerName);
+        await this.loadJsonRoute(fastify, path.join(adminPath, jsonFile), workerName, type);
       } catch (error) {
         console.log(error.message);
       }
@@ -51,7 +52,7 @@ class JsonRouteLoader {
    * @param {Object} fastify - Fastify instance
    * @param {string} jsonPath - Path to JSON file
    */
-  async loadJsonRoute(fastify, jsonPath, workerName) {
+  async loadJsonRoute(fastify, jsonPath, workerName, type = 'service') {
     try {
 
       const config = require(jsonPath);
@@ -75,7 +76,7 @@ class JsonRouteLoader {
         const routeName = route.action;
         const routeConfig = route;
         if (this.supportedRoutes.includes(routeName)) {
-          await this.registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema);
+          await this.registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema, type);
           if(store) {
             await add_model(store, primaryKey, schema);
           }
@@ -111,9 +112,9 @@ class JsonRouteLoader {
    * @param {string} routeName - Route name (list, get, create, update, delete)
    * @param {Object} routeConfig - Route configuration
    */
-  async registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema) {
+  async registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema, type = 'service') {
 
-    const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema);
+    const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type);
     const routeKey = `${routeDefinition.method}:${routeDefinition.url}`;
 
     if (this.registeredRoutes.has(routeKey)) {
@@ -166,40 +167,41 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Route definition
    */
-  generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema) {
-    const baseUrl = `/${fileName}`;
+  generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type = 'service') {
+    const prefix = configStore.prefix ? configStore.prefix + '/' : '';
+    const baseUrl = `/${prefix}${fileName}`;
     primaryKey = primaryKey || 'id';
 
     const routeDefinitions = {
       list: {
         method: 'GET',
         url: baseUrl,
-        schema: this.generateListSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateListSchema(tableName, routeConfig, primaryKey, schema, type)
       },
       get: {
         method: 'GET',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema, type)
       },
       create: {
         method: 'POST',
         url: baseUrl,
-        schema: this.generateCreateSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateCreateSchema(tableName, routeConfig, primaryKey, schema, type)
       },
       update: {
         method: 'PUT',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type)
       },
       delete: {
         method: 'DELETE',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type)
       },
       upload: {
         method: 'POST',
         url: `${baseUrl}/:${primaryKey}/upload`,
-        schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema),
+        schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema, type),
         validatorCompiler: ({ schema }) => {
           return (data) => {
             return true;
@@ -220,12 +222,12 @@ class JsonRouteLoader {
    * @param {Object} filters - Filters object
    * @returns {Object} Schema
    */
-  generateListSchema(tableName, routeConfig, primaryKey, schema) {
+  generateListSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
     const itemSchema = this.generateItemSchema(schema, primaryKey);
 
     return {
       description: `Get all ${tableName} with pagination and search`,
-      tags: [general.titleCase(tableName)],
+      tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(tableName)],
       summary: routeConfig.summary || `List of ${tableName} with pagination and search`,
       querystring: {
         type: 'object',
@@ -279,13 +281,13 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateGetSchema(tableName, routeConfig, primaryKey, schema) {
+  generateGetSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
     const itemSchema = this.generateItemSchema(schema, primaryKey);
     primaryKey = primaryKey || 'id';
 
     return {
       description: `Get ${tableName} by ${primaryKey}`,
-      tags: [general.titleCase(tableName)],
+      tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(tableName)],
       summary: routeConfig.summary || `Get ${tableName} by ${primaryKey}`,
       params: {
         type: 'object',
@@ -320,12 +322,12 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateCreateSchema(tableName, routeConfig, primaryKey, schema) {
+  generateCreateSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
     const bodySchema = this.generateBodySchema(schema, false, primaryKey);
 
     return {
       description: `Create new ${tableName}`,
-      tags: [general.titleCase(tableName)],
+      tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(tableName)],
       summary: routeConfig.summary || `Create new ${tableName}`,
       body: bodySchema,
       response: {
@@ -354,12 +356,12 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateUpdateSchema(tableName, routeConfig, primaryKey, schema) {
+  generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
     const bodySchema = this.generateBodySchema(schema, true, primaryKey, 'updatable');
     
     return {
       description: `Update ${tableName} by ID`,
-      tags: [general.titleCase(tableName)],
+      tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(tableName)],
       summary: routeConfig.summary || `Update ${tableName} by ${primaryKey}`,
       params: {
         type: 'object',
@@ -396,10 +398,10 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateDeleteSchema(tableName, routeConfig, primaryKey, schema) {
+  generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
     return {
       description: `Delete ${tableName} by ID`,
-      tags: [general.titleCase(tableName)],
+      tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(tableName)],
       summary: routeConfig.summary || `Delete ${tableName} by ${primaryKey}`,
       params: {
         type: 'object',
@@ -435,11 +437,11 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateUploadSchema(tableName, routeConfig, primaryKey, schema) {
+  generateUploadSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
     const uploadField = routeConfig.upload_field || 'file';
     return {
       description: `Upload file for ${tableName} by ${primaryKey}`,
-      tags: [general.titleCase(tableName)],
+      tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(tableName)],
       summary: routeConfig.summary || `Upload file for ${tableName} by ${primaryKey}`,
       params: {
         type: 'object',

package/utils/middleware.js

@@ -1,5 +1,4 @@
 const i18n = require('./i18n');
-const db = require('../libraries/knex');
 const { config } = require('../stores/config');
 /**
  * Middleware utilities for Fastify
@@ -17,10 +16,6 @@ class Middleware {
       // 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);
@@ -30,8 +25,8 @@ class Middleware {
   /**
    * Error handler middleware with custom response format
    */
-  static errorHandler(error, request, reply) {
-
+  static errorHandler(error, request, reply, config) {
+    
       if(config.development) {
         console.log(error);
       }
@@ -68,7 +63,7 @@ class Middleware {
           code: 404
         });
       }
-
+      
       // Handle other errors
       const statusCode = error.statusCode || 500;
       
@@ -116,9 +111,11 @@ class Middleware {
    */
   static responseFormatter() {
     return async (request, reply) => {
+
+      const route_url = request?.routeOptions?.url || request.url;
       
       // Skip response formatting for Swagger routes
-      if (request.routeOptions.url.startsWith('/docs') || request.routeOptions.url.startsWith('/docs/')) {
+      if (route_url.startsWith('/') || route_url.startsWith('/')) {
         return;
       }
       

package/utils/routeLoader.js

@@ -2,6 +2,7 @@ const fs = require('fs');
 const path = require('path');
 const JsonRouteLoader = require('./jsonRouteLoader');
 const general = require('../libraries/general');
+const { config: configStore } = require('../stores/config');
 
 /**
  * Automatically loads routes from the routes directory
@@ -11,6 +12,7 @@ const general = require('../libraries/general');
  * @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)) {
@@ -31,17 +33,17 @@ async function loadRoutes(fastify, routesDir = './routes', includeCommon = false
   
   for (const group of routeGroups) {
     const groupPath = path.join(routesPath + '/spec', group);
-    await loadRouteGroup(fastify, group, groupPath, workerName);
+    await loadRouteGroup(fastify, group, groupPath, workerName, 'service');
   }
 
   // Load JSON routes from routes/admin folder
   const jsonLoader = new JsonRouteLoader();
-  await jsonLoader.loadJsonRoutes(fastify, routesPath + '/auto', workerName);
+  await jsonLoader.loadJsonRoutes(fastify, routesPath + '/auto', workerName, 'service');
 
   // // Load common routes if requested
   if (includeCommon) {
-    const commonPath = path.resolve(__dirname + '/../routes/common');
-
+    const commonPath = path.resolve('./routes/common');
+    
     if (fs.existsSync(commonPath)) {
 
       if(!fs.existsSync(commonPath + '/spec')) {
@@ -56,10 +58,10 @@ async function loadRoutes(fastify, routesDir = './routes', includeCommon = false
 
       for (const group of routeGroupsCommon) {
         const groupPath = path.join(commonPath + '/spec', group);
-        await loadRouteGroup(fastify, group, groupPath, workerName);
+        await loadRouteGroup(fastify, group, groupPath, workerName, 'common');
       }
 
-      await jsonLoader.loadJsonRoutes(fastify, commonPath + '/auto', workerName);
+      await jsonLoader.loadJsonRoutes(fastify, commonPath + '/auto', workerName, 'common');
     }
   }
 }
@@ -70,8 +72,8 @@ async function loadRoutes(fastify, routesDir = './routes', includeCommon = false
  * @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);
+async function loadRouteGroup(fastify, groupName, groupPath, workerName, type = '--') {
+  await loadRouteModule(fastify, groupName, groupPath, workerName, type);
 }
 
 /**
@@ -81,7 +83,7 @@ async function loadRouteGroup(fastify, groupName, groupPath, workerName) {
  * @param {string} moduleName - Name of the route module
  * @param {string} modulePath - Path to the route module directory
  */
-async function loadRouteModule(fastify, groupName, modulePath, workerName) {
+async function loadRouteModule(fastify, groupName, modulePath, workerName, type = '--') {
   
   // Check if route file exists
   if (!fs.existsSync(modulePath)) {
@@ -106,14 +108,16 @@ async function loadRouteModule(fastify, groupName, modulePath, workerName) {
           console.warn(`Route handler is required for route ${route.path}`);
           continue;
         }
+
+        const prefix = configStore.prefix ? configStore.prefix + '/' : '';
         
         if(route.path) {
-          route.path = `/${moduleName}/${route.path}`;
+          route.path = `/${prefix}${moduleName}/${route.path}`;
         } else {
-          route.path = `/${moduleName}`;
+          route.path = `/${prefix}${moduleName}`;
         }
         
-        await registerRoute(fastify, route, moduleName, workerName);
+        await registerRoute(fastify, route, moduleName, workerName, type);
       }
     }
 
@@ -130,7 +134,7 @@ async function loadRouteModule(fastify, groupName, modulePath, workerName) {
  * @param {Object} validation - Route validation
  * @param {string} prefix - Route prefix
  */
-async function registerRoute(fastify, routeConfig, moduleName, workerName) {
+async function registerRoute(fastify, routeConfig, moduleName, workerName, type = '--') {
   const {
     method = 'GET',
     path = '',
@@ -156,7 +160,7 @@ async function registerRoute(fastify, routeConfig, moduleName, workerName) {
   }
 
   const schemaRoute = {
-    tags: [general.titleCase(moduleName)],
+    tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(moduleName)],
     response: {
       200: schema.success_response ? { ...schema.success_response, additionalProperties: schema.success_response.additionalProperties || false } : {
         type: 'object',