@ecopex/ecopex-framework 1.0.0

package/routes/auto/handler.js

@@ -0,0 +1,635 @@
+const db = require('@root/libraries/knex');
+const BCRYPT = require('@root/libraries/bcrypt');
+const bcrypt = new BCRYPT();
+const i18n = require('@root/utils/i18n');
+const { uploadFile } = require('@root/libraries/upload');
+const { randomChars } = require('@root/libraries/controls');
+const { get_all, get_by_primary_key, create_item, update_item, delete_item } = require('@root/stores');
+
+/**
+ * Get all records with pagination, search, and join tables
+ * @param {Object} request - The request object
+ * @param {Object} reply - The reply object
+ * @param {Object} routeOptions - The route options
+ * @returns {Promise<Object>} - The response object
+ */
+async function getAll(request, reply, routeOptions = {}) {
+
+  if(routeOptions.store) {
+    return get_all(routeOptions.store, request.query, reply, routeOptions);
+  }
+
+  try {
+    const { page = 1, limit = 10, search, order } = request.query;
+    const offset = (page - 1) * limit;
+    const tableName = routeOptions.tableName || 'users';
+    const routeConfig = routeOptions.routeConfig || {};
+    const primaryKey = routeOptions.primaryKey || 'id';
+    const filters = routeOptions.filters || {};
+    const splitOrder = order.split(':');
+    const orderBy = `${tableName}.${(splitOrder[0] || primaryKey)}`;
+    const orderDirection = splitOrder[1] || 'desc';
+
+    let query = db(tableName + ' as ' + tableName).select(`${tableName}.*`);
+
+    // Apply search filter if provided
+    if (search && routeConfig.searchable_fields) {
+      query = query.where(function() {
+        routeConfig.searchable_fields.forEach((field, index) => {
+          if (index === 0) {
+            this.where(tableName + '.' + field, 'like', `%${search}%`);
+          } else {
+            this.orWhere(tableName + '.' + field, 'like', `%${search}%`);
+          }
+        });
+      });
+    }
+
+    if(routeConfig.owned) {
+      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(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.options({ nestTables: true, rowMode: 'array' });
+    }
+
+    if(filters) {
+      for(let i = 0; i < Object.entries(filters).length; i++) {
+        const filter = Object.entries(filters)[i];
+        if(request.query[filter[0]] !== undefined) {
+          if(filter[1].search_type == 'like') {
+            query.where(tableName + '.' + filter[0], 'like', `%${request.query[filter[0]]}%`);
+          } else if(filter[1].search_type == 'equal') {
+            query.where(tableName + '.' + filter[0], request.query[filter[0]]);
+          } else if(filter[1].search_type == 'in') {
+            query.whereIn(tableName + '.' + filter[0], request.query[filter[0]]);
+          } else if(filter[1].search_type == 'not_in') {
+            query.whereNotIn(tableName + '.' + filter[0], request.query[filter[0]]);
+          } else if(filter[1].search_type == 'between') {
+            query.whereBetween(tableName + '.' + filter[0], request.query[filter[0]]);
+          } else if(filter[1].search_type == 'not_between') {
+            query.whereNotBetween(tableName + '.' + filter[0], request.query[filter[0]]);
+          }
+        }
+      }
+    }
+    
+    // Apply pagination
+    const items = await query
+      .orderBy(orderBy, orderDirection)
+      .limit(limit)
+      .offset(offset);
+
+    // Get total count for pagination
+    const totalQuery = query.clone();
+    totalQuery.clearSelect();
+    totalQuery.count(`${tableName}.${primaryKey} as count`);
+    totalQuery.options({ nestTables: false });
+    totalQuery.clearOrder();
+    totalQuery.clear('limit');
+    
+    
+    const [{ count }] = await totalQuery;
+    
+    const total = parseInt(count);
+
+    const rows = structureRows(items, tableName, routeConfig.join_tables)
+
+    // Process join tables if configured
+    const processedItems = await processJoinTables(rows, routeConfig.join_tables);
+
+    // console.log(processedItems);
+    
+    
+    const totalPages = Math.ceil(total / limit);
+
+    return reply.send({
+      status: true,
+      data: processedItems,
+      pagination: {
+        page: parseInt(page),
+        limit: parseInt(limit),
+        total,
+        totalPages
+      }
+    });
+  } catch (error) {
+    console.error('Error getting records:', error);
+    return reply.status(500).send({
+      status: false,
+      message: request.t('messages.internal_server_error')
+    });
+  }
+}
+
+/**
+ * Get record by ID with join tables
+ * @param {Object} request - The request object
+ * @param {Object} reply - The reply object
+ * @param {Object} routeOptions - The route options
+ * @returns {Promise<Object>} - The response object
+ */
+async function getById(request, reply, routeOptions = {}) {
+
+  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(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];
+        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.options({ nestTables: true, rowMode: 'array' });
+    }
+    
+    const item_data = await item_query.first();
+    console.log(item_data);
+    
+    let item = {}
+    
+
+    if(routeConfig.join_tables) {
+      item = {
+        ...item_data[tableName],
+      }
+      const join_one_to_one = Object.entries(routeConfig.join_tables).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];
+          item[join_table[0]] = item_data[join_table[0]];
+        }
+      }
+    } else {
+      item = item_data;
+    }
+    
+    if (!item) {
+      return reply.status(404).send({
+        status: false,
+        message: request.t('messages.record_not_found')
+      });
+    }
+
+    // Process join tables if configured
+    const processedItem = await processJoinTables([item], routeConfig.join_tables);
+    const result = processedItem[0];
+
+    return reply.send({
+      status: true,
+      data: 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')
+    });
+  }
+}
+
+/**
+ * Create new record
+ * @param {Object} request - The request object
+ * @param {Object} reply - The reply object
+ * @param {Object} routeOptions - The route options
+ * @returns {Promise<Object>} - The response object
+ */
+async function create(request, reply, routeOptions = {}) {
+
+  if(routeOptions.store) {
+    return create_item(routeOptions.store, request.body, 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
+    let data = request.body;
+    
+    if (schema) {
+      const payloadFields = Object.entries(schema).filter(n => n[1].creatable || n[1].generatable);
+      data = {};
+      
+      for (const field of payloadFields) {
+        if (request.body[field[0]] !== undefined || schema[field[0]].generatable) {
+          if (schema[field[0]].crypted) {
+            data[field[0]] = await bcrypt.hash(request.body[field[0]]);
+          } else if(schema[field[0]].generatable) {
+            data[field[0]] = await generateRandomString(typeof schema[field[0]].generatable === 'string' ? request.body[schema[field[0]].generatable] : null, field[0], tableName);
+          } else {
+            data[field[0]] = request.body[field[0]];
+          }
+        }
+      }
+    }
+
+    try {
+      const [id] = await db(tableName)
+        .insert({
+          ...data,
+          created_at: new Date(),
+          updated_at: new Date()
+        });
+
+      const item = await db(tableName)
+        .where(primaryKey, id)
+        .first();
+
+      return reply.send({
+        status: true,
+        data: item
+      });
+    } catch (error) {
+      if(process.env.NODE_ENV === 'development') {
+        console.log(error.message);
+      }
+      if(error.sqlMessage) {
+        return sqlErrorHandler(error, request, reply);
+      } else {
+        return reply.status(500).send({
+          status: false,
+          message: request.t('messages.internal_server_error')
+        });
+      }
+    }
+  } catch (error) {
+    console.error('Error creating record:', error);
+    return reply.status(500).send({
+      status: false,
+      message: request.t('messages.internal_server_error')
+    });
+  }
+}
+
+/**
+ * Update record by ID
+ * @param {Object} request - The request object
+ * @param {Object} reply - The reply object
+ * @param {Object} routeOptions - The route options
+ * @returns {Promise<Object>} - The response object
+ */
+async function update(request, reply, routeOptions = {}) {
+
+  if(routeOptions.store) {
+    return update_item(routeOptions.store, request.params[routeOptions.primaryKey], request.body, 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
+    let data = request.body;
+    if (schema) {
+      const payloadFields = Object.entries(schema).filter(n => n[1].updatable || n[1].generatable);
+      data = {};
+      
+      for (const field of payloadFields) {
+        if (request.body[field[0]] !== undefined) {
+          if (schema[field[0]].crypted) {
+            data[field[0]] = await bcrypt.hash(request.body[field[0]]);
+          } else if(schema[field[0]].unique) {
+            const check_unique = await checkUnique(request.body[field[0]], field[0], tableName);
+            if(check_unique) {
+              return reply.status(400).send({
+                status: false,
+                message: request.t('messages.unique_constraint_violation')
+              });
+            }
+            data[field[0]] = request.body[field[0]];
+          }else {
+            data[field[0]] = request.body[field[0]];
+          }
+        }
+      }
+    }
+
+
+    // Check if record exists
+    const existingItem = await db(tableName)
+      .where(request.params)
+      .first();
+
+    if (!existingItem) {
+      return reply.status(404).send({
+        status: false,
+        message: request.t('messages.record_not_found')
+      });
+    }
+
+    if(routeConfig.via && Object.entries(routeConfig.via).length > 0) {
+      for(let i = 0; i < Object.entries(routeConfig.via).length; i++) {
+        const via = Object.entries(routeConfig.via)[i];
+        data[via[0]] = via[1];
+      }
+    }
+
+    await db(tableName)
+      .where(request.params)
+      .update({
+        ...data,
+        updated_at: new Date()
+      })
+
+    const updatedItem = await db(tableName)
+      .where(request.params)
+      .first();
+
+    return reply.send({
+      status: true,
+      data: updatedItem
+    });
+  } catch (error) {
+    console.error('Error updating record:', error);
+    return reply.status(500).send({
+      status: false,
+      message: request.t('messages.internal_server_error')
+    });
+  }
+}
+
+/**
+ * Upload file for record by ID
+ * @param {Object} request - The request object
+ * @param {Object} reply - The reply object
+ * @param {Object} routeOptions - The route options
+ * @returns {Promise<Object>} - The response object
+ */
+async function upload(request, reply, routeOptions = {}) {
+
+  if(routeOptions.store) {
+    return upload_item(routeOptions.store, request.params[routeOptions.primaryKey], request.body[routeOptions.upload_field], 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(tableName)
+      .where(primaryKey, id)
+      .first();
+
+    if (!existingItem) {
+      return reply.status(404).send({
+        status: false,
+        message: request.t('messages.record_not_found')
+      });
+    }
+
+    const uploadResult = await uploadFile(request.body[routeConfig.upload_field], id, tableName);
+    if(!uploadResult.status) {
+      return reply.status(500).send({
+        status: false,
+        message: request.t('messages.internal_server_error')
+      });
+    }
+
+    await db(tableName)
+      .where(primaryKey, id)
+      .update({
+        [routeConfig.upload_field]: uploadResult.file.fileUrl
+      });
+
+    return reply.send({
+      status: true,
+      data: {
+        [routeConfig.upload_field]: uploadResult.file.fileUrl
+      }
+    });
+  } catch (error) {
+    console.error('Error uploading file:', error);
+    return reply.status(500).send({
+      status: false,
+      message: request.t('messages.internal_server_error')
+    });
+  }
+}
+
+/**
+ * Delete record by ID
+ * @param {Object} request - The request object
+ * @param {Object} reply - The reply object
+ * @param {Object} routeOptions - The route options
+ * @returns {Promise<Object>} - The response object
+ */
+async function deleteRecord(request, reply, routeOptions = {}) {
+
+  if(routeOptions.store) {
+    return delete_item(routeOptions.store, request.params[routeOptions.primaryKey], reply, routeOptions);
+  }
+
+  try {
+    const { id } = request.params;
+    const tableName = routeOptions.tableName || 'users';
+
+    // Check if record exists
+    const existingItem = await db(tableName)
+      .where('id', id)
+      .first();
+
+    if (!existingItem) {
+      return reply.status(404).send({
+        status: false,
+        message: request.t('messages.record_not_found')
+      });
+    }
+
+    await db(tableName)
+      .where('id', id)
+      .del();
+
+    return reply.send({
+      status: true,
+      data: existingItem
+    });
+  } catch (error) {
+    console.error('Error deleting record:', error);
+    return reply.status(500).send({
+      status: false,
+      message: request.t('messages.internal_server_error')
+    });
+  }
+}
+
+/**
+ * Generate random string
+ * @param {string} from_string - The string to generate random string from
+ * @param {string} field_name - The field name to check unique
+ * @param {string} tableName - The table name to check unique
+ * @returns {Promise<string>} - The random string
+ */
+const generateRandomString = async (from_string = null, field_name = null, tableName = null) => {
+  let random_string = '';
+
+  if(from_string.includes('@')) {
+    random_string = from_string.split('@')[0];
+  } else {
+    random_string = randomChars(10);
+  }
+
+  const existing_item = await checkUnique(random_string, field_name, tableName);
+
+  if(existing_item) {
+    return generateRandomString(from_string, field_name, tableName);
+  }
+  return random_string;
+}
+
+/**
+ * Check if the value is unique
+ * @param {string} value - The value to check unique
+ * @param {string} field_name - The field name to check unique
+ * @param {string} tableName - The table name to check unique
+ * @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();
+  return existing_item ? true : false;
+}
+
+/**
+ * Handle SQL error
+ * @param {Object} error - The error object
+ * @param {Object} request - The request object
+ * @param {Object} reply - The reply object
+ * @returns {Object} - The response object
+ */
+const sqlErrorHandler = (error, request, reply) => {
+  return reply.status(500).send({
+    status: false,
+    message: i18n.t('sql.' + error.code.toLowerCase(), request.headers.locale || 'en', {...request.body, ...request.query, ...request.params})
+  });
+}
+
+/**
+ * Structure rows
+ * @param {Array} items - The items to structure
+ * @param {string} tableName - The table name to structure
+ * @param {Object} joinTables - The join tables to structure
+ * @returns {Array} - The structured rows
+ */
+const structureRows = (items, tableName, joinTables) => {
+
+  if(!joinTables) {
+    return items;
+  }
+
+  return items.map(item => {
+    const other_items = Object.entries(item).filter(n => n[0] !== tableName).reduce((acc, curr) => {
+      // check if all items null then return null
+      if(Object.values(curr[1]).every(n => n === null)) {
+        acc[curr[0]] = null;
+      } else {
+        acc[curr[0]] = curr[1];
+      }
+      
+      return acc;
+    }, {});
+    
+    return {
+      ...item[tableName],
+      ...other_items
+    }
+  })
+}
+
+/**
+ * Process join tables
+ * @param {Array} items - The items to process join tables
+ * @param {Object} joinTables - The join tables to process
+ * @returns {Array} - The processed items
+ */
+const processJoinTables = async (items, joinTables) => {
+
+  if(!joinTables) {
+    return items;
+  }
+
+  const length_of_one_to_many = Object.entries(joinTables).filter(n => n[1].type === 'one-to-many');
+  if(length_of_one_to_many.length > 0) {
+    for(let i = 0; i < length_of_one_to_many.length; i++) {
+      const joinTable = length_of_one_to_many[i][1];
+      const joinTableKey = length_of_one_to_many[i][0];
+      
+      const personal_ids = items.map(item => item[joinTable.primary_key]);
+      
+      const personal_items = 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));
+      }
+
+      if(joinTable.join_table) {
+        personal_items.join(joinTable.join_table, joinTable.table + '.' + joinTable.join_key, '=', joinTable.join_table + '.' + joinTable.join_value);
+        personal_items.options({ nestTables: true, rowMode: 'array' });
+      }
+
+      const personal_items_data = await personal_items;
+
+      if(joinTable.join_table) {
+        items.forEach(item => {
+          item[joinTableKey] = personal_items_data.filter(n => n[joinTable.table][joinTable.foreign_key] === item[joinTable.primary_key]);
+        });
+      } else {
+        items.forEach(item => {
+          item[joinTableKey] = personal_items_data.filter(n => n[joinTable.foreign_key] === item[joinTable.primary_key]);
+        });
+      }
+    }
+
+    return items
+  } else {
+    return items;
+  }
+}
+
+module.exports = {
+  getAll,
+  getById,
+  create,
+  update,
+  delete: deleteRecord,
+  upload,
+  processJoinTables
+};

