axe-api 0.20.1 → 0.20.2

package/build/src/Handlers/HandlerFactory.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const AllHandler_1 = __importDefault(require("./AllHandler"));
+const DestroyHandler_1 = __importDefault(require("./DestroyHandler"));
+const PaginateHandler_1 = __importDefault(require("./PaginateHandler"));
+const PatchHandler_1 = __importDefault(require("./PatchHandler"));
+const UpdateHandler_1 = __importDefault(require("./UpdateHandler"));
+const ShowHandler_1 = __importDefault(require("./ShowHandler"));
+const StoreHandler_1 = __importDefault(require("./StoreHandler"));
+const Enums_1 = require("../Enums");
+class HandlerFactory {
+    get(handleType) {
+        switch (handleType) {
+            case Enums_1.HandlerTypes.ALL:
+                return AllHandler_1.default;
+            case Enums_1.HandlerTypes.DELETE:
+                return DestroyHandler_1.default;
+            case Enums_1.HandlerTypes.INSERT:
+                return StoreHandler_1.default;
+            case Enums_1.HandlerTypes.PAGINATE:
+                return PaginateHandler_1.default;
+            case Enums_1.HandlerTypes.PATCH:
+                return PatchHandler_1.default;
+            case Enums_1.HandlerTypes.SHOW:
+                return ShowHandler_1.default;
+            case Enums_1.HandlerTypes.UPDATE:
+                return UpdateHandler_1.default;
+            default:
+                throw new Error("Handler type is not defined");
+        }
+    }
+}
+exports.default = HandlerFactory;

package/build/src/Handlers/Helpers.d.ts

@@ -0,0 +1,14 @@
+import { Request } from "express";
+import { IModelService, IRelation, IHookParameter } from "../Interfaces";
+import { Knex } from "knex";
+import { IWith } from "../Interfaces";
+import { HandlerTypes, HookFunctionTypes, TimestampColumns } from "../Enums";
+import { ModelListService } from "../Services";
+export declare const bindTimestampValues: (formData: Record<string, any>, columnTypes: TimestampColumns[] | undefined, model: IModelService) => void;
+export declare const getMergedFormData: (req: Request, fillables: string[]) => Record<string, any>;
+export declare const callHooks: (model: IModelService, type: HookFunctionTypes, params: IHookParameter) => Promise<void>;
+export declare const getParentColumn: (relation: IRelation | null) => string | null;
+export declare const addForeignKeyQuery: (request: Request, query: Knex.QueryBuilder, relation: IRelation | null, parentModel: IModelService | null) => void;
+export declare const serializeData: (itemArray: any[] | any, modelSerializer: (data: any, request: Request) => void, handler: HandlerTypes, request: Request) => Promise<any[]>;
+export declare const filterHiddenFields: (itemArray: any[], hiddens: string[] | null) => void;
+export declare const getRelatedData: (data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: Request) => Promise<void>;

package/build/src/Handlers/Helpers.js

