axe-api 0.20.1 → 0.20.2

package/build/index.d.ts

@@ -0,0 +1,8 @@
+import Server from "./src/Server";
+import Model from "./src/Model";
+import ApiError from "./src/Exceptions/ApiError";
+import { DEFAULT_HANDLERS } from "./src/constants";
+import { IoCService } from "./src/Services";
+export * from "./src/Enums";
+export * from "./src/Interfaces";
+export { Server, Model, ApiError, DEFAULT_HANDLERS, IoCService };

package/build/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IoCService = exports.DEFAULT_HANDLERS = exports.ApiError = exports.Model = exports.Server = void 0;
+const Server_1 = __importDefault(require("./src/Server"));
+exports.Server = Server_1.default;
+const Model_1 = __importDefault(require("./src/Model"));
+exports.Model = Model_1.default;
+const ApiError_1 = __importDefault(require("./src/Exceptions/ApiError"));
+exports.ApiError = ApiError_1.default;
+const constants_1 = require("./src/constants");
+Object.defineProperty(exports, "DEFAULT_HANDLERS", { enumerable: true, get: function () { return constants_1.DEFAULT_HANDLERS; } });
+const Services_1 = require("./src/Services");
+Object.defineProperty(exports, "IoCService", { enumerable: true, get: function () { return Services_1.IoCService; } });
+__exportStar(require("./src/Enums"), exports);
+__exportStar(require("./src/Interfaces"), exports);

package/build/src/Builders/ModelTreeBuilder.d.ts

@@ -0,0 +1,9 @@
+declare class ModelTreeBuilder {
+    build(): Promise<void>;
+    private getRootLevelOfTree;
+    private createRecursiveTree;
+    private setChildrens;
+    private getChildModelNames;
+    private addNestedRoutes;
+}
+export default ModelTreeBuilder;

package/build/src/Builders/ModelTreeBuilder.js

@@ -0,0 +1,64 @@
+"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 Enums_1 = require("../Enums");
+const Services_1 = require("../Services");
+class ModelTreeBuilder {
+    build() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logger = yield Services_1.IoCService.useByType("LogService");
+            const modelList = yield Services_1.IoCService.useByType("ModelListService");
+            const tree = this.getRootLevelOfTree(modelList);
+            this.createRecursiveTree(tree, modelList);
+            this.addNestedRoutes(tree, modelList);
+            Services_1.IoCService.singleton("ModelTree", () => tree);
+            logger.info("Model tree has been created.");
+        });
+    }
+    getRootLevelOfTree(modelList) {
+        const childModels = [];
+        modelList.get().forEach((model) => {
+            childModels.push(...model.relations
+                .filter((relation) => relation.type === Enums_1.Relationships.HAS_MANY)
+                .map((relation) => relation.model));
+        });
+        return modelList.get().filter((model) => !childModels.includes(model.name));
+    }
+    createRecursiveTree(tree, modelList) {
+        for (const model of tree) {
+            this.setChildrens(model, modelList);
+        }
+    }
+    setChildrens(model, modelList) {
+        const childModelNames = this.getChildModelNames(model);
+        model.children = modelList
+            .get()
+            .filter((item) => childModelNames.includes(item.name));
+        for (const child of model.children) {
+            this.setChildrens(child, modelList);
+        }
+    }
+    getChildModelNames(model) {
+        return model.relations
+            .filter((item) => item.type === Enums_1.Relationships.HAS_MANY)
+            .map((item) => item.model);
+    }
+    addNestedRoutes(tree, modelList) {
+        // We should add recursive models
+        modelList.get().forEach((model) => {
+            const recursiveRelations = model.relations.filter((relation) => relation.model === model.name);
+            if (recursiveRelations.length === 2) {
+                tree.push(Object.assign(Object.assign({}, model), { isRecursive: true, children: [] }));
+            }
+        });
+    }
+}
+exports.default = ModelTreeBuilder;

package/build/src/Builders/RouterBuilder.d.ts

