axe-api 0.21.0 → 0.30.0-rc1

package/build/src/Builders/RouterBuilder.js

@@ -13,15 +13,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const pluralize_1 = __importDefault(require("pluralize"));
+const path_1 = __importDefault(require("path"));
 const http_status_codes_1 = require("http-status-codes");
 const change_case_1 = require("change-case");
 const Resolvers_1 = require("../Resolvers");
 const constants_1 = require("../constants");
 const Enums_1 = require("../Enums");
+const HandlerFactory_1 = __importDefault(require("../Handlers/HandlerFactory"));
 const Services_1 = require("../Services");
 const Middlewares_1 = require("../Middlewares");
 class RouterBuilder {
-    constructor() {
+    constructor(version) {
         this.getPrimaryKeyName = (model) => {
             return (pluralize_1.default.singular(model.name).toLowerCase() +
                 this.ucFirst(model.instance.primaryKey));
@@ -30,9 +32,8 @@ class RouterBuilder {
             return value.charAt(0).toUpperCase() + value.slice(1);
         };
         this.getRootPrefix = () => __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const config = yield Services_1.IoCService.use("Config");
-            let prefix = ((_a = config === null || config === void 0 ? void 0 : config.Application) === null || _a === void 0 ? void 0 : _a.prefix) || "api";
+            const api = Services_1.APIService.getInstance();
+            let prefix = api.config.prefix || "api";
             if (prefix.substr(0, 1) === "/") {
                 prefix = prefix.substr(1);
             }
@@ -41,32 +42,31 @@ class RouterBuilder {
             }
             return prefix;
         });
+        this.version = version;
     }
     build() {
         return __awaiter(this, void 0, void 0, function* () {
             const app = yield Services_1.IoCService.useByType("App");
-            const logger = yield Services_1.IoCService.useByType("LogService");
-            const modelTree = yield Services_1.IoCService.useByType("ModelTree");
-            const modelList = yield Services_1.IoCService.useByType("ModelListService");
-            const generalHooks = yield Resolvers_1.GeneralHookResolver.resolve();
+            const logger = Services_1.LogService.getInstance();
+            const generalHooks = yield new Resolvers_1.GeneralHookResolver(this.version).resolve();
             if (generalHooks.onBeforeInit) {
                 generalHooks.onBeforeInit(app);
             }
-            yield this.createRoutesByModelTree(modelTree, modelList);
-            logger.info("Express routes have been created.");
+            yield this.createRoutesByModelTree();
+            logger.info(`[${this.version.name}] Express routes have been created.`);
             if (generalHooks.onAfterInit) {
                 generalHooks.onAfterInit(app);
             }
         });
     }
-    createRoutesByModelTree(modelTree, modelList) {
+    createRoutesByModelTree() {
         return __awaiter(this, void 0, void 0, function* () {
-            for (const model of modelTree) {
-                yield this.createRouteByModel(model, modelList);
+            for (const model of this.version.modelTree) {
+                yield this.createRouteByModel(model);
             }
         });
     }
-    createRouteByModel(model, modelList, urlPrefix = "", parentModel = null, relation = null, allowRecursive = true) {
+    createRouteByModel(model, urlPrefix = "", parentModel = null, relation = null, allowRecursive = true) {
         return __awaiter(this, void 0, void 0, function* () {
             if (model.instance.ignore) {
                 return;
@@ -79,7 +79,7 @@ class RouterBuilder {
                     continue;
                 }
                 const urlCreator = constants_1.API_ROUTE_TEMPLATES[handlerType];
-                const url = urlCreator(yield this.getRootPrefix(), urlPrefix, resource, model.instance.primaryKey);
+                const url = urlCreator(path_1.default.join(yield this.getRootPrefix(), this.version.name), urlPrefix, resource, model.instance.primaryKey);
                 // Creating the middleware list for the route. As default, we support some
                 // internal middlewares such as `Accept Language Middleware` which parse
                 // the "accept-language" header to use in the application general.
@@ -90,11 +90,11 @@ class RouterBuilder {
                 // Adding the route to the express
                 yield this.addExpressRoute(handlerType, url, middlewares, model, parentModel, relation);
             }
-            yield this.createChildRoutes(model, modelList, resource, urlPrefix);
-            yield this.createNestedRoutes(model, modelList, allowRecursive, urlPrefix, resource);
+            yield this.createChildRoutes(model, resource, urlPrefix);
+            yield this.createNestedRoutes(model, allowRecursive, urlPrefix, resource);
         });
     }
-    createNestedRoutes(model, modelList, allowRecursive, urlPrefix, resource) {
+    createNestedRoutes(model, allowRecursive, urlPrefix, resource) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!model.isRecursive || !allowRecursive) {
                 return;
@@ -103,30 +103,29 @@ class RouterBuilder {
             const relation = model.relations.find((relation) => relation.model === model.name &&
                 relation.type === Enums_1.Relationships.HAS_MANY);
             if (relation) {
-                yield this.createRouteByModel(model, modelList, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation, false);
+                yield this.createRouteByModel(model, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation, false);
             }
         });
     }
-    createChildRoutes(model, modelList, resource, urlPrefix) {
+    createChildRoutes(model, resource, urlPrefix) {
         return __awaiter(this, void 0, void 0, function* () {
             if (model.children.length === 0) {
                 return;
             }
             // We should different parameter name for child routes
-            const primaryKey = this.getPrimaryKeyName(model);
             const subRelations = model.relations.filter((item) => item.type === Enums_1.Relationships.HAS_MANY);
             for (const relation of subRelations) {
                 const child = model.children.find((item) => item.name === relation.model);
                 // It should be recursive
                 if (child) {
-                    yield this.createRouteByModel(child, modelList, `${urlPrefix}${resource}/:${primaryKey}/`, model, relation);
+                    yield this.createRouteByModel(child, `${urlPrefix}${resource}/:${(0, change_case_1.camelCase)(relation.foreignKey)}/`, model, relation);
                 }
             }
         });
     }
     addExpressRoute(handlerType, url, middlewares, model, parentModel, relation) {
         return __awaiter(this, void 0, void 0, function* () {
-            const docs = yield Services_1.IoCService.useByType("DocumentationService");
+            const docs = Services_1.DocumentationService.getInstance();
             const app = yield Services_1.IoCService.useByType("App");
             const handler = (req, res) => {
                 this.requestHandler(handlerType, req, res, model, parentModel, relation);
@@ -140,6 +139,10 @@ class RouterBuilder {
                     app.delete(url, middlewares, handler);
                     docs.push(Enums_1.HttpMethods.DELETE, url, model);
                     break;
+                case Enums_1.HandlerTypes.FORCE_DELETE:
+                    app.delete(url, middlewares, handler);
+                    docs.push(Enums_1.HttpMethods.DELETE, url, model);
+                    break;
                 case Enums_1.HandlerTypes.INSERT:
                     app.post(url, middlewares, handler);
                     docs.push(Enums_1.HttpMethods.POST, url, model);
@@ -170,14 +173,16 @@ class RouterBuilder {
             let trx = null;
             let hasTransaction = false;
             try {
-                const factory = yield Services_1.IoCService.useByType("HandlerFactory");
                 const database = (yield Services_1.IoCService.use("Database"));
-                hasTransaction = yield Resolvers_1.TransactionResolver.resolve(model, handlerType);
+                const api = Services_1.APIService.getInstance();
+                hasTransaction = yield new Resolvers_1.TransactionResolver(this.version).resolve(model, handlerType);
                 if (hasTransaction) {
                     trx = yield database.transaction();
                 }
-                const handler = factory.get(handlerType);
+                const handler = HandlerFactory_1.default.get(handlerType);
                 const pack = {
+                    api,
+                    version: this.version,
                     req,
                     res,
                     handlerType,

package/build/src/Enums.d.ts

@@ -24,6 +24,7 @@ export declare enum HandlerTypes {
     SHOW = "show",
     UPDATE = "update",
     DELETE = "destroy",
+    FORCE_DELETE = "force_delete",
     PATCH = "patch",
     ALL = "all"
 }
@@ -33,6 +34,8 @@ export declare enum HookFunctionTypes {
     onBeforeUpdate = "onBeforeUpdate",
     onBeforeDeleteQuery = "onBeforeDeleteQuery",
     onBeforeDelete = "onBeforeDelete",
+    onBeforeForceDeleteQuery = "onBeforeForceDeleteQuery",
+    onBeforeForceDelete = "onBeforeForceDelete",
     onBeforePaginate = "onBeforePaginate",
     onBeforeAll = "onBeforeAll",
     onBeforeShow = "onBeforeShow",
@@ -41,6 +44,8 @@ export declare enum HookFunctionTypes {
     onAfterUpdate = "onAfterUpdate",
     onAfterDeleteQuery = "onAfterDeleteQuery",
     onAfterDelete = "onAfterDelete",
+    onAfterForceDeleteQuery = "onAfterForceDeleteQuery",
+    onAfterForceDelete = "onAfterForceDelete",
     onAfterPaginate = "onAfterPaginate",
     onAfterAll = "onAfterAll",
     onAfterShow = "onAfterShow"
@@ -75,3 +80,11 @@ export declare enum TimestampColumns {
     CREATED_AT = "createdAtColumn",
     UPDATED_AT = "updatedAtColumn"
 }
+export declare enum AxeErrorCode {
+    UNACCEPTABLE_VERSION_NAME = "UNACCEPTABLE_VERSION_NAME",
+    VERSION_CONFIG_NOT_FOUND = "VERSION_CONFIG_NOT_FOUND",
+    TABLE_DOESNT_HAVE_ANY_COLUMN = "TABLE_DOESNT_HAVE_ANY_COLUMN",
+    RESERVED_VERSION_NAME = "RESERVED_VERSION_NAME",
+    UNDEFINED_COLUMN = "UNDEFINED_COLUMN",
+    UNDEFINED_RELATION_MODEL = "UNDEFINED_RELATION_MODEL"
+}

package/build/src/Enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TimestampColumns = exports.SortTypes = exports.Relationships = exports.LogLevels = exports.HttpMethods = exports.Extensions = exports.HookFunctionTypes = exports.HandlerTypes = exports.DependencyTypes = exports.ConditionTypes = void 0;
+exports.AxeErrorCode = exports.TimestampColumns = exports.SortTypes = exports.Relationships = exports.LogLevels = exports.HttpMethods = exports.Extensions = exports.HookFunctionTypes = exports.HandlerTypes = exports.DependencyTypes = exports.ConditionTypes = void 0;
 var ConditionTypes;
 (function (ConditionTypes) {
     ConditionTypes["NotNull"] = "NotNull";
@@ -30,6 +30,7 @@ var HandlerTypes;
     HandlerTypes["SHOW"] = "show";
     HandlerTypes["UPDATE"] = "update";
     HandlerTypes["DELETE"] = "destroy";
+    HandlerTypes["FORCE_DELETE"] = "force_delete";
     HandlerTypes["PATCH"] = "patch";
     HandlerTypes["ALL"] = "all";
 })(HandlerTypes = exports.HandlerTypes || (exports.HandlerTypes = {}));
@@ -40,6 +41,8 @@ var HookFunctionTypes;
     HookFunctionTypes["onBeforeUpdate"] = "onBeforeUpdate";
     HookFunctionTypes["onBeforeDeleteQuery"] = "onBeforeDeleteQuery";
     HookFunctionTypes["onBeforeDelete"] = "onBeforeDelete";
+    HookFunctionTypes["onBeforeForceDeleteQuery"] = "onBeforeForceDeleteQuery";
+    HookFunctionTypes["onBeforeForceDelete"] = "onBeforeForceDelete";
     HookFunctionTypes["onBeforePaginate"] = "onBeforePaginate";
     HookFunctionTypes["onBeforeAll"] = "onBeforeAll";
     HookFunctionTypes["onBeforeShow"] = "onBeforeShow";
@@ -48,6 +51,8 @@ var HookFunctionTypes;
     HookFunctionTypes["onAfterUpdate"] = "onAfterUpdate";
     HookFunctionTypes["onAfterDeleteQuery"] = "onAfterDeleteQuery";
     HookFunctionTypes["onAfterDelete"] = "onAfterDelete";
+    HookFunctionTypes["onAfterForceDeleteQuery"] = "onAfterForceDeleteQuery";
+    HookFunctionTypes["onAfterForceDelete"] = "onAfterForceDelete";
     HookFunctionTypes["onAfterPaginate"] = "onAfterPaginate";
     HookFunctionTypes["onAfterAll"] = "onAfterAll";
     HookFunctionTypes["onAfterShow"] = "onAfterShow";
@@ -88,3 +93,12 @@ var TimestampColumns;
     TimestampColumns["CREATED_AT"] = "createdAtColumn";
     TimestampColumns["UPDATED_AT"] = "updatedAtColumn";
 })(TimestampColumns = exports.TimestampColumns || (exports.TimestampColumns = {}));
+var AxeErrorCode;
+(function (AxeErrorCode) {
+    AxeErrorCode["UNACCEPTABLE_VERSION_NAME"] = "UNACCEPTABLE_VERSION_NAME";
+    AxeErrorCode["VERSION_CONFIG_NOT_FOUND"] = "VERSION_CONFIG_NOT_FOUND";
+    AxeErrorCode["TABLE_DOESNT_HAVE_ANY_COLUMN"] = "TABLE_DOESNT_HAVE_ANY_COLUMN";
+    AxeErrorCode["RESERVED_VERSION_NAME"] = "RESERVED_VERSION_NAME";
+    AxeErrorCode["UNDEFINED_COLUMN"] = "UNDEFINED_COLUMN";
+    AxeErrorCode["UNDEFINED_RELATION_MODEL"] = "UNDEFINED_RELATION_MODEL";
+})(AxeErrorCode = exports.AxeErrorCode || (exports.AxeErrorCode = {}));

package/build/src/Exceptions/AxeError.d.ts

@@ -0,0 +1,8 @@
+import { AxeErrorCode } from "src/Enums";
+declare class AxeError extends Error {
+    type: string;
+    code: AxeErrorCode;
+    message: string;
+    constructor(code: AxeErrorCode, message: string);
+}
+export default AxeError;

package/build/src/Exceptions/AxeError.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AxeError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.type = "AxeError";
+        this.code = code;
+        this.message = message;
+    }
+}
+exports.default = AxeError;

package/build/src/Handlers/AllHandler.js

@@ -13,13 +13,14 @@ const Helpers_1 = require("./Helpers");
 const Services_1 = require("../Services");
 const Enums_1 = require("../Enums");
 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());
+    const { version, model, req, res, database, relation, parentModel } = pack;
+    const queryParser = new Services_1.QueryService(model, version.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);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, conditions, query);
     // Users should be able to select some fields to show.
     queryParser.applyFields(query, conditions.fields);
     // Binding parent id if there is.
@@ -32,12 +33,12 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     queryParser.applySorting(query, conditions.sort);
     let result = yield query;
     // We should try to get related data if there is any
-    yield (0, Helpers_1.getRelatedData)(result, conditions.with, model, modelList, database, Enums_1.HandlerTypes.ALL, req);
+    yield (0, Helpers_1.getRelatedData)(version, result, conditions.with, model, version.modelList, database, Enums_1.HandlerTypes.ALL, req);
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterAll, Object.assign(Object.assign({}, pack), { result,
         conditions,
         query }));
     // Serializing the data by the model's serialize method
-    result = yield (0, Helpers_1.serializeData)(result, model.instance.serialize, Enums_1.HandlerTypes.ALL, req);
+    result = yield (0, Helpers_1.serializeData)(version, result, model.serialize, Enums_1.HandlerTypes.ALL, req);
     // Filtering hidden fields from the response data.
     (0, Helpers_1.filterHiddenFields)(result, model.instance.hiddens);
     return res.json(result);

package/build/src/Handlers/DestroyHandler.js

@@ -20,6 +20,8 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     const query = database
         .from(model.instance.table)
         .where(model.instance.primaryKey, req.params[model.instance.primaryKey]);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, null, query);
     // 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.onBeforeDeleteQuery, Object.assign(Object.assign({}, pack), { query }));
@@ -31,7 +33,15 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         item }));
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeDelete, Object.assign(Object.assign({}, pack), { query,
         item }));
-    yield query.delete();
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    if (model.instance.deletedAtColumn) {
+        yield query.update({
+            [model.instance.deletedAtColumn]: new Date(),
+        });
+    }
+    else {
+        yield query.delete();
+    }
     yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterDelete, Object.assign(Object.assign({}, pack), { item }));
     return res.json();
 });

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