@@ -0,0 +1,217 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRelatedData = exports.filterHiddenFields = exports.serializeData = exports.addForeignKeyQuery = exports.getParentColumn = exports.callHooks = exports.getMergedFormData = exports.bindTimestampValues = void 0;
+const change_case_1 = require("change-case");
+const Enums_1 = require("../Enums");
+const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+const Services_1 = require("../Services");
+const bindTimestampValues = (formData, columnTypes = [], model) => {
+    if (columnTypes.includes(Enums_1.TimestampColumns.CREATED_AT) &&
+        model.instance.createdAtColumn) {
+        formData[model.instance.createdAtColumn] = new Date();
+    }
+    if (columnTypes.includes(Enums_1.TimestampColumns.UPDATED_AT) &&
+        model.instance.updatedAtColumn) {
+        formData[model.instance.updatedAtColumn] = new Date();
+    }
+};
+exports.bindTimestampValues = bindTimestampValues;
+const getMergedFormData = (req, fillables) => {
+    const formData = {};
+    Object.keys(req.body).forEach((key) => {
+        if (fillables.includes(key)) {
+            formData[key] = req.body[key];
+        }
+    });
+    return formData;
+};
+exports.getMergedFormData = getMergedFormData;
+const callHooks = (model, type, params) => __awaiter(void 0, void 0, void 0, function* () {
+    if (model.hooks[type]) {
+        yield model.hooks[type](params);
+    }
+    if (model.events[type]) {
+        // Developers shouldn't be able to access transaction in events. Because
+        // we don't await for the events. If the developer uses the transaction and
+        // try to commit something, it would be lost cause the transaction could be
+        // already completed.
+        const database = (yield Services_1.IoCService.use("Database"));
+        params.database = database;
+        // Calling the events
+        model.events[type](params);
+    }
+});
+exports.callHooks = callHooks;
+const getParentColumn = (relation) => {
+    if (!relation) {
+        return null;
+    }
+    return (0, change_case_1.camelCase)(relation.foreignKey);
+};
+exports.getParentColumn = getParentColumn;
+const addForeignKeyQuery = (request, query, relation, parentModel) => {
+    if (relation && parentModel) {
+        const parentColumn = (0, exports.getParentColumn)(relation);
+        if (parentColumn) {
+            query.where(relation.foreignKey, request.params[parentColumn]);
+        }
+    }
+};
+exports.addForeignKeyQuery = addForeignKeyQuery;
+const getPrimaryOrForeignKeyByRelation = (relation, dataField) => {
+    if (dataField === "primaryKey") {
+        return relation.primaryKey;
+    }
+    return relation.foreignKey;
+};
+const uniqueByMap = (array) => {
+    const map = new Map();
+    for (const item of array) {
+        map.set(item, item);
+    }
+    return Array.from(map.values());
+};
+const serialize = (data, callback, request) => {
+    if (!callback) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map((item) => callback(item, request));
+    }
+    return callback(data, request);
+};
+const globalSerializer = (itemArray, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+    const Application = yield Services_1.IoCService.useByType("Config");
+    if (!Application.serializers) {
+        return itemArray;
+    }
+    const callbacks = [];
+    // Push all runable serializer into callbacks.
+    Application.serializers.map((configSerializer) => {
+        // Serialize data for all requests types.
+        if (typeof configSerializer === "function") {
+            callbacks.push(configSerializer);
+            return;
+        }
+        // Serialize data with specific handler like "PAGINATE" or "SHOW".
+        if (configSerializer.handler.includes(handler)) {
+            callbacks.push(...configSerializer.serializer);
+            return;
+        }
+    });
+    callbacks.forEach((callback) => {
+        itemArray = serialize(itemArray, callback, request);
+    });
+    return itemArray;
+});
+const serializeData = (itemArray, modelSerializer, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+    itemArray = serialize(itemArray, modelSerializer, request);
+    itemArray = yield globalSerializer(itemArray, handler, request);
+    return itemArray;
+});
+exports.serializeData = serializeData;
+const filterHiddenFields = (itemArray, hiddens) => {
+    if (hiddens === null) {
+        return;
+    }
+    if (hiddens.length === 0 || itemArray.length === 0) {
+        return;
+    }
+    itemArray.forEach((item) => {
+        hiddens.forEach((hidden) => {
+            if (item[hidden] !== undefined) {
+                delete item[hidden];
+            }
+        });
+    });
+};
+exports.filterHiddenFields = filterHiddenFields;
+const getRelatedData = (data, withArray, model, modelList, database, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+    if (withArray.length === 0) {
+        return;
+    }
+    const models = modelList.get();
+    for (const clientQuery of withArray) {
+        // Find the relation of the model. If the model doesn't have any relationship like the
+        // user wants, we can't show anything.
+        const definedRelation = model.relations.find((relation) => relation.name === clientQuery.relationship);
+        if (!definedRelation) {
+            throw new ApiError_1.default(`Undefined relation: ${clientQuery.relationship}`);
+        }
+        // Find the foreign model by the relationship
+        const foreignModel = models.find((model) => model.name === definedRelation.model);
+        if (!foreignModel) {
+            continue;
+        }
+        let dataField = "primaryKey";
+        let searchField = "foreignKey";
+        if (definedRelation.type !== Enums_1.Relationships.HAS_MANY) {
+            dataField = "foreignKey";
+            searchField = "primaryKey";
+        }
+        const dataFieldKey = getPrimaryOrForeignKeyByRelation(definedRelation, dataField);
+        const searchFieldKey = getPrimaryOrForeignKeyByRelation(definedRelation, searchField);
+        // We should find the parent Primary Key values.
+        const parentPrimaryKeyValues = data.map((item) => item[dataFieldKey]);
+        // Selecting the special field for the relations
+        let selectColumns = ["*"];
+        if (clientQuery.fields.length > 0) {
+            selectColumns = [...clientQuery.fields, searchFieldKey];
+            if (definedRelation.type === Enums_1.Relationships.HAS_MANY) {
+                selectColumns.push(dataFieldKey);
+            }
+            // We should check if any select column is a relationship name. If so,
+            // we should remove that column name from the select columns
+            const possibleThirthLevelRelations = foreignModel.relations.map((item) => item.name);
+            // Removing relationship values from the select column list
+            selectColumns = selectColumns.filter((column) => !possibleThirthLevelRelations.includes(column));
+            // We should check if the column is defined on the table.
+            const undefinedColumns = selectColumns.filter((column) => !foreignModel.columnNames.includes(column));
+            if (undefinedColumns.length > 0) {
+                throw new ApiError_1.default(`Undefined columns: ${undefinedColumns.join(", ")}`);
+            }
+        }
+        // We should add the HAS_ONE relation's foreignKeys incase the developer
+        // wants the related data but didn't set the foreignKey column
+        if (selectColumns.length > 0 && selectColumns[0] !== "*") {
+            const requiredForeignKeys = foreignModel.relations
+                .filter((item) => item.type === Enums_1.Relationships.HAS_ONE)
+                .map((item) => item.foreignKey);
+            selectColumns.push(...requiredForeignKeys);
+        }
+        selectColumns = uniqueByMap(selectColumns);
+        // Fetching related records by foreignKey and primary key values.
+        let relatedRecords = yield database(foreignModel.instance.table)
+            .select(selectColumns)
+            .whereIn(searchFieldKey, parentPrimaryKeyValues);
+        // We should serialize related data if there is any serialization function
+        relatedRecords = yield (0, exports.serializeData)(relatedRecords, foreignModel.instance.serialize, handler, request);
+        // We should hide hidden fields if there is any
+        (0, exports.filterHiddenFields)(relatedRecords, foreignModel.instance.hiddens);
+        // We should try to get child data if there is any on the query
+        if (clientQuery.children.length > 0) {
+            yield (0, exports.getRelatedData)(relatedRecords, clientQuery.children, foreignModel, modelList, database, handler, request);
+        }
+        // Binding relation data to the parent rows.
+        data.forEach((row) => {
+            let values = relatedRecords.filter((item) => item[searchFieldKey] === row[dataFieldKey]);
+            if (definedRelation.type === Enums_1.Relationships.HAS_ONE) {
+                values = values.length > 0 ? values[0] : null;
+            }
+            row[(0, change_case_1.camelCase)(definedRelation.name)] = values;
+        });
+    }
+});
+exports.getRelatedData = getRelatedData;

