@ecopex/ecopex-framework 1.0.9 → 1.0.12

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,
+    knex: knex.connection,
     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.9",
+  "version": "1.0.12",
   "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');
@@ -26,11 +26,12 @@ async function getAll(request, reply, routeOptions = {}) {
     const routeConfig = routeOptions.routeConfig || {};
     const primaryKey = routeOptions.primaryKey || 'id';
     const filters = routeOptions.filters || {};
+    const joinTables = routeOptions.joinTables || {};
     const splitOrder = order.split(':');
     const orderBy = `${tableName}.${(splitOrder[0] || primaryKey)}`;
     const orderDirection = splitOrder[1] || 'desc';
 
-    let query = db.instance(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) {
@@ -49,18 +50,18 @@ async function getAll(request, reply, routeOptions = {}) {
       query.where(routeConfig.owned, request.user?.id || 0);
       query.where(routeConfig.owned_type, request.user?.type || 'user');
     }
-
-    if(routeConfig.join_tables) {
-      for(let i = 0; i < Object.values(routeConfig.join_tables).length; i++) {
-        const tableKey = Object.keys(routeConfig.join_tables)[i];
-        let joinTable = Object.values(routeConfig.join_tables)[i];
+    
+    if(joinTables) {
+      for(let i = 0; i < Object.values(joinTables).length; i++) {
+        const tableKey = Object.keys(joinTables)[i];
+        let joinTable = Object.values(joinTables)[i];
         if(joinTable.type == 'one-to-one') {
           if(joinTable.extra_where) {
             query.leftJoin(joinTable.table + ' as ' + tableKey, `${tableName}.${joinTable.foreign_key} = ${tableKey}.${joinTable.primary_key} AND ${joinTable.extra_where}`);
           } else {
             query.leftJoin(joinTable.table + ' as ' + tableKey, `${tableName}.${joinTable.foreign_key}`, `${tableKey}.${joinTable.primary_key}`);
           }
-          query.select(`${tableKey}.*`);
+          query.select(knex.connection.db.raw(Object.entries(joinTable.properties || {}).map(n => `${tableKey}.${n[0]} as ${n[0]}`).join(', ')));
         }
       }
 
@@ -107,14 +108,11 @@ async function getAll(request, reply, routeOptions = {}) {
     
     const total = parseInt(count);
 
-    const rows = structureRows(items, tableName, routeConfig.join_tables)
+    const rows = structureRows(items, tableName, joinTables)
 
     // Process join tables if configured
-    const processedItems = await processJoinTables(rows, routeConfig.join_tables);
+    const processedItems = await processJoinTables(rows, joinTables);
 
-    // console.log(processedItems);
-    
-    
     const totalPages = Math.ceil(total / limit);
 
     return reply.send({
@@ -143,33 +141,30 @@ async function getAll(request, reply, routeOptions = {}) {
  * @param {Object} routeOptions - The route options
  * @returns {Promise<Object>} - The response object
  */
-async function getById(request, reply, routeOptions = {}) {
+async function getById(request, reply, routeOptions = {}, inner = false) {
 
   if(routeOptions.store) {
     return get_by_primary_key(routeOptions.store, request.params[routeOptions.primaryKey], reply, routeOptions);
   }
 
   try {
-    const primaryKey = routeOptions.primaryKey || 'id';
-    const { [primaryKey]: id } = request.params;
     const tableName = routeOptions.tableName || 'users';
-    const routeConfig = routeOptions.routeConfig || {};
-
-    const item_query = db.instance(tableName)
+    const joinTables = routeOptions.joinTables || {};
+    const item_query = knex.connection.db(tableName)
       .select(`${tableName}.*`)
-      .where(primaryKey, id);
-
-    if(routeConfig.join_tables) {
-      for(let i = 0; i < Object.values(routeConfig.join_tables).length; i++) {
-        const tableKey = Object.keys(routeConfig.join_tables)[i];
-        let joinTable = Object.values(routeConfig.join_tables)[i];
+      .where(request.params);
+    
+    if(joinTables) {
+      for(let i = 0; i < Object.values(joinTables).length; i++) {
+        const tableKey = Object.keys(joinTables)[i];
+        let joinTable = Object.values(joinTables)[i];
         if(joinTable.type == 'one-to-one') {
           if(joinTable.extra_where) {
             item_query.leftJoin(joinTable.table + ' as ' + tableKey, `${tableName}.${joinTable.foreign_key} = ${tableKey}.${joinTable.primary_key} AND ${joinTable.extra_where}`);
           } else {
             item_query.leftJoin(joinTable.table + ' as ' + tableKey, `${tableName}.${joinTable.foreign_key}`, `${tableKey}.${joinTable.primary_key}`);
           }
-          item_query.select(`${tableKey}.*`);
+          item_query.select(knex.connection.db.raw(Object.entries(joinTable.properties || {}).map(n => `${tableKey}.${n[0]} as ${n[0]}`).join(', ')));
         }
       }
 
@@ -177,16 +172,15 @@ async function getById(request, reply, routeOptions = {}) {
     }
     
     const item_data = await item_query.first();
-    console.log(item_data);
     
     let item = {}
     
 
-    if(routeConfig.join_tables) {
+    if(joinTables) {
       item = {
         ...item_data[tableName],
       }
-      const join_one_to_one = Object.entries(routeConfig.join_tables).filter(n => n[1].type === 'one-to-one');
+      const join_one_to_one = Object.entries(joinTables).filter(n => n[1].type === 'one-to-one');
       if(join_one_to_one.length > 0) {
         for(let i = 0; i < join_one_to_one.length; i++) {
           const join_table = join_one_to_one[i];
@@ -198,26 +192,44 @@ async function getById(request, reply, routeOptions = {}) {
     }
     
     if (!item) {
-      return reply.status(404).send({
-        status: false,
-        message: request.t('messages.record_not_found')
-      });
+      if(!inner) {
+        return reply.status(404).send({
+          status: false,
+          message: request.t('messages.record_not_found')
+        });
+      } else {
+        return {
+          status: false,
+          message: request.t('messages.record_not_found')
+        };
+      }
     }
 
     // Process join tables if configured
-    const processedItem = await processJoinTables([item], routeConfig.join_tables);
+    const processedItem = await processJoinTables([item], joinTables);
     const result = processedItem[0];
 
-    return reply.send({
-      status: true,
-      data: result
-    });
+    if(!inner) {
+      return reply.send({
+        status: true,
+        data: result
+      });
+    } else {
+      return result;
+    }
   } catch (error) {
     console.error('Error getting record by ID:', error);
-    return reply.status(500).send({
-      status: false,
-      message: request.t('messages.internal_server_error')
-    });
+    if(!inner) {
+      return reply.status(500).send({
+        status: false,
+        message: request.t('messages.internal_server_error')
+      });
+    } else {
+      return {
+        status: false,
+        message: request.t('messages.internal_server_error')
+      };
+    }
   }
 }
 
@@ -237,7 +249,6 @@ async function create(request, reply, routeOptions = {}) {
   try {
     const tableName = routeOptions.tableName || 'users';
     const primaryKey = routeOptions.primaryKey || 'id';
-    const routeConfig = routeOptions.routeConfig || {};
     const schema = routeOptions.schema || {};
     
     // Use payload field if available, otherwise use request.body directly
@@ -259,18 +270,14 @@ async function create(request, reply, routeOptions = {}) {
         }
       }
     }
-
+    
     try {
-      const [id] = await db.instance(tableName)
+      const [id] = await knex.connection.db(tableName)
         .insert({
-          ...data,
-          created_at: new Date(),
-          updated_at: new Date()
+          ...data
         });
 
-      const item = await db.instance(tableName)
-        .where(primaryKey, id)
-        .first();
+      const item = await getById({ ...request, params: { [primaryKey]: id } }, {}, { ...routeOptions, primaryKey: primaryKey }, true)
 
       return reply.send({
         status: true,
@@ -314,8 +321,8 @@ async function update(request, reply, routeOptions = {}) {
   try {
     const tableName = routeOptions.tableName || 'users';
     const primaryKey = routeOptions.primaryKey || 'id';
-    const routeConfig = routeOptions.routeConfig || {};
     const schema = routeOptions.schema || {};
+    const routeConfig = routeOptions.routeConfig || {};
     
     // Use payload field if available, otherwise use request.body directly
     let data = request.body;
@@ -345,7 +352,7 @@ async function update(request, reply, routeOptions = {}) {
 
 
     // Check if record exists
-    const existingItem = await db.instance(tableName)
+    const existingItem = await knex.connection.db(tableName)
       .where(request.params)
       .first();
 
@@ -363,16 +370,14 @@ async function update(request, reply, routeOptions = {}) {
       }
     }
 
-    await db.instance(tableName)
+    await knex.connection.db(tableName)
       .where(request.params)
       .update({
         ...data,
         updated_at: new Date()
       })
 
-    const updatedItem = await db.instance(tableName)
-      .where(request.params)
-      .first();
+    const updatedItem = await getById({ ...request }, {}, { ...routeOptions, primaryKey: primaryKey }, true);
 
     return reply.send({
       status: true,
@@ -403,11 +408,10 @@ async function upload(request, reply, routeOptions = {}) {
   try {
     const tableName = routeOptions.tableName || 'users';
     const primaryKey = routeOptions.primaryKey || 'id';
-    const { [primaryKey]: id } = request.params;
     const routeConfig = routeOptions.routeConfig || {};
 
-    const existingItem = await db.instance(tableName)
-      .where(primaryKey, id)
+    const existingItem = await knex.connection.db(tableName)
+      .where(request.params)
       .first();
 
     if (!existingItem) {
@@ -417,7 +421,7 @@ async function upload(request, reply, routeOptions = {}) {
       });
     }
 
-    const uploadResult = await uploadFile(request.body[routeConfig.upload_field], id, tableName);
+    const uploadResult = await uploadFile(request.body[routeConfig.upload_field], request.params[primaryKey], tableName);
     if(!uploadResult.status) {
       return reply.status(500).send({
         status: false,
@@ -425,8 +429,8 @@ async function upload(request, reply, routeOptions = {}) {
       });
     }
 
-    await db.instance(tableName)
-      .where(primaryKey, id)
+    await knex.connection.db(tableName)
+      .where(request.params)
       .update({
         [routeConfig.upload_field]: uploadResult.file.fileUrl
       });
@@ -464,7 +468,7 @@ async function deleteRecord(request, reply, routeOptions = {}) {
     const tableName = routeOptions.tableName || 'users';
 
     // Check if record exists
-    const existingItem = await db.instance(tableName)
+    const existingItem = await knex.connection.db(tableName)
       .where('id', id)
       .first();
 
@@ -475,7 +479,7 @@ async function deleteRecord(request, reply, routeOptions = {}) {
       });
     }
 
-    await db.instance(tableName)
+    await knex.connection.db(tableName)
       .where('id', id)
       .del();
 
@@ -524,7 +528,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.instance(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 +598,7 @@ const processJoinTables = async (items, joinTables) => {
       
       const personal_ids = items.map(item => item[joinTable.primary_key]);
       
-      const personal_items = db.instance(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);
@@ -66,6 +67,7 @@ class JsonRouteLoader {
       const store = config.store || null;
       const routes = config.routes || {};
       const schema = config.schema || {};
+      const joinTables = config.join_tables || {};
 
       // Validate configuration
       this.validateConfig(config);
@@ -75,7 +77,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, joinTables, type);
           if(store) {
             await add_model(store, primaryKey, schema);
           }
@@ -111,9 +113,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, joinTables, type = 'service') {
 
-    const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema);
+    const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type, joinTables);
     const routeKey = `${routeDefinition.method}:${routeDefinition.url}`;
 
     if (this.registeredRoutes.has(routeKey)) {
@@ -148,7 +150,7 @@ class JsonRouteLoader {
         },
         handler: async (request, reply) => {
           // Pass table name and route config to handler as additional parameters
-          return handler(request, reply, { tableName, routeConfig, schema, primaryKey, store, filters });
+          return handler(request, reply, { tableName, routeConfig, schema, primaryKey, store, filters, joinTables });
         }
       });
 
@@ -166,40 +168,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', joinTables = {}) {
+    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, joinTables)
       },
       get: {
         method: 'GET',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       create: {
         method: 'POST',
         url: baseUrl,
-        schema: this.generateCreateSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateCreateSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       update: {
         method: 'PUT',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       delete: {
         method: 'DELETE',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema)
+        schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       upload: {
         method: 'POST',
-        url: `${baseUrl}/:${primaryKey}/upload`,
-        schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema),
+        url: `${baseUrl}/:${primaryKey}/${routeConfig.upload_field || 'upload'}`,
+        schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema, type, joinTables),
         validatorCompiler: ({ schema }) => {
           return (data) => {
             return true;
@@ -220,12 +223,12 @@ class JsonRouteLoader {
    * @param {Object} filters - Filters object
    * @returns {Object} Schema
    */
-  generateListSchema(tableName, routeConfig, primaryKey, schema) {
-    const itemSchema = this.generateItemSchema(schema, primaryKey);
+  generateListSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
+    const itemSchema = this.generateItemSchema(schema, primaryKey, joinTables);
 
     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 +282,13 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateGetSchema(tableName, routeConfig, primaryKey, schema) {
-    const itemSchema = this.generateItemSchema(schema, primaryKey);
+  generateGetSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
+    const itemSchema = this.generateItemSchema(schema, primaryKey, joinTables);
     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 +323,12 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateCreateSchema(tableName, routeConfig, primaryKey, schema) {
+  generateCreateSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     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: {
@@ -333,7 +336,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey)
+            data: this.generateItemSchema(schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -354,12 +357,12 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateUpdateSchema(tableName, routeConfig, primaryKey, schema) {
+  generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     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',
@@ -375,7 +378,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey)
+            data: this.generateItemSchema(schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -396,10 +399,10 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateDeleteSchema(tableName, routeConfig, primaryKey, schema) {
+  generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     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',
@@ -414,7 +417,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey)
+            data: this.generateItemSchema(schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -435,11 +438,11 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateUploadSchema(tableName, routeConfig, primaryKey, schema) {
+  generateUploadSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     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',
@@ -462,7 +465,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey)
+            data: this.generateItemSchema(schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -482,7 +485,7 @@ class JsonRouteLoader {
    * @param {Object} itemSchema - Item schema from config
    * @returns {Object} Item schema
    */
-  generateItemSchema(schema, primaryKey) {
+  generateItemSchema(schema, primaryKey, joinTables = {}) {
     if (!schema) {
       return { type: 'object' };
     }
@@ -507,6 +510,18 @@ class JsonRouteLoader {
       }
     }
 
+    if(Object.entries(joinTables).length > 0) {
+      for(const [key, value] of Object.entries(joinTables)) {
+        if(value.type == 'one-to-one') {
+          withoutReferences[value.table] = {
+            type: 'object',
+            properties: value.properties,
+            additionalProperties: false
+          };
+        }
+      }
+    }
+
     return {
       type: 'object',
       properties: withoutReferences,

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.instance('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 = '',
@@ -143,20 +147,8 @@ async function registerRoute(fastify, routeConfig, moduleName, workerName) {
   // 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)],
+    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',
@@ -209,6 +201,38 @@ async function registerRoute(fastify, routeConfig, moduleName, workerName) {
     schemaRoute.security = [{ bearer: [] }];
   }
 
+  if(schema.pagination) {
+
+    if(schemaRoute.querystring && schemaRoute.querystring.properties) {
+      schemaRoute.querystring.properties = Object.assign(schemaRoute.querystring.properties || {}, {
+        page: { type: 'integer', minimum: 1, default: 1 },
+        limit: { type: 'integer', minimum: 1, maximum: 100, default: 25 },
+        search: { type: 'string' },
+        order: { type: 'string' }
+      });
+    } else {
+      schemaRoute.querystring = {
+        type: 'object',
+        properties: {
+          page: { type: 'integer', minimum: 1, default: 1 },
+          limit: { type: 'integer', minimum: 1, maximum: 100, default: 25 },
+          search: { type: 'string' },
+          order: { type: 'string' }
+        }
+      }
+    }
+
+    schemaRoute.response[200].properties.pagination = {
+      type: 'object',
+      properties: {
+        total: { type: 'integer' },
+        page: { type: 'integer' },
+        limit: { type: 'integer' },
+        totalPages: { type: 'integer' }
+      }
+    }
+  }
+
   // Register the route
   fastify.route({
     method: method.toUpperCase(),