@@ -0,0 +1,3 @@
+import { Request, Response } from "express";
+declare const _default: (req: Request, res: Response) => Promise<void>;
+export default _default;

package/build/src/Handlers/DocsHandler.js

@@ -0,0 +1,22 @@
+"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 Services_1 = require("../Services");
+exports.default = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const docs = Services_1.DocumentationService.getInstance();
+    const api = Services_1.APIService.getInstance();
+    res.json({
+        routes: docs.get(),
+        versions: api.versions.map((version) => {
+            return Object.assign(Object.assign({}, version), { config: Object.assign(Object.assign({}, version.config), { transaction: undefined }), folders: undefined, modelList: undefined, models: version.modelList.get() });
+        }),
+    });
+});

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

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

package/build/src/Handlers/ForceDestroyHandler.js

@@ -0,0 +1,41 @@
+"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"));
+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)
+        .where(model.instance.primaryKey, req.params[model.instance.primaryKey]);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    if (model.instance.deletedAtColumn === null) {
+        throw new ApiError_1.default("You can use force delete only soft-delete supported models.");
+    }
+    // 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.onBeforeForceDeleteQuery, Object.assign(Object.assign({}, pack), { query }));
+    const item = yield query.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.onAfterForceDeleteQuery, Object.assign(Object.assign({}, pack), { query,
+        item }));
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeForceDelete, Object.assign(Object.assign({}, pack), { query,
+        item }));
+    yield query.delete();
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterForceDelete, Object.assign(Object.assign({}, pack), { item }));
+    return res.json();
+});

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

