@ecopex/ecopex-framework 1.0.10 → 1.0.12

package/index.js

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

package/package.json

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

package/routes/auto/handler.js

@@ -26,6 +26,7 @@ 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';
@@ -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 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 knex.connection.db(tableName)
         .insert({
-          ...data,
-          created_at: new Date(),
-          updated_at: new Date()
+          ...data
         });
 
-      const item = await knex.connection.db(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;
@@ -370,9 +377,7 @@ async function update(request, reply, routeOptions = {}) {
         updated_at: new Date()
       })
 
-    const updatedItem = await knex.connection.db(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 knex.connection.db(tableName)
-      .where(primaryKey, id)
+      .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,
@@ -426,7 +430,7 @@ async function upload(request, reply, routeOptions = {}) {
     }
 
     await knex.connection.db(tableName)
-      .where(primaryKey, id)
+      .where(request.params)
       .update({
         [routeConfig.upload_field]: uploadResult.file.fileUrl
       });

package/utils/jsonRouteLoader.js

@@ -67,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);
@@ -76,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, type);
+          await this.registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema, joinTables, type);
           if(store) {
             await add_model(store, primaryKey, schema);
           }
@@ -112,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, type = 'service') {
+  async registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema, joinTables, type = 'service') {
 
-    const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type);
+    const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type, joinTables);
     const routeKey = `${routeDefinition.method}:${routeDefinition.url}`;
 
     if (this.registeredRoutes.has(routeKey)) {
@@ -149,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 });
         }
       });
 
@@ -167,7 +168,7 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Route definition
    */
-  generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type = 'service') {
+  generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type = 'service', joinTables = {}) {
     const prefix = configStore.prefix ? configStore.prefix + '/' : '';
     const baseUrl = `/${prefix}${fileName}`;
     primaryKey = primaryKey || 'id';
@@ -176,32 +177,32 @@ class JsonRouteLoader {
       list: {
         method: 'GET',
         url: baseUrl,
-        schema: this.generateListSchema(tableName, routeConfig, primaryKey, schema, type)
+        schema: this.generateListSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       get: {
         method: 'GET',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema, type)
+        schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       create: {
         method: 'POST',
         url: baseUrl,
-        schema: this.generateCreateSchema(tableName, routeConfig, primaryKey, schema, type)
+        schema: this.generateCreateSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       update: {
         method: 'PUT',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type)
+        schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       delete: {
         method: 'DELETE',
         url: `${baseUrl}/:${primaryKey}`,
-        schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type)
+        schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       upload: {
         method: 'POST',
-        url: `${baseUrl}/:${primaryKey}/upload`,
-        schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema, type),
+        url: `${baseUrl}/:${primaryKey}/${routeConfig.upload_field || 'upload'}`,
+        schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema, type, joinTables),
         validatorCompiler: ({ schema }) => {
           return (data) => {
             return true;
@@ -222,8 +223,8 @@ class JsonRouteLoader {
    * @param {Object} filters - Filters object
    * @returns {Object} Schema
    */
-  generateListSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
-    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`,
@@ -281,8 +282,8 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateGetSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
-    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 {
@@ -322,7 +323,7 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateCreateSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
+  generateCreateSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     const bodySchema = this.generateBodySchema(schema, false, primaryKey);
 
     return {
@@ -335,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
         },
@@ -356,7 +357,7 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
+  generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     const bodySchema = this.generateBodySchema(schema, true, primaryKey, 'updatable');
     
     return {
@@ -377,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
         },
@@ -398,7 +399,7 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
+  generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     return {
       description: `Delete ${tableName} by ID`,
       tags: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(tableName)],
@@ -416,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
         },
@@ -437,7 +438,7 @@ class JsonRouteLoader {
    * @param {Object} routeConfig - Route configuration
    * @returns {Object} Schema
    */
-  generateUploadSchema(tableName, routeConfig, primaryKey, schema, type = 'service') {
+  generateUploadSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
     const uploadField = routeConfig.upload_field || 'file';
     return {
       description: `Upload file for ${tableName} by ${primaryKey}`,
@@ -464,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
         },
@@ -484,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' };
     }
@@ -509,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/routeLoader.js

@@ -147,18 +147,6 @@ async function registerRoute(fastify, routeConfig, moduleName, workerName, type
   // 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: [(type == 'service' ? general.titleCase(configStore.name) + ' | ' : 'Common | ') + 'Specs | ' + general.titleCase(moduleName)],
     response: {
@@ -213,6 +201,38 @@ async function registerRoute(fastify, routeConfig, moduleName, workerName, type
     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(),