package/build/src/Handlers/PaginateHandler.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="express" />
+import { IRequestPack } from "../Interfaces";
+declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
+export default _default;

package/build/src/Handlers/PaginateHandler.js

@@ -0,0 +1,48 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("./Helpers");
+const Enums_1 = require("../Enums");
+const Services_1 = require("../Services");
+exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
+    const modelList = yield Services_1.IoCService.useByType("ModelListService");
+    const { model, req, database, relation, parentModel } = pack;
+    const queryParser = new Services_1.QueryService(model, modelList.get());
+    // We should parse URL query string to use as condition in Lucid query
+    const conditions = queryParser.get(req.query);
+    // Creating a new database query
+    const query = database.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.
+    (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforePaginate, Object.assign(Object.assign({}, pack), { conditions,
+        query }));
+    // Users should be able to filter records
+    queryParser.applyWheres(query, conditions.q);
+    // User should be able to select sorting fields and types
+    queryParser.applySorting(query, conditions.sort);
+    const result = yield query.paginate({
+        perPage: conditions.per_page,
+        currentPage: conditions.page,
+        isLengthAware: true,
+    });
+    // We should try to get related data if there is any
+    yield (0, Helpers_1.getRelatedData)(result.data, conditions.with, model, modelList, database, Enums_1.HandlerTypes.PAGINATE, req);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterPaginate, Object.assign(Object.assign({}, pack), { conditions,
+        result,
+        query }));
+    // Serializing the data by the model's serialize method
+    result.data = yield (0, Helpers_1.serializeData)(result.data, model.instance.serialize, Enums_1.HandlerTypes.PAGINATE, req);
+    // Filtering hidden fields from the response data.
+    (0, Helpers_1.filterHiddenFields)(result.data, model.instance.hiddens);
+    return pack.res.json(result);
+});