@@ -0,0 +1,15 @@
+declare class RouterBuilder {
+    build(): Promise<void>;
+    private createRoutesByModelTree;
+    private createRouteByModel;
+    private createNestedRoutes;
+    private createChildRoutes;
+    private getPrimaryKeyName;
+    private ucFirst;
+    private addExpressRoute;
+    private requestHandler;
+    private sendErrorAsResponse;
+    private getResourcePath;
+    private getRootPrefix;
+}
+export default RouterBuilder;

package/build/src/Builders/RouterBuilder.js

@@ -0,0 +1,219 @@
+"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 pluralize_1 = __importDefault(require("pluralize"));
+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 Services_1 = require("../Services");
+class RouterBuilder {
+    constructor() {
+        this.getPrimaryKeyName = (model) => {
+            return (pluralize_1.default.singular(model.name).toLowerCase() +
+                this.ucFirst(model.instance.primaryKey));
+        };
+        this.ucFirst = (value) => {
+            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";
+            if (prefix.substr(0, 1) === "/") {
+                prefix = prefix.substr(1);
+            }
+            if (prefix.substr(prefix.length - 1) === "/") {
+                prefix = prefix.substr(0, prefix.length - 1);
+            }
+            return prefix;
+        });
+    }
+    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();
+            if (generalHooks.onBeforeInit) {
+                generalHooks.onBeforeInit(app);
+            }
+            yield this.createRoutesByModelTree(modelTree, modelList);
+            if (generalHooks.onAfterInit) {
+                generalHooks.onAfterInit(app);
+            }
+            logger.info("Express routes have been created.");
+        });
+    }
+    createRoutesByModelTree(modelTree, modelList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const model of modelTree) {
+                yield this.createRouteByModel(model, modelList);
+            }
+        });
+    }
+    createRouteByModel(model, modelList, urlPrefix = "", parentModel = null, relation = null, allowRecursive = true) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (model.instance.ignore) {
+                return;
+            }
+            const resource = this.getResourcePath(model, relation);
+            // We create and handle routes by not duplicate so many lines.
+            for (const handler of Object.keys(constants_1.API_ROUTE_TEMPLATES)) {
+                const handlerType = handler;
+                if (!model.instance.handlers.includes(handlerType)) {
+                    continue;
+                }
+                const urlCreator = constants_1.API_ROUTE_TEMPLATES[handlerType];
+                const url = urlCreator(yield this.getRootPrefix(), urlPrefix, resource, model.instance.primaryKey);
+                // Detecting filters
+                const middlewares = model.instance.getMiddlewares(handlerType);
+                // 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);
+        });
+    }
+    createNestedRoutes(model, modelList, allowRecursive, urlPrefix, resource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!model.isRecursive || !allowRecursive) {
+                return;
+            }
+            // We should different parameter name for child routes
+            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);
+            }
+        });
+    }
+    createChildRoutes(model, modelList, 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);
+                }
+            }
+        });
+    }
+    addExpressRoute(handlerType, url, middlewares, model, parentModel, relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const docs = yield Services_1.IoCService.useByType("DocumentationService");
+            const app = yield Services_1.IoCService.useByType("App");
+            const handler = (req, res) => {
+                this.requestHandler(handlerType, req, res, model, parentModel, relation);
+            };
+            switch (handlerType) {
+                case Enums_1.HandlerTypes.ALL:
+                    app.get(url, middlewares, handler);
+                    docs.push(Enums_1.HttpMethods.GET, url, model);
+                    break;
+                case Enums_1.HandlerTypes.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);
+                    break;
+                case Enums_1.HandlerTypes.PAGINATE:
+                    app.get(url, middlewares, handler);
+                    docs.push(Enums_1.HttpMethods.GET, url, model);
+                    break;
+                case Enums_1.HandlerTypes.PATCH:
+                    app.patch(url, middlewares, handler);
+                    docs.push(Enums_1.HttpMethods.PATCH, url, model);
+                    break;
+                case Enums_1.HandlerTypes.SHOW:
+                    app.get(url, middlewares, handler);
+                    docs.push(Enums_1.HttpMethods.GET, url, model);
+                    break;
+                case Enums_1.HandlerTypes.UPDATE:
+                    app.put(url, middlewares, handler);
+                    docs.push(Enums_1.HttpMethods.PUT, url, model);
+                    break;
+                default:
+                    throw new Error("Undefined handler type");
+            }
+        });
+    }
+    requestHandler(handlerType, req, res, model, parentModel, relation) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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);
+                if (hasTransaction) {
+                    trx = yield database.transaction();
+                }
+                const handler = factory.get(handlerType);
+                const pack = {
+                    req,
+                    res,
+                    handlerType,
+                    model,
+                    parentModel,
+                    relation,
+                    database: hasTransaction && trx ? trx : database,
+                };
+                yield handler(pack);
+                if (hasTransaction && trx) {
+                    trx.commit();
+                }
+            }
+            catch (error) {
+                if (hasTransaction && trx) {
+                    trx.rollback();
+                }
+                this.sendErrorAsResponse(res, error);
+            }
+        });
+    }
+    sendErrorAsResponse(res, error) {
+        const type = error.type;
+        switch (type) {
+            case "ApiError":
+                // eslint-disable-next-line no-case-declarations
+                const apiError = error;
+                res.status(apiError.status).json({
+                    error: apiError.message,
+                });
+                break;
+            default:
+                res.status(http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR).json({
+                    error: "An error occurred.",
+                });
+                break;
+        }
+    }
+    getResourcePath(model, relation) {
+        return relation
+            ? (0, change_case_1.paramCase)(relation.name)
+            : (0, change_case_1.paramCase)(pluralize_1.default.plural(model.name)).toLowerCase();
+    }
+}
+exports.default = RouterBuilder;