package/routes/common/auto/countries.json

@@ -0,0 +1,28 @@
+{
+    "table": "countries",
+    "primary_key": "country_id",
+    "schema": {
+        "country_id": { "type": "integer", "example": 1 },
+        "name": { "type": "string", "default": "", "example": "United States" },
+        "code": { "type": "string", "default": "", "search_type": "equal", "example": "US" },
+        "iso_code": { "type": "string", "default": "", "search_type": "equal", "example": "USA" },
+        "phone_code": { "type": "string", "default": "", "example": "+1" },
+        "flag": { "type": "string", "default": "", "example": "🇺🇸" }
+    },
+    "store": "countries",
+    "routes": [
+        {
+            "action": "list",
+            "method": "GET",
+            "path": "/countries",
+            "searchable_fields": ["name", "code", "iso_code", "phone_code", "flag"],
+            "pagination": true,
+            "additionalProperties": false
+        },
+        {
+            "action": "get",
+            "method": "GET",
+            "path": "/countries/:country_id"
+        }
+    ]
+}

package/routes/common/auto/currencies.json

@@ -0,0 +1,26 @@
+{
+    "table": "currencies",
+    "primary_key": "currency_id",
+    "store": "currencies",
+    "schema": {
+        "currency_id": { "type": "integer", "example": 1 },
+        "code": { "type": "string", "default": "", "example": "USD" },
+        "symbol": { "type": "string", "default": "", "example": "$" },
+        "name": { "type": "string", "default": "", "example": "United States Dollar" }
+    },
+    "routes": [
+        {
+            "action": "list",
+            "method": "GET",
+            "path": "/currencies",
+            "searchable_fields": ["code", "name"],
+            "pagination": true,
+            "additionalProperties": false
+        },
+        {
+            "action": "get",
+            "method": "GET",
+            "path": "/currencies/:currency_id"
+        }
+    ]
+}