package/build/src/Handlers/PatchHandler.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="express" />
+import { IRequestPack } from "../Interfaces";
+declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
+export default _default;

package/build/src/Handlers/PatchHandler.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validatorjs_1 = __importDefault(require("validatorjs"));
+const Helpers_1 = require("./Helpers");
+const Enums_1 = require("../Enums");
+const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
+    const { model, req, res, database, relation, parentModel } = pack;
+    const query = database.from(model.instance.table);
+    // If there is a relation, we should bind it
+    (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeUpdateQuery, Object.assign(Object.assign({}, pack), { query }));
+    let item = yield query
+        .where(model.instance.primaryKey, req.params[model.instance.primaryKey])
+        .first();
+    if (!item) {
+        throw new ApiError_1.default(`The item is not found on ${model.name}.`);
+    }
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterUpdateQuery, Object.assign(Object.assign({}, pack), { item,
+        query }));
+    const requestMethod = req.method;
+    const fillables = model.instance.getFillableFields(requestMethod);
+    const formData = Object.assign(Object.assign({}, item), (0, Helpers_1.getMergedFormData)(req, fillables));
+    const validationRules = model.instance.getValidationRules(requestMethod);
+    if (validationRules) {
+        const validation = new validatorjs_1.default(formData, validationRules);
+        if (validation.fails()) {
+            return res.status(400).json(validation.errors);
+        }
+    }
+    // We should bind the timestamp values
+    (0, Helpers_1.bindTimestampValues)(formData, [Enums_1.TimestampColumns.UPDATED_AT], model);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeUpdate, Object.assign(Object.assign({}, pack), { item,
+        formData,
+        query }));
+    yield query
+        .where(model.instance.primaryKey, item[model.instance.primaryKey])
+        .update(formData);
+    item = yield database(model.instance.table)
+        .where(model.instance.primaryKey, item[model.instance.primaryKey])
+        .first();
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterUpdate, Object.assign(Object.assign({}, pack), { item,
+        formData,
+        query }));
+    // Serializing the data by the model's serialize method
+    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.PATCH, req);
+    // Filtering hidden fields from the response data.
+    (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
+    return res.json(item);
+});

package/build/src/Handlers/ShowHandler.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="express" />
+import { IRequestPack } from "../Interfaces";
+declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
+export default _default;

package/build/src/Handlers/ShowHandler.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("./Helpers");
+const Enums_1 = require("../Enums");
+const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+const Services_1 = require("../Services");
+exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
+    const modelList = yield Services_1.IoCService.useByType("ModelListService");
+    const { model, req, res, database, relation, parentModel } = pack;
+    const queryParser = new Services_1.QueryService(model, modelList.get());
+    // We should parse URL query string to use as condition in Lucid query
+    const conditions = queryParser.get(req.query);
+    // Fetching item
+    const query = database.from(model.instance.table);
+    // Users should be able to select some fields to show.
+    queryParser.applyFields(query, conditions.fields);
+    // If there is a relation, we should bind it
+    (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
+    // We should add this condition in here because of performance.
+    query.where(model.instance.primaryKey, req.params[model.instance.primaryKey]);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeShow, Object.assign(Object.assign({}, pack), { query,
+        conditions }));
+    // Users should be able to filter records
+    queryParser.applyWheres(query, conditions.q);
+    let item = yield query.first();
+    if (!item) {
+        throw new ApiError_1.default(`The item is not found on ${model.name}.`);
+    }
+    // We should try to get related data if there is any
+    yield (0, Helpers_1.getRelatedData)([item], conditions.with, model, modelList, database, Enums_1.HandlerTypes.ALL, req);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterShow, Object.assign(Object.assign({}, pack), { query,
+        conditions,
+        item }));
+    // Serializing the data by the model's serialize method
+    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.SHOW, req);
+    // Filtering hidden fields from the response data.
+    (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
+    return res.json(item);
+});

package/build/src/Handlers/StoreHandler.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="express" />
+import { IRequestPack } from "../Interfaces";
+declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
+export default _default;

package/build/src/Handlers/StoreHandler.js