package/build/src/Builders/index.d.ts

@@ -0,0 +1,3 @@
+import ModelTreeBuilder from "./ModelTreeBuilder";
+import RouterBuilder from "./RouterBuilder";
+export { ModelTreeBuilder, RouterBuilder };

package/build/src/Builders/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterBuilder = exports.ModelTreeBuilder = void 0;
+const ModelTreeBuilder_1 = __importDefault(require("./ModelTreeBuilder"));
+exports.ModelTreeBuilder = ModelTreeBuilder_1.default;
+const RouterBuilder_1 = __importDefault(require("./RouterBuilder"));
+exports.RouterBuilder = RouterBuilder_1.default;

package/build/src/Enums.d.ts

@@ -0,0 +1,77 @@
+export declare enum ConditionTypes {
+    NotNull = "NotNull",
+    Null = "Null",
+    "=" = "=",
+    "<>" = "<>",
+    ">" = ">",
+    ">=" = ">=",
+    "<" = "<",
+    "<=" = "<=",
+    "LIKE" = "LIKE",
+    "NOT LIKE" = "NOT LIKE",
+    "In" = "In",
+    "NotIn" = "NotIn",
+    "Between" = "Between",
+    "NotBetween" = "NotBetween"
+}
+export declare enum DependencyTypes {
+    BIND = "BIND",
+    SINGLETON = "SINGLETON"
+}
+export declare enum HandlerTypes {
+    INSERT = "store",
+    PAGINATE = "paginate",
+    SHOW = "show",
+    UPDATE = "update",
+    DELETE = "destroy",
+    PATCH = "patch",
+    ALL = "all"
+}
+export declare enum HookFunctionTypes {
+    onBeforeInsert = "onBeforeInsert",
+    onBeforeUpdateQuery = "onBeforeUpdateQuery",
+    onBeforeUpdate = "onBeforeUpdate",
+    onBeforeDeleteQuery = "onBeforeDeleteQuery",
+    onBeforeDelete = "onBeforeDelete",
+    onBeforePaginate = "onBeforePaginate",
+    onBeforeAll = "onBeforeAll",
+    onBeforeShow = "onBeforeShow",
+    onAfterInsert = "onAfterInsert",
+    onAfterUpdateQuery = "onAfterUpdateQuery",
+    onAfterUpdate = "onAfterUpdate",
+    onAfterDeleteQuery = "onAfterDeleteQuery",
+    onAfterDelete = "onAfterDelete",
+    onAfterPaginate = "onAfterPaginate",
+    onAfterAll = "onAfterAll",
+    onAfterShow = "onAfterShow"
+}
+export declare enum Extensions {
+    Hooks = "Hooks",
+    Events = "Events"
+}
+export declare enum HttpMethods {
+    POST = "POST",
+    PUT = "PUT",
+    PATCH = "PATCH",
+    GET = "GET",
+    DELETE = "DELETE"
+}
+export declare enum LogLevels {
+    NONE = 0,
+    ERROR = 1,
+    WARNING = 2,
+    INFO = 3,
+    ALL = 4
+}
+export declare enum Relationships {
+    HAS_ONE = "HAS_ONE",
+    HAS_MANY = "HAS_MANY"
+}
+export declare enum SortTypes {
+    ASC = "ASC",
+    DESC = "DESC"
+}
+export declare enum TimestampColumns {
+    CREATED_AT = "createdAtColumn",
+    UPDATED_AT = "updatedAtColumn"
+}