@@ -1,6 +1,6 @@
 import { IRequestPack } from "../Interfaces";
 import { HandlerTypes } from "../Enums";
 declare class HandlerFactory {
-    get(handleType: HandlerTypes): (pack: IRequestPack) => void;
+    static get(handleType: HandlerTypes): (pack: IRequestPack) => void;
 }
 export default HandlerFactory;

package/build/src/Handlers/HandlerFactory.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const AllHandler_1 = __importDefault(require("./AllHandler"));
 const DestroyHandler_1 = __importDefault(require("./DestroyHandler"));
+const ForceDestroyHandler_1 = __importDefault(require("./ForceDestroyHandler"));
 const PaginateHandler_1 = __importDefault(require("./PaginateHandler"));
 const PatchHandler_1 = __importDefault(require("./PatchHandler"));
 const UpdateHandler_1 = __importDefault(require("./UpdateHandler"));
@@ -12,12 +13,14 @@ const ShowHandler_1 = __importDefault(require("./ShowHandler"));
 const StoreHandler_1 = __importDefault(require("./StoreHandler"));
 const Enums_1 = require("../Enums");
 class HandlerFactory {
-    get(handleType) {
+    static 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.FORCE_DELETE:
+                return ForceDestroyHandler_1.default;
             case Enums_1.HandlerTypes.INSERT:
                 return StoreHandler_1.default;
             case Enums_1.HandlerTypes.PAGINATE:

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

@@ -1,14 +1,16 @@
 import { Request } from "express";
-import { IModelService, IRelation, IHookParameter } from "../Interfaces";
+import { IModelService, IRelation, IHookParameter, IQuery, IVersion } from "../Interfaces";
 import { Knex } from "knex";
 import { IWith } from "../Interfaces";
 import { HandlerTypes, HookFunctionTypes, TimestampColumns } from "../Enums";
 import { ModelListService } from "../Services";
+import { SerializationFunction } from "../Types";
 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 serializeData: (version: IVersion, itemArray: any[] | any, modelSerializer: SerializationFunction | null, 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>;
+export declare const addSoftDeleteQuery: (model: IModelService, conditions: IQuery | null, query: Knex.QueryBuilder) => void;
+export declare const getRelatedData: (version: IVersion, data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: Request) => Promise<void>;

package/build/src/Handlers/Helpers.js

@@ -12,7 +12,7 @@ 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;
+exports.getRelatedData = exports.addSoftDeleteQuery = 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"));
@@ -30,7 +30,7 @@ const bindTimestampValues = (formData, columnTypes = [], model) => {
 exports.bindTimestampValues = bindTimestampValues;
 const getMergedFormData = (req, fillables) => {
     const formData = {};
-    Object.keys(req.body).forEach((key) => {
+    Object.keys((req === null || req === void 0 ? void 0 : req.body) || {}).forEach((key) => {
         if (fillables.includes(key)) {
             formData[key] = req.body[key];
         }
@@ -92,14 +92,13 @@ const serialize = (data, callback, 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) {
+const globalSerializer = (version, itemArray, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!version.config.serializers) {
         return itemArray;
     }
     const callbacks = [];
     // Push all runable serializer into callbacks.
-    Application.serializers.map((configSerializer) => {
+    version.config.serializers.map((configSerializer) => {
         // Serialize data for all requests types.
         if (typeof configSerializer === "function") {
             callbacks.push(configSerializer);
@@ -116,9 +115,9 @@ const globalSerializer = (itemArray, handler, request) => __awaiter(void 0, void
     });
     return itemArray;
 });
-const serializeData = (itemArray, modelSerializer, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+const serializeData = (version, itemArray, modelSerializer, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
     itemArray = serialize(itemArray, modelSerializer, request);
-    itemArray = yield globalSerializer(itemArray, handler, request);
+    itemArray = yield globalSerializer(version, itemArray, handler, request);
     return itemArray;
 });
 exports.serializeData = serializeData;
@@ -138,7 +137,15 @@ const filterHiddenFields = (itemArray, hiddens) => {
     });
 };
 exports.filterHiddenFields = filterHiddenFields;
-const getRelatedData = (data, withArray, model, modelList, database, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
+const addSoftDeleteQuery = (model, conditions, query) => {
+    // TODO: Trashed feature will be implemented later
+    // (conditions === null || conditions?.trashed === false)
+    if (model.instance.deletedAtColumn) {
+        query.whereNull(model.instance.deletedAtColumn);
+    }
+};
+exports.addSoftDeleteQuery = addSoftDeleteQuery;
+const getRelatedData = (version, data, withArray, model, modelList, database, handler, request) => __awaiter(void 0, void 0, void 0, function* () {
     if (withArray.length === 0) {
         return;
     }
@@ -192,17 +199,20 @@ const getRelatedData = (data, withArray, model, modelList, database, handler, re
             selectColumns.push(...requiredForeignKeys);
         }
         selectColumns = uniqueByMap(selectColumns);
+        const foreignModelQuery = database(foreignModel.instance.table).select(selectColumns);
+        // If the model is supported soft-delete we should check the data.
+        if (foreignModel.instance.deletedAtColumn) {
+            foreignModelQuery.whereNull(foreignModel.instance.deletedAtColumn);
+        }
         // Fetching related records by foreignKey and primary key values.
-        let relatedRecords = yield database(foreignModel.instance.table)
-            .select(selectColumns)
-            .whereIn(searchFieldKey, parentPrimaryKeyValues);
+        let relatedRecords = yield foreignModelQuery.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);
+        relatedRecords = yield (0, exports.serializeData)(version, relatedRecords, foreignModel.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);
+            yield (0, exports.getRelatedData)(version, relatedRecords, clientQuery.children, foreignModel, modelList, database, handler, request);
         }
         // Binding relation data to the parent rows.
         data.forEach((row) => {

package/build/src/Handlers/PaginateHandler.js

@@ -13,13 +13,14 @@ 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());
+    const { version, model, req, database, relation, parentModel } = pack;
+    const queryParser = new Services_1.QueryService(model, version.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);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, conditions, query);
     // Users should be able to select some fields to show.
     queryParser.applyFields(query, conditions.fields);
     // Binding parent id if there is.
@@ -36,12 +37,12 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         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.getRelatedData)(version, result.data, conditions.with, model, version.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);
+    result.data = yield (0, Helpers_1.serializeData)(version, result.data, model.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.js

@@ -17,10 +17,12 @@ 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 { version, 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);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(model, null, query);
     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])
@@ -58,7 +60,7 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
         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);
+    item = yield (0, Helpers_1.serializeData)(version, item, model.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/RoutesHandler.d.ts

@@ -0,0 +1,3 @@
+import { Request, Response } from "express";
+declare const _default: (req: Request, res: Response) => Promise<void>;
+export default _default;

package/build/src/Handlers/RoutesHandler.js

@@ -0,0 +1,16 @@
+"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 Services_1 = require("../Services");
+exports.default = (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+    const docs = Services_1.DocumentationService.getInstance();
+    res.json(docs.get().map((route) => `${route.method} ${route.url}`));
+});