@@ -0,0 +1,59 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validatorjs_1 = __importDefault(require("validatorjs"));
+const Helpers_1 = require("./Helpers");
+const Enums_1 = require("../Enums");
+exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
+    const { model, req, res, database, relation, parentModel } = pack;
+    const requestMethod = req.method;
+    const fillables = model.instance.getFillableFields(requestMethod);
+    const formData = (0, Helpers_1.getMergedFormData)(req, fillables);
+    const validationRules = model.instance.getValidationRules(requestMethod);
+    if (validationRules) {
+        const validation = new validatorjs_1.default(formData, validationRules);
+        if (validation.fails()) {
+            return res.status(400).json(validation.errors);
+        }
+    }
+    if (relation && parentModel) {
+        const parentColumn = (0, Helpers_1.getParentColumn)(relation);
+        if (parentColumn) {
+            formData[relation.foreignKey] = req.params[parentColumn];
+        }
+    }
+    // We should bind the timestamp values
+    (0, Helpers_1.bindTimestampValues)(formData, [Enums_1.TimestampColumns.CREATED_AT, Enums_1.TimestampColumns.UPDATED_AT], model);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeInsert, Object.assign(Object.assign({}, pack), { formData }));
+    const [returningResult] = yield database(model.instance.table)
+        .insert(formData)
+        .returning(model.instance.primaryKey);
+    let insertedPrimaryKeyValue = typeof returningResult === "number"
+        ? returningResult
+        : returningResult[model.instance.primaryKey];
+    // If the user use a special primary key value, we should use that value
+    if (insertedPrimaryKeyValue === 0) {
+        insertedPrimaryKeyValue = formData[model.instance.primaryKey];
+    }
+    let item = yield database(model.instance.table)
+        .where(model.instance.primaryKey, insertedPrimaryKeyValue)
+        .first();
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterInsert, Object.assign(Object.assign({}, pack), { formData,
+        item }));
+    // Serializing the data by the model's serialize method
+    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.INSERT, req);
+    // Filtering hidden fields from the response data.
+    (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
+    return res.json(item);
+});

package/build/src/Handlers/UpdateHandler.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="express" />
+import { IRequestPack } from "../Interfaces";
+declare const _default: (pack: IRequestPack) => Promise<import("express").Response<any, Record<string, any>>>;
+export default _default;

package/build/src/Handlers/UpdateHandler.js

@@ -0,0 +1,62 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validatorjs_1 = __importDefault(require("validatorjs"));
+const Helpers_1 = require("./Helpers");
+const Enums_1 = require("../Enums");
+const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
+    const { model, req, res, database, relation, parentModel } = pack;
+    const query = database.from(model.instance.table);
+    // If there is a relation, we should bind it
+    (0, Helpers_1.addForeignKeyQuery)(req, query, relation, parentModel);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeUpdateQuery, Object.assign(Object.assign({}, pack), { query }));
+    let item = yield query
+        .where(model.instance.primaryKey, req.params[model.instance.primaryKey])
+        .first();
+    if (!item) {
+        throw new ApiError_1.default(`The item is not found on ${model.name}.`);
+    }
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterUpdateQuery, Object.assign(Object.assign({}, pack), { item,
+        query }));
+    const requestMethod = req.method;
+    const fillables = model.instance.getFillableFields(requestMethod);
+    const formData = (0, Helpers_1.getMergedFormData)(req, fillables);
+    const validationRules = model.instance.getValidationRules(requestMethod);
+    if (validationRules) {
+        const validation = new validatorjs_1.default(formData, validationRules);
+        if (validation.fails()) {
+            return res.status(400).json(validation.errors);
+        }
+    }
+    // We should bind the timestamp values
+    (0, Helpers_1.bindTimestampValues)(formData, [Enums_1.TimestampColumns.UPDATED_AT], model);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeUpdate, Object.assign(Object.assign({}, pack), { item,
+        formData,
+        query }));
+    yield query
+        .where(model.instance.primaryKey, item[model.instance.primaryKey])
+        .update(formData);
+    item = yield database(model.instance.table)
+        .where(model.instance.primaryKey, item[model.instance.primaryKey])
+        .first();
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterUpdate, Object.assign(Object.assign({}, pack), { item,
+        formData,
+        query }));
+    // Serializing the data by the model's serialize method
+    item = yield (0, Helpers_1.serializeData)(item, model.instance.serialize, Enums_1.HandlerTypes.UPDATE, req);
+    // Filtering hidden fields from the response data.
+    (0, Helpers_1.filterHiddenFields)([item], model.instance.hiddens);
+    return res.json(item);
+});