package/build/src/Enums.js

@@ -0,0 +1,90 @@
+"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;
+var ConditionTypes;
+(function (ConditionTypes) {
+    ConditionTypes["NotNull"] = "NotNull";
+    ConditionTypes["Null"] = "Null";
+    ConditionTypes["="] = "=";
+    ConditionTypes["<>"] = "<>";
+    ConditionTypes[">"] = ">";
+    ConditionTypes[">="] = ">=";
+    ConditionTypes["<"] = "<";
+    ConditionTypes["<="] = "<=";
+    ConditionTypes["LIKE"] = "LIKE";
+    ConditionTypes["NOT LIKE"] = "NOT LIKE";
+    ConditionTypes["In"] = "In";
+    ConditionTypes["NotIn"] = "NotIn";
+    ConditionTypes["Between"] = "Between";
+    ConditionTypes["NotBetween"] = "NotBetween";
+})(ConditionTypes = exports.ConditionTypes || (exports.ConditionTypes = {}));
+var DependencyTypes;
+(function (DependencyTypes) {
+    DependencyTypes["BIND"] = "BIND";
+    DependencyTypes["SINGLETON"] = "SINGLETON";
+})(DependencyTypes = exports.DependencyTypes || (exports.DependencyTypes = {}));
+var HandlerTypes;
+(function (HandlerTypes) {
+    HandlerTypes["INSERT"] = "store";
+    HandlerTypes["PAGINATE"] = "paginate";
+    HandlerTypes["SHOW"] = "show";
+    HandlerTypes["UPDATE"] = "update";
+    HandlerTypes["DELETE"] = "destroy";
+    HandlerTypes["PATCH"] = "patch";
+    HandlerTypes["ALL"] = "all";
+})(HandlerTypes = exports.HandlerTypes || (exports.HandlerTypes = {}));
+var HookFunctionTypes;
+(function (HookFunctionTypes) {
+    HookFunctionTypes["onBeforeInsert"] = "onBeforeInsert";
+    HookFunctionTypes["onBeforeUpdateQuery"] = "onBeforeUpdateQuery";
+    HookFunctionTypes["onBeforeUpdate"] = "onBeforeUpdate";
+    HookFunctionTypes["onBeforeDeleteQuery"] = "onBeforeDeleteQuery";
+    HookFunctionTypes["onBeforeDelete"] = "onBeforeDelete";
+    HookFunctionTypes["onBeforePaginate"] = "onBeforePaginate";
+    HookFunctionTypes["onBeforeAll"] = "onBeforeAll";
+    HookFunctionTypes["onBeforeShow"] = "onBeforeShow";
+    HookFunctionTypes["onAfterInsert"] = "onAfterInsert";
+    HookFunctionTypes["onAfterUpdateQuery"] = "onAfterUpdateQuery";
+    HookFunctionTypes["onAfterUpdate"] = "onAfterUpdate";
+    HookFunctionTypes["onAfterDeleteQuery"] = "onAfterDeleteQuery";
+    HookFunctionTypes["onAfterDelete"] = "onAfterDelete";
+    HookFunctionTypes["onAfterPaginate"] = "onAfterPaginate";
+    HookFunctionTypes["onAfterAll"] = "onAfterAll";
+    HookFunctionTypes["onAfterShow"] = "onAfterShow";
+})(HookFunctionTypes = exports.HookFunctionTypes || (exports.HookFunctionTypes = {}));
+var Extensions;
+(function (Extensions) {
+    Extensions["Hooks"] = "Hooks";
+    Extensions["Events"] = "Events";
+})(Extensions = exports.Extensions || (exports.Extensions = {}));
+var HttpMethods;
+(function (HttpMethods) {
+    HttpMethods["POST"] = "POST";
+    HttpMethods["PUT"] = "PUT";
+    HttpMethods["PATCH"] = "PATCH";
+    HttpMethods["GET"] = "GET";
+    HttpMethods["DELETE"] = "DELETE";
+})(HttpMethods = exports.HttpMethods || (exports.HttpMethods = {}));
+var LogLevels;
+(function (LogLevels) {
+    LogLevels[LogLevels["NONE"] = 0] = "NONE";
+    LogLevels[LogLevels["ERROR"] = 1] = "ERROR";
+    LogLevels[LogLevels["WARNING"] = 2] = "WARNING";
+    LogLevels[LogLevels["INFO"] = 3] = "INFO";
+    LogLevels[LogLevels["ALL"] = 4] = "ALL";
+})(LogLevels = exports.LogLevels || (exports.LogLevels = {}));
+var Relationships;
+(function (Relationships) {
+    Relationships["HAS_ONE"] = "HAS_ONE";
+    Relationships["HAS_MANY"] = "HAS_MANY";
+})(Relationships = exports.Relationships || (exports.Relationships = {}));
+var SortTypes;
+(function (SortTypes) {
+    SortTypes["ASC"] = "ASC";
+    SortTypes["DESC"] = "DESC";
+})(SortTypes = exports.SortTypes || (exports.SortTypes = {}));
+var TimestampColumns;
+(function (TimestampColumns) {
+    TimestampColumns["CREATED_AT"] = "createdAtColumn";
+    TimestampColumns["UPDATED_AT"] = "updatedAtColumn";
+})(TimestampColumns = exports.TimestampColumns || (exports.TimestampColumns = {}));

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

