axe-api 0.17.4 → 0.19.0

package/.github/workflows/test-integration.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x, 16.x]
+        node-version: [14.x, 16.x, 17.x]
         database: [mysql8, mysql57, "postgres"]
     steps:
       - uses: actions/checkout@v2

package/.github/workflows/test-unit.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node-version: [14.x, 16.x]
+        node-version: [14.x, 16.x, 17.x]
     steps:
       - uses: actions/checkout@v2
       - name: Use Node.js ${{ matrix.node-version }}

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Release Notes
 
+## [0.19.0 (2021-12-05)](https://github.com/axe-api/axe-api/compare/0.19.0...0.18.1)
+
+### Fixed
+
+- [#110](https://github.com/axe-api/axe-api/issues/110)
+
+### Enhancements
+
+- [#106](https://github.com/axe-api/axe-api/issues/106)
+
+## [0.18.1 (2021-12-02)](https://github.com/axe-api/axe-api/compare/0.18.1...0.18.0)
+
+### Fixed
+
+- [#117](https://github.com/axe-api/axe-api/issues/117)
+
+## [0.18.0 (2021-11-30)](https://github.com/axe-api/axe-api/compare/0.18.0...0.17.5)
+
+### Fixed
+
+- [#115](https://github.com/axe-api/axe-api/issues/115)
+- [#114](https://github.com/axe-api/axe-api/issues/114)
+
+### Enhancements
+
+- [#113](https://github.com/axe-api/axe-api/issues/113)
+- [#107](https://github.com/axe-api/axe-api/issues/107)
+- [#108](https://github.com/axe-api/axe-api/issues/108)
+
+## [0.17.5 (2021-11-27)](https://github.com/axe-api/axe-api/compare/0.17.5...0.17.4)
+
+### Fixed
+
+- [#111](https://github.com/axe-api/axe-api/issues/111)
+
 ## [0.17.4 (2021-10-28)](https://github.com/axe-api/axe-api/compare/0.17.4...0.17.3)
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "0.17.4",
+  "version": "0.19.0",
   "description": "AXE API is a simple tool which has been created based on Express and Knex.js to create Rest APIs quickly.",
   "main": "index.js",
   "type": "module",

package/src/constants.js

@@ -13,6 +13,7 @@ const HOOK_FUNCTIONS = {
   onBeforeDeleteQuery: "onBeforeDeleteQuery",
   onBeforeDelete: "onBeforeDelete",
   onBeforePaginate: "onBeforePaginate",
+  onBeforeAll: "onBeforeAll",
   onBeforeShow: "onBeforeShow",
   onAfterInsert: "onAfterInsert",
   onAfterUpdateQuery: "onAfterUpdateQuery",
@@ -20,6 +21,7 @@ const HOOK_FUNCTIONS = {
   onAfterDeleteQuery: "onAfterDeleteQuery",
   onAfterDelete: "onAfterDelete",
   onAfterPaginate: "onAfterPaginate",
+  onAfterAll: "onAfterAll",
   onAfterShow: "onAfterShow",
 };
 
@@ -52,7 +54,8 @@ const HANDLERS = {
   SHOW: "show",
   UPDATE: "update",
   DELETE: "destroy",
-  AUTOSAVE: "autosave",
+  PATCH: "patch",
+  ALL: "all",
 };
 
 const DEFAULT_HANDLERS = [
@@ -60,6 +63,7 @@ const DEFAULT_HANDLERS = [
   HANDLERS.PAGINATE,
   HANDLERS.SHOW,
   HANDLERS.UPDATE,
+  HANDLERS.PATCH,
   HANDLERS.DELETE,
 ];
 
@@ -68,35 +72,41 @@ const HTTP_METHODS = {
   GET: "GET",
   PUT: "PUT",
   DELETE: "DELETE",
+  PATCH: "PATCH",
 };
 
 const API_ROUTE_TEMPLATES = {
   [HANDLERS.INSERT]: {
-    url: (parentUrl, resource) => `/api/${parentUrl}${resource}`,
+    url: (prefix, parentUrl, resource) => `/${prefix}/${parentUrl}${resource}`,
     method: HTTP_METHODS.POST,
   },
   [HANDLERS.PAGINATE]: {
-    url: (parentUrl, resource) => `/api/${parentUrl}${resource}`,
+    url: (prefix, parentUrl, resource) => `/${prefix}/${parentUrl}${resource}`,
+    method: HTTP_METHODS.GET,
+  },
+  [HANDLERS.ALL]: {
+    url: (prefix, parentUrl, resource) =>
+      `/${prefix}/${parentUrl}${resource}/all`,
     method: HTTP_METHODS.GET,
   },
   [HANDLERS.SHOW]: {
-    url: (parentUrl, resource, primaryKey) =>
-      `/api/${parentUrl}${resource}/:${primaryKey}`,
+    url: (prefix, parentUrl, resource, primaryKey) =>
+      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
     method: HTTP_METHODS.GET,
   },
   [HANDLERS.UPDATE]: {
-    url: (parentUrl, resource, primaryKey) =>
-      `/api/${parentUrl}${resource}/:${primaryKey}`,
+    url: (prefix, parentUrl, resource, primaryKey) =>
+      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
     method: HTTP_METHODS.PUT,
   },
-  [HANDLERS.AUTOSAVE]: {
-    url: (parentUrl, resource, primaryKey) =>
-      `/api/${parentUrl}${resource}/:${primaryKey}/autosave`,
-    method: HTTP_METHODS.PUT,
+  [HANDLERS.PATCH]: {
+    url: (prefix, parentUrl, resource, primaryKey) =>
+      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
+    method: HTTP_METHODS.PATCH,
   },
   [HANDLERS.DELETE]: {
-    url: (parentUrl, resource, primaryKey) =>
-      `/api/${parentUrl}${resource}/:${primaryKey}`,
+    url: (prefix, parentUrl, resource, primaryKey) =>
+      `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
     method: HTTP_METHODS.DELETE,
   },
 };

package/src/core/Model.js

@@ -1,7 +1,6 @@
 import pluralize from "pluralize";
 import { snakeCase } from "snake-case";
-import { RELATIONSHIPS, HANDLERS } from "./../constants.js";
-const { INSERT, SHOW, UPDATE, PAGINATE, DELETE } = HANDLERS;
+import { RELATIONSHIPS, DEFAULT_HANDLERS } from "./../constants.js";
 
 class Model {
   constructor() {
@@ -25,7 +24,7 @@ class Model {
   }
 
   get handlers() {
-    return [INSERT, SHOW, PAGINATE, UPDATE, DELETE];
+    return [...DEFAULT_HANDLERS];
   }
 
   get middlewares() {

package/src/core/QueryParser.js

@@ -1,31 +1,13 @@
 import HttpResponse from "./../core/HttpResponse.js";
 import { RELATIONSHIPS } from "../constants.js";
 
-const DEFAULT_OPTIONS = {
-  min_per_page: 1,
-  max_per_page: 1000,
-};
-
 class QueryParser {
-  constructor({ model, models, options = {} }) {
+  constructor({ model, models }) {
     this.model = model;
     this.models = models;
     this.createdJoins = [];
     this.relationColumns = [];
     this.usedConditionColumns = new Set();
-    this.options = { ...DEFAULT_OPTIONS, ...options };
-
-    if (isNaN(this.options.min_per_page) || this.options.min_per_page < 1) {
-      throw new Error(
-        `You set unacceptable query parse option (min_per_page): ${this.options.min_per_page}`
-      );
-    }
-
-    if (isNaN(this.options.max_per_page) || this.options.max_per_page > 10000) {
-      throw new Error(
-        `You set unacceptable query parse option (max_per_page): ${this.options.max_per_page}`
-      );
-    }
   }
 
   applyFields(query, fields) {
@@ -109,10 +91,9 @@ class QueryParser {
     });
 
     if (undefinedColumns.length > 0) {
-      throw new HttpResponse(
-        400,
-        `Undefined column names: ${undefinedColumns.join(",")}`
-      );
+      throw new HttpResponse(400, {
+        message: `Undefined column names: ${undefinedColumns.join(",")}`,
+      });
     }
 
     return conditions;
@@ -215,7 +196,9 @@ class QueryParser {
       try {
         sections.q = JSON.parse(queryContent);
       } catch (err) {
-        throw new Error(`Unacceptable query string: \n ${queryContent}`);
+        throw new HttpResponse(400, {
+          message: `Unacceptable query string: ${queryContent}`,
+        });
       }
     }
 
@@ -247,16 +230,8 @@ class QueryParser {
   _parsePerPage(content) {
     const value = parseInt(content);
 
-    if (isNaN(value)) {
-      return this.options.min_per_page;
-    }
-
-    if (value <= this.options.min_per_page) {
-      return this.options.min_per_page;
-    }
-
-    if (value > this.options.max_per_page) {
-      return this.options.max_per_page;
+    if (isNaN(value) || value <= 1 || value > 10000) {
+      return 10;
     }
 
     return value;
@@ -325,19 +300,24 @@ class QueryParser {
       return null;
     }
 
+    const wheres = [];
+    for (const key in content) {
+      wheres.push(this._parseConditionObject(content, key));
+    }
+
+    return wheres;
+  }
+
+  _parseConditionObject(content, key) {
     const where = {
       prefix: null,
       model: this.model,
       table: this.model.instance.table,
-      field: null,
+      field: key,
       condition: "=",
-      value: null,
+      value: content[key],
     };
 
-    const key = Object.keys(content)[0];
-    where.field = key;
-    where.value = content[key];
-
     // Sometimes we can have basic OR operations for queries
     if (where.field.indexOf("$or.") === 0) {
       where.prefix = "or";
@@ -349,19 +329,30 @@ class QueryParser {
       where.field = where.field.replace("$and.", "");
     }
 
-    this._applySpecialCondition(where, "$not", "<>");
-    this._applySpecialCondition(where, "$gt", ">");
-    this._applySpecialCondition(where, "$gte", ">=");
-    this._applySpecialCondition(where, "$lt", "<");
-    this._applySpecialCondition(where, "$lte", "<=");
-    this._applySpecialCondition(where, "$like", "LIKE");
-    this._applySpecialCondition(where, "$notLike", "NOT LIKE");
-    this._applySpecialCondition(where, "$in", "In");
-    this._applySpecialCondition(where, "$notIn", "NotIn");
-    this._applySpecialCondition(where, "$between", "Between");
-    this._applySpecialCondition(where, "$notBetween", "NotBetween");
-    this._applySpecialCondition(where, "$null", "Null");
-    this._applySpecialCondition(where, "$notNull", "NotNull");
+    // If there is not any value, it means that we should check nullable values
+    if (where.value === null) {
+      // If the client wants to see not nullable values
+      if (this._hasSpecialStructure(where.field, ".$not")) {
+        where.field = where.field.replace(".$not", "");
+        where.condition = "NotNull";
+      } else {
+        // So, it means that the clients wants to see null valus
+        where.condition = "Null";
+      }
+    } else {
+      // If there is value, we should check it
+      this._applySpecialCondition(where, "$not", "<>");
+      this._applySpecialCondition(where, "$gt", ">");
+      this._applySpecialCondition(where, "$gte", ">=");
+      this._applySpecialCondition(where, "$lt", "<");
+      this._applySpecialCondition(where, "$lte", "<=");
+      this._applySpecialCondition(where, "$like", "LIKE");
+      this._applySpecialCondition(where, "$notLike", "NOT LIKE");
+      this._applySpecialCondition(where, "$in", "In");
+      this._applySpecialCondition(where, "$notIn", "NotIn");
+      this._applySpecialCondition(where, "$between", "Between");
+      this._applySpecialCondition(where, "$notBetween", "NotBetween");
+    }
 
     if (where.condition === "In" || where.condition === "NotIn") {
       where.value = where.value.split(",");
@@ -371,10 +362,6 @@ class QueryParser {
       where.value = where.value.split(":");
     }
 
-    if (where.condition === "Null" || where.condition === "NotNull") {
-      where.value = null;
-    }
-
     if (where.condition === "LIKE" || where.condition === "NOT LIKE") {
       where.value = where.value.replace(/\*/g, "%");
     }
@@ -389,7 +376,9 @@ class QueryParser {
       );
 
       if (!relation) {
-        throw new Error(`Unacceptable query field: ${relationName}.${field}`);
+        throw new HttpResponse(400, {
+          message: `Unacceptable query field: ${relationName}.${field}`,
+        });
       }
 
       const relatedModel = this.models.find(
@@ -397,7 +386,9 @@ class QueryParser {
       );
 
       if (!relatedModel) {
-        throw new Error(`Undefined model name: ${relation.model}`);
+        throw new HttpResponse(400, {
+          message: `Undefined model name: ${relation.model}`,
+        });
       }
 
       where.model = relatedModel;
@@ -504,7 +495,9 @@ class QueryParser {
         (i) => i.name === item.relationship
       );
       if (!relation) {
-        throw new Error(`Undefined relation: ${item.relationship}`);
+        throw new HttpResponse(400, {
+          message: `Undefined relation: ${item.relationship}`,
+        });
       }
 
       this.relationColumns.push(
@@ -535,11 +528,15 @@ class QueryParser {
   _shouldBeAcceptableColumn(field) {
     const regex = /^[0-9,a-z,A-Z_.]+$/;
     if (!field.match(regex)) {
-      throw new Error(`Unacceptable field name: ${field}`);
+      throw new HttpResponse(400, {
+        message: `Unacceptable field name: ${field}`,
+      });
     }
 
     if (field.indexOf(".") === 0 || field.indexOf(".") === field.length - 1) {
-      throw new Error(`You have to define the column specefically: ${field}`);
+      throw new HttpResponse(400, {
+        message: `You have to define the column specefically: ${field}`,
+      });
     }
   }
 }

package/src/handlers/all.js

@@ -0,0 +1,73 @@
+import {
+  callHooks,
+  getRelatedData,
+  filterHiddenFields,
+  serializeData,
+  addForeignKeyQuery,
+} from "./helpers.js";
+import { HOOK_FUNCTIONS, HANDLERS } from "./../constants.js";
+import QueryParser from "./../core/QueryParser.js";
+
+export default async (context) => {
+  const { request, response, model, models, trx, relation, parentModel } =
+    context;
+
+  const queryParser = new QueryParser({ model, models });
+
+  // We should parse URL query string to use as condition in Lucid query
+  const conditions = queryParser.get(request.query);
+
+  // Creating a new database query
+  const query = trx.from(model.instance.table);
+
+  // Users should be able to select some fields to show.
+  queryParser.applyFields(query, conditions.fields);
+
+  // Binding parent id if there is.
+  addForeignKeyQuery(request, query, relation, parentModel);
+
+  // Users should be able to filter records
+  queryParser.applyWheres(query, conditions.q);
+
+  await callHooks(model, HOOK_FUNCTIONS.onBeforeAll, {
+    ...context,
+    conditions,
+    query,
+  });
+
+  // User should be able to select sorting fields and types
+  queryParser.applySorting(query, conditions.sort);
+
+  const result = await query;
+
+  // We should try to get related data if there is any
+  await getRelatedData(
+    result.data,
+    conditions.with,
+    model,
+    models,
+    trx,
+    HANDLERS.ALL,
+    request
+  );
+
+  await callHooks(model, HOOK_FUNCTIONS.onAfterAll, {
+    ...context,
+    result,
+    conditions,
+    query,
+  });
+
+  // Serializing the data by the model's serialize method
+  result.data = await serializeData(
+    result.data,
+    model.instance.serialize,
+    HANDLERS.ALL,
+    request
+  );
+
+  // Filtering hidden fields from the response data.
+  filterHiddenFields(result.data, model.instance.hiddens);
+
+  return response.json(result);
+};

package/src/handlers/destroy.js

@@ -22,7 +22,9 @@ export default async (context) => {
 
   let item = await query.first();
   if (!item) {
-    throw new HttpResponse(404, `The item is not found on ${model.name}.`);
+    throw new HttpResponse(404, {
+      message: `The item is not found on ${model.name}.`,
+    });
   }
 
   await callHooks(model, HOOK_FUNCTIONS.onAfterDeleteQuery, {

package/src/handlers/helpers.js

@@ -1,7 +1,7 @@
 import { RELATIONSHIPS } from "./../constants.js";
 import { camelCase } from "change-case";
 import HttpResponse from "./../core/HttpResponse.js";
-import IoC from '../core/IoC.js';
+import IoC from "../core/IoC.js";
 
 const getInputFromBody = (body, field) => {
   if (!body) {
@@ -83,7 +83,8 @@ export const getRelatedData = async (
   model,
   models,
   database,
-  handler
+  handler,
+  request
 ) => {
   if (withArray.length === 0) {
     return;
@@ -96,10 +97,9 @@ export const getRelatedData = async (
       (relation) => relation.name === clientQuery.relationship
     );
     if (!definedRelation) {
-      throw new HttpResponse(
-        400,
-        `Undefined relation: ${clientQuery.relationship}`
-      );
+      throw new HttpResponse(400, {
+        message: `Undefined relation: ${clientQuery.relationship}`,
+      });
     }
 
     // Find the foreign model by the relationship
@@ -164,10 +164,9 @@ export const getRelatedData = async (
         (column) => !foreignModel.instance.columnNames.includes(column)
       );
       if (undefinedColumns.length > 0) {
-        throw new HttpResponse(
-          400,
-          `Undefined columns: ${undefinedColumns.join(", ")}`
-        );
+        throw new HttpResponse(400, {
+          message: `Undefined columns: ${undefinedColumns.join(", ")}`,
+        });
       }
     }
 
@@ -189,7 +188,8 @@ export const getRelatedData = async (
     relatedRecords = await serializeData(
       relatedRecords,
       foreignModel.instance.serialize,
-      handler
+      handler,
+      request
     );
 
     // We should hide hidden fields if there is any
@@ -203,7 +203,8 @@ export const getRelatedData = async (
         foreignModel,
         models,
         database,
-        handler
+        handler,
+        request
       );
     }
 
@@ -243,19 +244,19 @@ export const bindTimestampValues = (formData, columnTypes = [], model) => {
   }
 };
 
-const serialize = async (data, callback) => {
+const serialize = async (data, callback, request) => {
   if (!callback) {
     return data;
   }
 
   if (Array.isArray(data)) {
-    return data.map(callback);
+    return data.map((item) => callback(item, request));
   }
 
-  return [data].map(callback)[0];
-}
+  return callback(data, request);
+};
 
-const globalSerializer = async (itemArray, handler) => {
+const globalSerializer = async (itemArray, handler, request) => {
   const { Application } = await IoC.use("Config");
 
   if (!Application.serializers) {
@@ -263,35 +264,43 @@ const globalSerializer = async (itemArray, handler) => {
   }
 
   let callbacks = [];
-  // Push all runable serializer into callbacks. 
-  Application.serializers.map(configSerializer => {
+  // Push all runable serializer into callbacks.
+  Application.serializers.map((configSerializer) => {
     // Serialize data for all requests types.
     if (typeof configSerializer === "function") {
       callbacks.push(configSerializer);
-      return
+      return;
     }
 
     // Serialize data with specific handler like "PAGINATE" or "SHOW".
-    if (typeof configSerializer === "object" && configSerializer.handler.includes(handler)) {
+    if (
+      typeof configSerializer === "object" &&
+      configSerializer.handler.includes(handler)
+    ) {
       // Handle multiple serializer.
       if (Array.isArray(configSerializer.serializer)) {
-        configSerializer.serializer.forEach(fn => callbacks.push(fn));
-        return
+        configSerializer.serializer.forEach((fn) => callbacks.push(fn));
+        return;
       }
-      callbacks.push(configSerializer.serializer)
-      return
+      callbacks.push(configSerializer.serializer);
+      return;
     }
-  })
+  });
 
   while (callbacks.length !== 0) {
-    itemArray = await serialize(itemArray, callbacks.shift());
+    itemArray = serialize(itemArray, callbacks.shift(), request);
   }
   return itemArray;
 };
 
-export const serializeData = async (itemArray, modelSerializer, handler) => {
-  itemArray = await serialize(itemArray, modelSerializer);
-  itemArray = await globalSerializer(itemArray, handler);
+export const serializeData = async (
+  itemArray,
+  modelSerializer,
+  handler,
+  request
+) => {
+  itemArray = serialize(itemArray, modelSerializer, request);
+  itemArray = await globalSerializer(itemArray, handler, request);
   return itemArray;
 };
 

package/src/handlers/index.js

@@ -1,8 +1,9 @@
-import autosave from "./autosave.js";
+import all from "./all.js";
+import patch from "./patch.js";
 import store from "./store.js";
 import show from "./show.js";
 import paginate from "./paginate.js";
 import update from "./update.js";
 import destroy from "./destroy.js";
 
-export default { autosave, store, show, paginate, update, destroy };
+export default { all, patch, store, show, paginate, update, destroy };

package/src/handlers/paginate.js

@@ -45,7 +45,15 @@ export default async (context) => {
   });
 
   // We should try to get related data if there is any
-  await getRelatedData(result.data, conditions.with, model, models, trx, HANDLERS.PAGINATE);
+  await getRelatedData(
+    result.data,
+    conditions.with,
+    model,
+    models,
+    trx,
+    HANDLERS.PAGINATE,
+    request
+  );
 
   await callHooks(model, HOOK_FUNCTIONS.onAfterPaginate, {
     ...context,
@@ -55,7 +63,12 @@ export default async (context) => {
   });
 
   // Serializing the data by the model's serialize method
-  result.data = await serializeData(result.data, model.instance.serialize, HANDLERS.PAGINATE);
+  result.data = await serializeData(
+    result.data,
+    model.instance.serialize,
+    HANDLERS.PAGINATE,
+    request
+  );
 
   // Filtering hidden fields from the response data.
   filterHiddenFields(result.data, model.instance.hiddens);

package/src/handlers/{autosave.js → patch.js}

@@ -11,6 +11,7 @@ import {
 import Validator from "validatorjs";
 import { HOOK_FUNCTIONS, TIMESTAMP_COLUMNS } from "./../constants.js";
 import HttpResponse from "./../core/HttpResponse.js";
+import { HANDLERS } from "./../constants.js";
 
 export default async (context) => {
   const { request, response, model, trx, relation, parentModel } = context;
@@ -29,7 +30,9 @@ export default async (context) => {
     .where(model.instance.primaryKey, request.params[model.instance.primaryKey])
     .first();
   if (!item) {
-    throw new HttpResponse(404, `The item is not found on ${model.name}.`);
+    throw new HttpResponse(404, {
+      message: `The item is not found on ${model.name}.`,
+    });
   }
 
   await callHooks(model, HOOK_FUNCTIONS.onAfterUpdateQuery, {
@@ -78,7 +81,12 @@ export default async (context) => {
   });
 
   // Serializing the data by the model's serialize method
-  item = await serializeData(item, model.instance.serialize);
+  item = await serializeData(
+    item,
+    model.instance.serialize,
+    HANDLERS.PATCH,
+    request
+  );
 
   // Filtering hidden fields from the response data.
   filterHiddenFields([item], model.instance.hiddens);

package/src/handlers/show.js

@@ -43,11 +43,21 @@ export default async (context) => {
 
   let item = await query.first();
   if (!item) {
-    throw new HttpResponse(404, `The item is not found on ${model.name}.`);
+    throw new HttpResponse(404, {
+      message: `The item is not found on ${model.name}.`,
+    });
   }
 
   // We should try to get related data if there is any
-  await getRelatedData([item], conditions.with, model, models, trx, HANDLERS.SHOW);
+  await getRelatedData(
+    [item],
+    conditions.with,
+    model,
+    models,
+    trx,
+    HANDLERS.SHOW,
+    request
+  );
 
   await callHooks(model, HOOK_FUNCTIONS.onAfterShow, {
     ...context,
@@ -57,7 +67,12 @@ export default async (context) => {
   });
 
   // Serializing the data by the model's serialize method
-  item = await serializeData(item, model.instance.serialize, HANDLERS.SHOW);
+  item = await serializeData(
+    item,
+    model.instance.serialize,
+    HANDLERS.SHOW,
+    request
+  );
 
   // Filtering hidden fields from the response data.
   filterHiddenFields([item], model.instance.hiddens);

package/src/handlers/store.js

@@ -45,7 +45,7 @@ export default async (context) => {
 
   let [insertedPrimaryKeyValue] = await trx(model.instance.table)
     .insert(formData)
-    .returning("id");
+    .returning(model.instance.primaryKey);
 
   // If the user use a special primary key value, we should use that value
   if (insertedPrimaryKeyValue === 0) {
@@ -63,7 +63,12 @@ export default async (context) => {
   });
 
   // Serializing the data by the model's serialize method
-  item = await serializeData(item, model.instance.serialize, HANDLERS.INSERT);
+  item = await serializeData(
+    item,
+    model.instance.serialize,
+    HANDLERS.INSERT,
+    request
+  );
 
   // Filtering hidden fields from the response data.
   filterHiddenFields([item], model.instance.hiddens);

package/src/handlers/update.js

@@ -28,7 +28,9 @@ export default async (context) => {
     .where(model.instance.primaryKey, request.params[model.instance.primaryKey])
     .first();
   if (!item) {
-    throw new HttpResponse(404, `The item is not found on ${model.name}.`);
+    throw new HttpResponse(404, {
+      message: `The item is not found on ${model.name}.`,
+    });
   }
 
   await callHooks(model, HOOK_FUNCTIONS.onAfterUpdateQuery, {
@@ -76,7 +78,12 @@ export default async (context) => {
   });
 
   // Serializing the data by the model's serialize method
-  item = await serializeData(item, model.instance.serialize, HANDLERS.UPDATE);
+  item = await serializeData(
+    item,
+    model.instance.serialize,
+    HANDLERS.UPDATE,
+    request
+  );
 
   // Filtering hidden fields from the response data.
   filterHiddenFields([item], model.instance.hiddens);

package/src/resolvers/setExpressRoutes.js

@@ -1,30 +1,11 @@
 import IoC from "./../core/IoC.js";
 import pluralize from "pluralize";
-import { paramCase } from "change-case";
+import { paramCase, camelCase } from "change-case";
 import { RELATIONSHIPS, API_ROUTE_TEMPLATES } from "./../constants.js";
 import Handlers from "./../handlers/index.js";
 
 let Config = null;
 
-const handleErrors = (req, res, error) => {
-  const status = error.type === "HttpResponse" ? error.status : 400;
-  let errors = error.content ? error.content : error.message;
-
-  if (Config.Application.env === "production") {
-    errors = "An error occurred!";
-  }
-
-  const result = {
-    errors,
-  };
-
-  if (Config.Application.env === "development") {
-    result.stack = error.stack;
-  }
-
-  res.status(status).json(result);
-};
-
 const setTransactionOption = (option, handler, defaultValue) => {
   if (Array.isArray(option)) {
     if (option.some((i) => i.handler === handler)) {
@@ -53,7 +34,7 @@ const hasTransaction = (config, model, handler) => {
   return privilegedOption;
 };
 
-const requestHandler = async (handler, req, res, context) => {
+const requestHandler = async (handler, req, res, next, context) => {
   try {
     context.trx = context.database;
     if (hasTransaction(Config, context.model, handler)) {
@@ -73,7 +54,11 @@ const requestHandler = async (handler, req, res, context) => {
       await context.trx.rollback();
     }
 
-    handleErrors(req, res, error);
+    if (error.type === "HttpResponse") {
+      return res.status(error.status).json(error.content);
+    }
+
+    next(error);
   }
 };
 
@@ -137,7 +122,7 @@ const createNestedRoutes = async (
   await createRouteByModel(
     model,
     models,
-    `${urlPrefix}${resource}/:${getPrimaryKeyName(model)}/`,
+    `${urlPrefix}${resource}/:${camelCase(relation.foreignKey)}/`,
     model,
     relation,
     false
@@ -179,6 +164,14 @@ const getModelMiddlewares = (model, handler) => {
   return middlewares;
 };
 
+const getRootPrefix = () => {
+  if (Config.Application.prefix) {
+    // NOSONAR
+    return Config.Application.prefix.replace(/^\/|\/$/g, "");
+  }
+  return "api";
+};
+
 const createRouteByModel = async (
   model,
   models,
@@ -216,6 +209,7 @@ const createRouteByModel = async (
 
     const routeTemplate = API_ROUTE_TEMPLATES[handler];
     const url = routeTemplate.url(
+      getRootPrefix(),
       urlPrefix,
       resource,
       model.instance.primaryKey
@@ -229,9 +223,13 @@ const createRouteByModel = async (
     docs.push(routeTemplate.method, url, model);
 
     // Adding the route to the express
-    app[routeTemplate.method.toLowerCase()](url, middlewares, (req, res) => {
-      requestHandler(handler, req, res, context);
-    });
+    app[routeTemplate.method.toLowerCase()](
+      url,
+      middlewares,
+      (req, res, next) => {
+        requestHandler(handler, req, res, next, context);
+      }
+    );
   }
 
   await createChildRoutes(model, models, resource, urlPrefix);