@ecopex/ecopex-framework 1.0.0

package/utils/jsonRouteLoader.js

@@ -0,0 +1,587 @@
+const fs = require('fs');
+const path = require('path');
+const handlers = require('@root/routes/auto/handler');
+const general = require('@root/libraries/general');
+const { add_model } = require('@root/stores');
+
+/**
+ * JSON Route Loader
+ * Loads routes from JSON configuration files in routes/admin folder
+ */
+class JsonRouteLoader {
+  constructor() {
+    this.supportedRoutes = ['list', 'get', 'create', 'update', 'delete', 'upload'];
+    this.registeredRoutes = new Set();
+    this.deleteKeys = ['creatable', 'updatable', 'search_type', 'listable', 'crypted', 'create_required', 'generatable', 'unique', 'example'];
+  }
+
+  /**
+   * Load all JSON route configurations from routes/admin folder
+   * @param {Object} fastify - Fastify instance
+   */
+  async loadJsonRoutes(fastify, routesDir, workerName) {
+    const adminPath = path.resolve(routesDir);
+
+    if(!workerName) {
+      console.warn(workerName + ' Worker name is required');
+      return;
+    }
+    
+    if (!fs.existsSync(adminPath)) {
+      console.warn(workerName + ' routes directory does not exist auto directory');
+      return;
+    }
+
+    // Find all JSON files in routes/admin
+    const jsonFiles = fs.readdirSync(adminPath, { withFileTypes: true })
+      .filter(dirent => dirent.isFile() && dirent.name.endsWith('.json'))
+      .map(dirent => dirent.name);
+
+    for (const jsonFile of jsonFiles) {
+      try {
+        await this.loadJsonRoute(fastify, path.join(adminPath, jsonFile), workerName);
+      } catch (error) {
+        console.log(error.message);
+      }
+    }
+  }
+
+  /**
+   * Load a single JSON route configuration
+   * @param {Object} fastify - Fastify instance
+   * @param {string} jsonPath - Path to JSON file
+   */
+  async loadJsonRoute(fastify, jsonPath, workerName) {
+    try {
+
+      const config = require(jsonPath);
+      if(!config) {
+        console.warn(`Config not found for ${jsonPath}`);
+        return;
+      }
+      
+      const fileName = jsonPath.split('/').pop().split('.')[0];
+      const tableName = config.table;
+      const primaryKey = config.primary_key || 'id';
+      const store = config.store || null;
+      const routes = config.routes || {};
+      const schema = config.schema || {};
+
+      // Validate configuration
+      this.validateConfig(config);
+      
+      // Register routes
+      for (const route of routes) {
+        const routeName = route.action;
+        const routeConfig = route;
+        if (this.supportedRoutes.includes(routeName)) {
+          await this.registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema);
+          if(store) {
+            await add_model(store, primaryKey, schema);
+          }
+        } else {
+          fastify.log.warn(`Unsupported route type: ${routeName} for table: ${tableName}`);
+        }
+      }
+
+    } catch (error) {
+      console.log(error);
+      return
+    }
+  }
+
+  /**
+   * Validate JSON configuration
+   * @param {Object} config - Configuration object
+   */
+  validateConfig(config) {
+    if (!config.table) {
+      throw new Error('Table name is required');
+    }
+
+    if (!config.routes || typeof config.routes !== 'object') {
+      throw new Error('Routes object is required');
+    }
+  }
+
+  /**
+   * Register a route for a specific table and route type
+   * @param {Object} fastify - Fastify instance
+   * @param {string} tableName - Table name
+   * @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) {
+
+    const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema);
+    const routeKey = `${routeDefinition.method}:${routeDefinition.url}`;
+
+    if (this.registeredRoutes.has(routeKey)) {
+      console.log(`Route already registered, skipping: ${routeKey}`);
+      return;
+    }
+    
+    this.registeredRoutes.add(routeKey);
+
+    try {
+      
+      const handler = this.getHandler(routeName);
+      
+      if(routeConfig.security) {
+        routeDefinition.schema.security = [{ bearer: [] }];
+      }
+
+      const filters = Object.entries(schema || {}).reduce((acc, [key, value]) => {
+        if(value.search_type) {
+          acc[key] = value;
+        }
+        return acc;
+      }, {});
+      
+      // Register the route
+      fastify.route({
+        ...routeDefinition,
+        preHandler: async (request, reply, done) => {
+          if(routeConfig.security) {
+            await require(`@root/routes/${workerName}/middlewares`)[routeConfig.security](request, reply);
+          }
+        },
+        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 });
+        }
+      });
+
+    } catch (error) {
+      console.error(`Error in registerRoute for ${tableName}/${routeName}:`, error.message);
+      console.error(`Error details:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Generate route definition
+   * @param {string} tableName - Table name
+   * @param {string} routeName - Route name
+   * @param {Object} routeConfig - Route configuration
+   * @returns {Object} Route definition
+   */
+  generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema) {
+    const baseUrl = `/${fileName}`;
+    primaryKey = primaryKey || 'id';
+
+    const routeDefinitions = {
+      list: {
+        method: 'GET',
+        url: baseUrl,
+        schema: this.generateListSchema(tableName, routeConfig, primaryKey, schema)
+      },
+      get: {
+        method: 'GET',
+        url: `${baseUrl}/:${primaryKey}`,
+        schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema)
+      },
+      create: {
+        method: 'POST',
+        url: baseUrl,
+        schema: this.generateCreateSchema(tableName, routeConfig, primaryKey, schema)
+      },
+      update: {
+        method: 'PUT',
+        url: `${baseUrl}/:${primaryKey}`,
+        schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema)
+      },
+      delete: {
+        method: 'DELETE',
+        url: `${baseUrl}/:${primaryKey}`,
+        schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema)
+      },
+      upload: {
+        method: 'POST',
+        url: `${baseUrl}/:${primaryKey}/upload`,
+        schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema),
+        validatorCompiler: ({ schema }) => {
+          return (data) => {
+            return true;
+          };
+        }
+      }
+    };
+
+    return routeDefinitions[routeName];
+  }
+
+  /**
+   * Generate list schema
+   * @param {string} tableName - Table name
+   * @param {Object} routeConfig - Route configuration
+   * @param {Object} schema - Schema object
+   * @param {string} primaryKey - Primary key
+   * @param {Object} filters - Filters object
+   * @returns {Object} Schema
+   */
+  generateListSchema(tableName, routeConfig, primaryKey, schema) {
+    const itemSchema = this.generateItemSchema(schema, primaryKey);
+
+    return {
+      description: `Get all ${tableName} with pagination and search`,
+      tags: [general.titleCase(tableName)],
+      summary: routeConfig.summary || `List of ${tableName} with pagination and search`,
+      querystring: {
+        type: 'object',
+        properties: {
+          page: { type: 'integer', minimum: 1, default: 1 },
+          limit: { type: 'integer', minimum: 1, maximum: 100, default: 10 },
+          search: { type: 'string' },
+          order: { type: 'string', default: `${primaryKey}:desc` },
+          ...Object.entries(schema).reduce((acc, [key, value]) => {
+            if(value.search_type) {
+              acc[key] = { type: value.type, default: value.default || undefined, enum: value.enum || undefined };
+            }
+            return acc;
+          }, {})
+        }
+      },
+      headers: {
+        type: 'object',
+        properties: {
+          locale: { type: 'string', default: 'en' }
+        }
+      },
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: true },
+            data: {
+              type: 'array',
+              items: itemSchema,
+              additionalProperties: false
+            },
+            pagination: {
+              type: 'object',
+              properties: {
+                page: { type: 'integer', example: 1 },
+                limit: { type: 'integer', example: 10 },
+                total: { type: 'integer', example: 100 },
+                totalPages: { type: 'integer', example: 10 }
+              }
+            }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate get schema
+   * @param {string} tableName - Table name
+   * @param {Object} routeConfig - Route configuration
+   * @returns {Object} Schema
+   */
+  generateGetSchema(tableName, routeConfig, primaryKey, schema) {
+    const itemSchema = this.generateItemSchema(schema, primaryKey);
+    primaryKey = primaryKey || 'id';
+
+    return {
+      description: `Get ${tableName} by ${primaryKey}`,
+      tags: [general.titleCase(tableName)],
+      summary: routeConfig.summary || `Get ${tableName} by ${primaryKey}`,
+      params: {
+        type: 'object',
+        properties: {
+          [primaryKey]: { type: 'integer', minimum: 1 }
+        },
+        required: [primaryKey],
+        additionalProperties: false
+      },
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: true },
+            data: itemSchema
+          }
+        },
+        404: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: false },
+            message: { type: 'string' }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate create schema
+   * @param {string} tableName - Table name
+   * @param {Object} routeConfig - Route configuration
+   * @returns {Object} Schema
+   */
+  generateCreateSchema(tableName, routeConfig, primaryKey, schema) {
+    const bodySchema = this.generateBodySchema(schema, false, primaryKey);
+
+    return {
+      description: `Create new ${tableName}`,
+      tags: [general.titleCase(tableName)],
+      summary: routeConfig.summary || `Create new ${tableName}`,
+      body: bodySchema,
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: true },
+            data: this.generateItemSchema(schema, primaryKey)
+          },
+          additionalProperties: false
+        },
+        400: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: false },
+            message: { type: 'string' }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate update schema
+   * @param {string} tableName - Table name
+   * @param {Object} routeConfig - Route configuration
+   * @returns {Object} Schema
+   */
+  generateUpdateSchema(tableName, routeConfig, primaryKey, schema) {
+    const bodySchema = this.generateBodySchema(schema, true, primaryKey, 'updatable');
+    
+    return {
+      description: `Update ${tableName} by ID`,
+      tags: [general.titleCase(tableName)],
+      summary: routeConfig.summary || `Update ${tableName} by ${primaryKey}`,
+      params: {
+        type: 'object',
+        properties: {
+          [primaryKey]: { type: 'integer', minimum: 1 }
+        },
+        required: [primaryKey],
+        additionalProperties: false
+      },
+      body: bodySchema,
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: true },
+            data: this.generateItemSchema(schema, primaryKey)
+          },
+          additionalProperties: false
+        },
+        404: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: false },
+            message: { type: 'string' }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate delete schema
+   * @param {string} tableName - Table name
+   * @param {Object} routeConfig - Route configuration
+   * @returns {Object} Schema
+   */
+  generateDeleteSchema(tableName, routeConfig, primaryKey, schema) {
+    return {
+      description: `Delete ${tableName} by ID`,
+      tags: [general.titleCase(tableName)],
+      summary: routeConfig.summary || `Delete ${tableName} by ${primaryKey}`,
+      params: {
+        type: 'object',
+        properties: {
+          [primaryKey]: { type: 'integer', minimum: 1 }
+        },
+        required: [primaryKey],
+        additionalProperties: false
+      },
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: true },
+            data: this.generateItemSchema(schema, primaryKey)
+          },
+          additionalProperties: false
+        },
+        404: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: false },
+            message: { type: 'string' }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate upload schema
+   * @param {string} tableName - Table name
+   * @param {Object} routeConfig - Route configuration
+   * @returns {Object} Schema
+   */
+  generateUploadSchema(tableName, routeConfig, primaryKey, schema) {
+    const uploadField = routeConfig.upload_field || 'file';
+    return {
+      description: `Upload file for ${tableName} by ${primaryKey}`,
+      tags: [general.titleCase(tableName)],
+      summary: routeConfig.summary || `Upload file for ${tableName} by ${primaryKey}`,
+      params: {
+        type: 'object',
+        properties: {
+          [primaryKey]: { type: 'integer', minimum: 1 }
+        },
+        required: [primaryKey],
+        additionalProperties: false
+      },
+      consumes: ['multipart/form-data'],
+      body: {
+        type: 'object',
+        properties: {
+          [uploadField]: { type: 'string', format: 'binary' }
+        },
+        additionalProperties: false
+      },
+      response: {
+        200: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: true },
+            data: this.generateItemSchema(schema, primaryKey)
+          },
+          additionalProperties: false
+        },
+        404: {
+          type: 'object',
+          properties: {
+            status: { type: 'boolean', default: false },
+            message: { type: 'string' }
+          }
+        }
+      }
+    };
+  }
+
+  /**
+   * Generate item schema for responses
+   * @param {Object} itemSchema - Item schema from config
+   * @returns {Object} Item schema
+   */
+  generateItemSchema(schema, primaryKey) {
+    if (!schema) {
+      return { type: 'object' };
+    }
+
+    const withoutReferences = { ...schema };
+
+    if(Object.entries(withoutReferences).length > 0) {
+      for(const [key, value] of Object.entries(withoutReferences)) {
+        const withoutReferencesValue = { ...value };
+        if(withoutReferencesValue.listable !== false) {
+          if(Object.entries(withoutReferencesValue).length > 0) {
+            for(const [key2,] of Object.entries(withoutReferencesValue)) {
+              if(this.deleteKeys.includes(key2)) {
+                delete withoutReferencesValue[key2];
+              }
+            }
+          }
+          withoutReferences[key] = value;
+        } else {
+          delete withoutReferences[key];
+        }
+      }
+    }
+
+    return {
+      type: 'object',
+      properties: withoutReferences,
+      additionalProperties: false
+    };
+  }
+
+  /**
+   * Generate body schema for create/update
+   * @param {Object} itemSchema - Item schema from config
+   * @param {boolean} isUpdate - Whether this is for update (optional fields)
+   * @returns {Object} Body schema
+   */
+  generateBodySchema(schema, isUpdate = false, primaryKey = 'id', type = 'creatable') {
+    if (!schema) {
+      return { type: 'object' };
+    }
+
+    // Filter out auto-generated fields for create/update
+    const filteredSchema = { ...schema };
+    delete filteredSchema[primaryKey];
+    delete filteredSchema.created_at;
+    delete filteredSchema.updated_at;
+
+    const requiredKeys = Object.keys(filteredSchema).filter(key => type == 'creatable' ? filteredSchema[key].create_required : filteredSchema[key].updatable_required);
+    // delete required keys in objects
+    const props = Object.entries(filteredSchema).reduce((acc, [key, value]) => {
+      if (typeof value === 'object') {
+        const withoutReferences = Object.assign({}, value);
+        if(withoutReferences[type]) {
+          if(Object.entries(withoutReferences).length > 0) {
+            for(const [key2,] of Object.entries(withoutReferences)) {
+              if(this.deleteKeys.includes(key2)) {
+                delete withoutReferences[key2];
+              }
+            }
+          }
+
+          if(type == 'updatable') {
+            delete withoutReferences.default
+          }
+
+          acc[key] = withoutReferences;
+        }
+      }
+      return acc;
+    }, {});
+
+    return {
+      type: 'object',
+      required: requiredKeys,
+      properties: props,
+      additionalProperties: false,
+      ...(isUpdate ? { minProperties: 1 } : {})
+    };
+  }
+
+  /**
+   * Get handler function for route type
+   * @param {string} routeName - Route name
+   * @returns {Function} Handler function
+   */
+  getHandler(routeName) {
+
+    const handlerMap = {
+      'list': handlers.getAll,
+      'get': handlers.getById,
+      'create': handlers.create,
+      'update': handlers.update,
+      'delete': handlers.delete,
+      'upload': handlers.upload
+    };
+
+    return handlerMap[routeName];
+  }
+}
+
+module.exports = JsonRouteLoader;