@ecopex/ecopex-framework 1.0.13 → 1.0.15

package/config/swagger.js

@@ -17,25 +17,25 @@ module.exports = {
         produces: ['application/json'],
         components: {
             securitySchemes: {
-            bearer: {
-                type: 'http',
-                scheme: 'bearer',
-                bearerFormat: 'JWT',
-                description: 'Enter the token with the `Bearer: ` prefix, e.g. "Bearer abcde12345".'
-            },
-            apiKey: {
-                type: 'apiKey',
-                in: 'header',
-                name: 'apiKey',
-                description: 'Enter token e.g. "abcde1-234533-333312-2222".'
-            }
+                bearer: {
+                    type: 'http',
+                    scheme: 'bearer',
+                    bearerFormat: 'JWT',
+                    description: 'Enter the token with the `Bearer: ` prefix, e.g. "Bearer abcde12345".'
+                },
+                apiKey: {
+                    type: 'apiKey',
+                    in: 'header',
+                    name: 'apiKey',
+                    description: 'Enter token e.g. "abcde1-234533-333312-2222".'
+                }
             },
             headers: {
-            description: 'Headers',
-            scheme: {
-                type: 'object',
-                properties: {}
-            }
+                description: 'Headers',
+                scheme: {
+                    type: 'object',
+                    properties: {}
+                }
             }
         }
         }

package/index.js

@@ -4,11 +4,13 @@ const JWT = require('./libraries/jwt');
 const BCRYPT = require('./libraries/bcrypt');
 const date = require('./libraries/date');
 const twofactor = require('./libraries/2fa');
+const i18n = require('./utils/i18n');
 
 const jwt = new JWT();
 const bcrypt = new BCRYPT();
 
 const start = async (config) => {
+    i18n.setConfig(config);
     await knex.initialize(config);
     await fastifyStart(config);
 }
@@ -19,5 +21,6 @@ module.exports = {
     date: date,
     jwt: jwt,
     bcrypt: bcrypt,
-    twofactor: twofactor
+    twofactor: twofactor,
+    i18n: i18n
 }

package/knexfile.js

@@ -1 +1,47 @@
-module.exports = require('./config/database');
+const config = require('../../../config');
+
+const services = Object.entries(config).filter(([, value]) => value.database).map(([key, ]) => key);
+
+let readline = require('readline-sync');
+let service = readline.question("For which service do you want to migrate? (" + services.join(', ') + ') default:' + services[0] + ' => ');
+service = service || services[0];
+
+if(!services.includes(service)) {
+    console.log('Service not found');
+    process.exit(1);
+}
+
+module.exports = {
+    development: {
+        client: 'mysql2',
+        connection: {
+            host: config[service].database.host,
+            port: config[service].database.port,
+            user: config[service].database.user,
+            password: config[service].database.password,
+            database: config[service].database.database
+        },
+        migrations: {
+            directory: '../../../database/' + service + '/migrations'
+        },
+        seeds: {
+            directory: '../../../database/' + service + '/seeds'
+        }
+    },
+    production: {
+        client: 'mysql2',
+        connection: {
+            host: config[service].database.host,
+            port: config[service].database.port,
+            user: config[service].database.user,
+            password: config[service].database.password,
+            database: config[service].database.database
+        },
+        migrations: {
+            directory: '../../../database/' + service + '/migrations'
+        },
+        seeds: {
+            directory: '../../../database/' + service + '/seeds'
+        }
+    }
+};

package/libraries/fastify.js