@@ -0,0 +1,8 @@
+import { StatusCodes } from "http-status-codes";
+declare class ApiError extends Error {
+    type: string;
+    status: StatusCodes;
+    message: string;
+    constructor(message: string);
+}
+export default ApiError;

package/build/src/Exceptions/ApiError.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const http_status_codes_1 = require("http-status-codes");
+class ApiError extends Error {
+    constructor(message) {
+        super(message);
+        this.type = "ApiError";
+        this.status = http_status_codes_1.StatusCodes.BAD_REQUEST;
+        this.message = message;
+    }
+}
+exports.default = ApiError;

package/build/src/Handlers/AllHandler.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/AllHandler.js

@@ -0,0 +1,44 @@
+"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 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());
+    // 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);
+    // Users should be able to filter records
+    queryParser.applyWheres(query, conditions.q);
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeAll, Object.assign(Object.assign({}, pack), { conditions,
+        query }));
+    // User should be able to select sorting fields and types
+    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.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);
+    // Filtering hidden fields from the response data.
+    (0, Helpers_1.filterHiddenFields)(result, model.instance.hiddens);
+    return res.json(result);
+});

package/build/src/Handlers/DestroyHandler.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/DestroyHandler.js

@@ -0,0 +1,37 @@
+"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 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 }));
+    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.onAfterDeleteQuery, Object.assign(Object.assign({}, pack), { query,
+        item }));
+    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onBeforeDelete, Object.assign(Object.assign({}, pack), { query,
+        item }));
+    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/HandlerFactory.d.ts

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