@ecopex/ecopex-framework 1.0.0 → 1.0.2

package/routes/auto/handler.js

@@ -1,635 +0,0 @@
-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

@@ -1,28 +0,0 @@
-{
-    "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

@@ -1,26 +0,0 @@
-{
-    "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"
-        }
-    ]
-}