@@ -21,7 +21,8 @@ async function registerPlugins(config) {
     // CORS plugin
     await fastifyInstance.register(require('@fastify/cors'), {
         origin: config.cors || '*',
-        credentials: true
+        methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+        allowedHeaders: ['Content-Type', 'Authorization', 'Accept', 'locale', 'timezone', 'device']
     });
 
     // Swagger documentation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecopex/ecopex-framework",
-  "version": "1.0.13",
+  "version": "1.0.15",
   "description": "Javascript Framework for API and Admin Panel",
   "main": "index.js",
   "scripts": {
@@ -48,7 +48,8 @@
     "pm2": "^5.3.0",
     "qrcode": "^1.5.4",
     "slugify": "^1.6.6",
-    "uuid": "^9.0.1"
+    "uuid": "^9.0.1",
+    "readline-sync": "^1.4.10"
   },
   "devDependencies": {
     "nodemon": "^3.0.1",

package/routes/auto/handler.js

@@ -1,10 +1,11 @@
 const knex = require('../../libraries/knex');
 const BCRYPT = require('../../libraries/bcrypt');
+const returnSlug = require('../../libraries/slug');
 const bcrypt = new BCRYPT();
 const i18n = require('../../utils/i18n');
 const { uploadFile } = require('../../libraries/upload');
 const { randomChars } = require('../../libraries/controls');
-const { get_all, get_by_primary_key, create_item, update_item, delete_item } = require('../../stores');
+const { get_all, get_by_primary_key, create_item, update_item, delete_item, stores } = require('../../stores');
 const { config } = require('../../stores/config');
 /**
  * Get all records with pagination, search, and join tables
@@ -25,8 +26,9 @@ async function getAll(request, reply, routeOptions = {}) {
     const tableName = routeOptions.tableName || 'users';
     const routeConfig = routeOptions.routeConfig || {};
     const primaryKey = routeOptions.primaryKey || 'id';
-    const filters = routeOptions.filters || {};
-    const joinTables = routeOptions.joinTables || {};
+    const filters = routeOptions.filters || false;
+    const owned = routeOptions.owned || false;
+    const joinTables = routeOptions.joinTables || false;
     const splitOrder = order.split(':');
     const orderBy = `${tableName}.${(splitOrder[0] || primaryKey)}`;
     const orderDirection = splitOrder[1] || 'desc';
@@ -46,18 +48,51 @@ async function getAll(request, reply, routeOptions = {}) {
       });
     }
 
-    if(routeConfig.owned) {
-      query.where(routeConfig.owned, request.user?.id || 0);
-      query.where(routeConfig.owned_type, request.user?.type || 'user');
+    if(owned) {
+      for(let i = 0; i < Object.entries(owned).length; i++) {
+        const owned_field = Object.entries(owned)[i];
+        if(owned_field[1].from == 'request') {
+          query.where(tableName + '.' + owned_field[0], (owned_field[1].operator || '='), getText(request, owned_field[1].path));
+        } else {
+          query.where(tableName + '.' + owned_field[0], (owned_field[1].operator || '='), owned_field[1].value);
+        }
+      }
+    }
+
+    if(routeConfig.conditions) {
+      for(let i = 0; i < Object.entries(routeConfig.conditions).length; i++) {
+        const condition = Object.entries(routeConfig.conditions)[i];
+        if(condition[1].value_type == 'request') {
+          query.where(condition[0], (condition[1].operator || '='), getText(request, condition[1].value));
+        } else {
+          query.where(condition[0], (condition[1].operator || '='), condition[1].value);
+        }
+      }
     }
     
     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}`);
+        if(joinTable.type == 'one-to-one' || (joinTable.type == 'one-to-many' && joinTable.localized)) {
+          if(joinTable.localized) {
+            const stored_languages = stores.languages || false;
+
+            if(stored_languages) {
+              const find_language = [...stored_languages.data.values()].find(n => n.code === request.locale);
+              
+              if(find_language) {
+                if(joinTable.extra_where) {
+                  joinTable.extra_where += ` AND ${tableKey}.language_id = ${find_language.language_id}`;
+                } else {
+                  joinTable.extra_where = `${tableKey}.language_id = ${find_language.language_id}`;
+                }
+              }
+            } 
+          }
+          
+          if(joinTable.extra_where && joinTable.extra_where != '') {
+            query.leftJoin(joinTable.table + ' as ' + tableKey, knex.connection.db.raw(`${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}`);
           }
@@ -150,9 +185,21 @@ async function getById(request, reply, routeOptions = {}, inner = false) {
   try {
     const tableName = routeOptions.tableName || 'users';
     const joinTables = routeOptions.joinTables || {};
+    const owned = routeOptions.owned || false;
     const item_query = knex.connection.db(tableName)
       .select(`${tableName}.*`)
       .where(request.params);
+
+    if(owned) {
+      for(let i = 0; i < Object.entries(owned).length; i++) {
+        const owned_field = Object.entries(owned)[i];
+        if(owned_field[1].from == 'request') {
+          item_query.where(tableName + '.' + owned_field[0], (owned_field[1].operator || '='), getText(request, owned_field[1].path));
+        } else {
+          item_query.where(tableName + '.' + owned_field[0], (owned_field[1].operator || '='), owned_field[1].value);
+        }
+      }
+    }
     
     if(joinTables) {
       for(let i = 0; i < Object.values(joinTables).length; i++) {
@@ -173,8 +220,21 @@ async function getById(request, reply, routeOptions = {}, inner = false) {
     
     const item_data = await item_query.first();
     
-    let item = {}
+    if(!item_data) {
+      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')
+        };
+      }
+    }
     
+    let item = {}
 
     if(joinTables) {
       item = {
@@ -187,6 +247,14 @@ async function getById(request, reply, routeOptions = {}, inner = false) {
           item[join_table[0]] = item_data[join_table[0]];
         }
       }
+      const join_one_to_many = Object.entries(joinTables).filter(n => n[1].type === 'one-to-many');
+      if(join_one_to_many.length > 0) {
+        for(let i = 0; i < join_one_to_many.length; i++) {
+          const join_table = join_one_to_many[i];
+          const join_table_data = await knex.connection.db(join_table[1].table).where(join_table[1].foreign_key, item_data[tableName][join_table[1].primary_key]);
+          item[join_table[0]] = join_table_data;
+        }
+      }
     } else {
       item = item_data;
     }
@@ -242,34 +310,61 @@ async function getById(request, reply, routeOptions = {}, inner = false) {
  */
 async function create(request, reply, routeOptions = {}) {
 
+  const tableName = routeOptions.tableName || 'users';
+  const primaryKey = routeOptions.primaryKey || 'id';
+  const owned = routeOptions.owned || false;
+  const schema = routeOptions.schema || {};
+
+  if(routeOptions.unique && routeOptions.unique.length > 0) {
+    const extra_where = routeOptions.unique.map(n => `${tableName}.${n} = ${request.body[n]}`).join(' AND ');
+    const check_unique = await checkUnique(null, null, tableName, extra_where);
+    if(check_unique) {
+      return reply.status(400).send({
+        status: false,
+        message: request.t('messages.unique_constraint_violation')
+      });
+    }
+  }
+  
   if(routeOptions.store) {
     return create_item(routeOptions.store, request.body, reply, routeOptions);
   }
 
   try {
-    const tableName = routeOptions.tableName || 'users';
-    const primaryKey = routeOptions.primaryKey || 'id';
-    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);
+      const payloadFields = Object.entries(schema).filter(n => n[1].creatable || n[1].generatable || n[1].slug);
       data = {};
       
       for (const field of payloadFields) {
-        if (request.body[field[0]] !== undefined || schema[field[0]].generatable) {
+        if (request.body[field[0]] !== undefined || schema[field[0]].generatable || schema[field[0]].slug) {
           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 if(schema[field[0]].slug) {
+            const extra_where = schema[field[0]].slug.unique.map(n => `${tableName}.${n} = ${request.body[n]}`).join(' AND ');
+            data[field[0]] = await generateSlug(request.body[schema[field[0]].slug.from], field[0], tableName, extra_where, schema[field[0]].slug.random_chars || 5);
           } else {
             data[field[0]] = request.body[field[0]];
           }
         }
       }
     }
+
+    if(owned) {
+      for(let i = 0; i < Object.entries(owned).length; i++) {
+        const owned_field = Object.entries(owned)[i];
+        if(owned_field[1].from == 'request') {
+          data[owned_field[0]] = getText(request, owned_field[1].path);
+        } else {
+          data[owned_field[0]] = owned_field[1].value;
+        }
+      }
+    }
     
     try {
       const [id] = await knex.connection.db(tableName)
@@ -520,6 +615,19 @@ const generateRandomString = async (from_string = null, field_name = null, table
   return random_string;
 }
 
+const generateSlug = async (from_string = null, field_name = null, tableName = null, extra_where = null, random_chars = 5) => {
+  let slug = returnSlug(from_string);
+
+  const existing_item = await checkUnique(slug, field_name, tableName, extra_where);
+
+  if(existing_item) {
+    slug = returnSlug(from_string + '-' + randomChars(random_chars));
+    return generateSlug(slug, field_name, tableName, extra_where, random_chars);
+  }
+
+  return slug;
+}
+
 /**
  * Check if the value is unique
  * @param {string} value - The value to check unique
@@ -527,9 +635,16 @@ const generateRandomString = async (from_string = null, field_name = null, table
  * @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 knex.connection.db(tableName).select(field_name).where(field_name, value).first();
-  return existing_item ? true : false;
+const checkUnique = async (value = null, field_name = null, tableName = null, extra_where = null) => {
+  let query = knex.connection.db(tableName).select(field_name);
+  if(value && field_name) {
+    query.where(field_name, value);
+  }
+  if(extra_where) {
+    query.where(knex.connection.db.raw(extra_where));
+  }
+  const existing_item = await query;
+  return existing_item.length > 0 ? true : false;
 }
 
 /**
@@ -590,7 +705,7 @@ const processJoinTables = async (items, joinTables) => {
     return items;
   }
 
-  const length_of_one_to_many = Object.entries(joinTables).filter(n => n[1].type === 'one-to-many');
+  const length_of_one_to_many = Object.entries(joinTables).filter(n => n[1].type === 'one-to-many' && !n[1].localized);
   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];
@@ -601,7 +716,7 @@ const processJoinTables = async (items, joinTables) => {
       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));
+        personal_items.where(knex.connection.db.raw(joinTable.table + '.' + joinTable.extra_where));
       }
 
       if(joinTable.join_table) {
@@ -628,6 +743,17 @@ const processJoinTables = async (items, joinTables) => {
   }
 }
 
+const getText = (row, path) => {
+    const keys = path.split('.')
+    let value = row
+
+    for (const key of keys) {
+        value = value[key] || false
+    }
+
+    return value
+}
+
 module.exports = {
   getAll,
   getById,

package/utils/i18n.js

@@ -1,6 +1,5 @@
 const fs = require('fs');
 const path = require('path');
-const { config } = require('../stores/config');
 
 /**
  * Internationalization utility for multi-language support
@@ -8,13 +7,18 @@ const { config } = require('../stores/config');
 class I18n {
   constructor() {
     this.locales = {};
-    this.defaultLocale = config.default_language || 'en';
-    this.supportedLocales = config.supported_languages || ['en'];
+    this.defaultLocale = 'en';
+    this.supportedLocales = ['en'];
     this.localesPath = path.join(__dirname, '../locales');
     this.localesBackend = path.join('./locales');
     this.loadLocales();
   }
 
+  setConfig(config) {
+    this.defaultLocale = config.default_locale || 'en';
+    this.supportedLocales = config.supported_locales || ['en'];
+  }
+
   /**
    * Load all locale files
    */
@@ -62,15 +66,30 @@ class I18n {
    * @param {Object} params - Parameters to replace in the translation
    * @returns {string} Translated string
    */
-  t(key, locale = this.defaultLocale, params = {}) {
+  t(key, params = {}, locale = this.defaultLocale) {
     const keys = key.split('.');
-    let translation = this.locales[locale] || this.locales[this.defaultLocale];
+
+    if(!this.locales[locale]) {
+      this.locales[locale] = {};
+    }
+
+    if(!fs.existsSync(path.join(this.localesBackend, locale))) {
+      // create directory
+      fs.mkdirSync(path.join(this.localesBackend, locale), { recursive: true });
+    }
+
+    let translation = this.locales[locale];
     const fileName = keys.length > 0 ? keys[0] : 'index';
 
     if(!translation[fileName]) {
       translation[fileName] = {};
     }
 
+    if(!fs.existsSync(path.join(this.localesBackend, locale, `${fileName}.json`))) {
+      this.writeFile(key, locale, params);
+      return key;
+    }
+
     if(keys.length > 1) {
       for(const k of keys.slice(1)) {
         if(translation[fileName] && translation[fileName][k] !== undefined) {

package/utils/jsonRouteLoader.js

@@ -13,7 +13,7 @@ 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'];
+    this.deleteKeys = ['creatable', 'updatable', 'search_type', 'listable', 'crypted', 'create_required', 'generatable', 'unique', 'example', 'slug', 'exists'];
   }
 
   /**
@@ -67,6 +67,8 @@ class JsonRouteLoader {
       const store = config.store || null;
       const routes = config.routes || {};
       const schema = config.schema || {};
+      const unique = config.unique || [];
+      const owned = config.owned || {};
       const joinTables = config.join_tables || {};
 
       // Validate configuration
@@ -77,7 +79,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, joinTables, type);
+          await this.registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema, joinTables, type, unique, owned);
           if(store) {
             await add_model(store, primaryKey, schema);
           }
@@ -113,7 +115,7 @@ 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, joinTables, type = 'service') {
+  async registerRoute(fastify, tableName, routeName, routeConfig, primaryKey, workerName, fileName, store, schema, joinTables, type = 'service', unique = [], owned = {}) {
 
     const routeDefinition = this.generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type, joinTables);
     const routeKey = `${routeDefinition.method}:${routeDefinition.url}`;
@@ -150,7 +152,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, joinTables });
+          return handler(request, reply, { tableName, routeConfig, schema, primaryKey, store, filters, joinTables, unique, owned });
         }
       });
 
@@ -170,9 +172,17 @@ class JsonRouteLoader {
    */
   generateRouteDefinition(tableName, routeName, routeConfig, primaryKey, fileName, schema, type = 'service', joinTables = {}) {
     const prefix = configStore.prefix ? configStore.prefix + '/' : '';
-    const baseUrl = `/${prefix}${fileName}`;
+    let cleanPath = routeConfig.path || false
+    if(cleanPath && cleanPath.startsWith('/')) {
+      cleanPath = cleanPath.slice(1);
+    }
+    let baseUrl = `/${prefix}${(cleanPath ? cleanPath : fileName)}`;
     primaryKey = primaryKey || 'id';
 
+    if(!routeConfig.path) {
+      baseUrl += `/${primaryKey}`;
+    }
+    
     const routeDefinitions = {
       list: {
         method: 'GET',
@@ -181,7 +191,7 @@ class JsonRouteLoader {
       },
       get: {
         method: 'GET',
-        url: `${baseUrl}/:${primaryKey}`,
+        url: `${baseUrl}`,
         schema: this.generateGetSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       create: {
@@ -191,17 +201,17 @@ class JsonRouteLoader {
       },
       update: {
         method: 'PUT',
-        url: `${baseUrl}/:${primaryKey}`,
+        url: `${baseUrl}`,
         schema: this.generateUpdateSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       delete: {
         method: 'DELETE',
-        url: `${baseUrl}/:${primaryKey}`,
+        url: `${baseUrl}`,
         schema: this.generateDeleteSchema(tableName, routeConfig, primaryKey, schema, type, joinTables)
       },
       upload: {
         method: 'POST',
-        url: `${baseUrl}/:${primaryKey}/${routeConfig.upload_field || 'upload'}`,
+        url: `${baseUrl}`,
         schema: this.generateUploadSchema(tableName, routeConfig, primaryKey, schema, type, joinTables),
         validatorCompiler: ({ schema }) => {
           return (data) => {
@@ -224,7 +234,7 @@ class JsonRouteLoader {
    * @returns {Object} Schema
    */
   generateListSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
-    const itemSchema = this.generateItemSchema(schema, primaryKey, joinTables);
+    const itemSchema = this.generateItemSchema('list', schema, primaryKey, joinTables);
 
     return {
       description: `Get all ${tableName} with pagination and search`,
@@ -239,7 +249,7 @@ class JsonRouteLoader {
           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 };
+              acc[key] = { type: value.type == 'boolean' ? 'integer' : value.type, default: value.default || undefined, enum: value.enum || undefined };
             }
             return acc;
           }, {})
@@ -283,7 +293,7 @@ class JsonRouteLoader {
    * @returns {Object} Schema
    */
   generateGetSchema(tableName, routeConfig, primaryKey, schema, type = 'service', joinTables = {}) {
-    const itemSchema = this.generateItemSchema(schema, primaryKey, joinTables);
+    const itemSchema = this.generateItemSchema('get', schema, primaryKey, joinTables);
     primaryKey = primaryKey || 'id';
 
     return {
@@ -336,7 +346,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey, joinTables)
+            data: this.generateItemSchema('create', schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -378,7 +388,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey, joinTables)
+            data: this.generateItemSchema('update', schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -417,7 +427,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey, joinTables)
+            data: this.generateItemSchema('delete', schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -465,7 +475,7 @@ class JsonRouteLoader {
           type: 'object',
           properties: {
             status: { type: 'boolean', default: true },
-            data: this.generateItemSchema(schema, primaryKey, joinTables)
+            data: this.generateItemSchema('upload', schema, primaryKey, joinTables)
           },
           additionalProperties: false
         },
@@ -485,7 +495,7 @@ class JsonRouteLoader {
    * @param {Object} itemSchema - Item schema from config
    * @returns {Object} Item schema
    */
-  generateItemSchema(schema, primaryKey, joinTables = {}) {
+  generateItemSchema(type, schema, primaryKey, joinTables = {}) {
     if (!schema) {
       return { type: 'object' };
     }
@@ -512,12 +522,21 @@ class JsonRouteLoader {
 
     if(Object.entries(joinTables).length > 0) {
       for(const [key, value] of Object.entries(joinTables)) {
-        if(value.type == 'one-to-one') {
+        if(value.type == 'one-to-one' || (value.type == 'one-to-many' && value.localized && type == 'list')) {
           withoutReferences[value.table] = {
             type: 'object',
             properties: value.properties,
             additionalProperties: false
           };
+        } else if(value.type == 'one-to-many') {
+          withoutReferences[value.table] = {
+            type: 'array',
+            items: {
+              type: 'object',
+              properties: value.properties,
+              additionalProperties: false
+            }
+          };
         }
       }
     }