axe-api 0.20.0-rc4 → 0.20.0-rc5

package/build/index.js

@@ -1,30 +1,7 @@
-"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.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; } });
-__exportStar(require("./src/Enums"), exports);
-__exportStar(require("./src/Interfaces"), exports);
+import Server from "./src/Server";
+import Model from "./src/Model";
+import ApiError from "./src/Exceptions/ApiError";
+import { DEFAULT_HANDLERS } from "./src/constants";
+export * from "./src/Enums";
+export * from "./src/Interfaces";
+export { Server, Model, ApiError, DEFAULT_HANDLERS };

package/build/src/Builders/ModelTreeBuilder.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,18 +7,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const Enums_1 = require("../Enums");
-const Services_1 = require("../Services");
+import { Relationships } from "../Enums";
+import { IoCService } from "../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 logger = yield IoCService.useByType("LogService");
+            const modelList = yield IoCService.useByType("ModelListService");
             const tree = this.getRootLevelOfTree(modelList);
             this.createRecursiveTree(tree, modelList);
             this.addNestedRoutes(tree, modelList);
-            Services_1.IoCService.singleton("ModelTree", () => tree);
+            IoCService.singleton("ModelTree", () => tree);
             logger.info("Model tree has been created.");
         });
     }
@@ -27,7 +25,7 @@ class ModelTreeBuilder {
         const childModels = [];
         modelList.get().forEach((model) => {
             childModels.push(...model.relations
-                .filter((relation) => relation.type === Enums_1.Relationships.HAS_MANY)
+                .filter((relation) => relation.type === Relationships.HAS_MANY)
                 .map((relation) => relation.model));
         });
         return modelList.get().filter((model) => !childModels.includes(model.name));
@@ -48,7 +46,7 @@ class ModelTreeBuilder {
     }
     getChildModelNames(model) {
         return model.relations
-            .filter((item) => item.type === Enums_1.Relationships.HAS_MANY)
+            .filter((item) => item.type === Relationships.HAS_MANY)
             .map((item) => item.model);
     }
     addNestedRoutes(tree, modelList) {
@@ -61,4 +59,4 @@ class ModelTreeBuilder {
         });
     }
 }
-exports.default = ModelTreeBuilder;
+export default ModelTreeBuilder;

package/build/src/Builders/RouterBuilder.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,21 +7,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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");
+import pluralize from "pluralize";
+import { StatusCodes } from "http-status-codes";
+import { paramCase, camelCase } from "change-case";
+import { GeneralHookResolver, TransactionResolver, ModelMiddlewareResolver, } from "../Resolvers";
+import { API_ROUTE_TEMPLATES } from "../constants";
+import { HandlerTypes, Relationships, HttpMethods } from "../Enums";
+import { IoCService, } from "../Services";
 class RouterBuilder {
     constructor() {
         this.getPrimaryKeyName = (model) => {
-            return (pluralize_1.default.singular(model.name).toLowerCase() +
+            return (pluralize.singular(model.name).toLowerCase() +
                 this.ucFirst(model.instance.primaryKey));
         };
         this.ucFirst = (value) => {
@@ -30,7 +25,7 @@ class RouterBuilder {
         };
         this.getRootPrefix = () => __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const config = yield Services_1.IoCService.use("Config");
+            const config = yield 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);
@@ -43,10 +38,10 @@ class RouterBuilder {
     }
     build() {
         return __awaiter(this, void 0, void 0, function* () {
-            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 = yield IoCService.useByType("LogService");
+            const modelTree = yield IoCService.useByType("ModelTree");
+            const modelList = yield IoCService.useByType("ModelListService");
+            const generalHooks = yield GeneralHookResolver.resolve();
             if (generalHooks.onBeforeInit) {
                 generalHooks.onBeforeInit();
             }
@@ -71,15 +66,15 @@ class RouterBuilder {
             }
             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)) {
+            for (const handler of Object.keys(API_ROUTE_TEMPLATES)) {
                 const handlerType = handler;
                 if (!model.instance.handlers.includes(handlerType)) {
                     continue;
                 }
-                const urlCreator = constants_1.API_ROUTE_TEMPLATES[handlerType];
+                const urlCreator = API_ROUTE_TEMPLATES[handlerType];
                 const url = urlCreator(yield this.getRootPrefix(), urlPrefix, resource, model.instance.primaryKey);
                 // Detecting filters
-                const middlewares = Resolvers_1.ModelMiddlewareResolver.resolve(model, handlerType);
+                const middlewares = ModelMiddlewareResolver.resolve(model, handlerType);
                 // Adding the route to the express
                 yield this.addExpressRoute(handlerType, url, middlewares, model, parentModel, relation);
             }
@@ -94,9 +89,9 @@ class RouterBuilder {
             }
             // 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);
+                relation.type === 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, modelList, `${urlPrefix}${resource}/:${camelCase(relation.foreignKey)}/`, model, relation, false);
             }
         });
     }
@@ -107,7 +102,7 @@ class RouterBuilder {
             }
             // 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);
+            const subRelations = model.relations.filter((item) => item.type === Relationships.HAS_MANY);
             for (const relation of subRelations) {
                 const child = model.children.find((item) => item.name === relation.model);
                 // It should be recursive
@@ -119,39 +114,39 @@ class RouterBuilder {
     }
     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 docs = yield IoCService.useByType("DocumentationService");
+            const app = yield IoCService.useByType("App");
             const handler = (req, res) => {
                 this.requestHandler(handlerType, req, res, model, parentModel, relation);
             };
             switch (handlerType) {
-                case Enums_1.HandlerTypes.ALL:
+                case HandlerTypes.ALL:
                     app.get(url, middlewares, handler);
-                    docs.push(Enums_1.HttpMethods.GET, url, model);
+                    docs.push(HttpMethods.GET, url, model);
                     break;
-                case Enums_1.HandlerTypes.DELETE:
+                case HandlerTypes.DELETE:
                     app.delete(url, middlewares, handler);
-                    docs.push(Enums_1.HttpMethods.DELETE, url, model);
+                    docs.push(HttpMethods.DELETE, url, model);
                     break;
-                case Enums_1.HandlerTypes.INSERT:
+                case HandlerTypes.INSERT:
                     app.post(url, middlewares, handler);
-                    docs.push(Enums_1.HttpMethods.POST, url, model);
+                    docs.push(HttpMethods.POST, url, model);
                     break;
-                case Enums_1.HandlerTypes.PAGINATE:
+                case HandlerTypes.PAGINATE:
                     app.get(url, middlewares, handler);
-                    docs.push(Enums_1.HttpMethods.GET, url, model);
+                    docs.push(HttpMethods.GET, url, model);
                     break;
-                case Enums_1.HandlerTypes.PATCH:
+                case HandlerTypes.PATCH:
                     app.patch(url, middlewares, handler);
-                    docs.push(Enums_1.HttpMethods.PATCH, url, model);
+                    docs.push(HttpMethods.PATCH, url, model);
                     break;
-                case Enums_1.HandlerTypes.SHOW:
+                case HandlerTypes.SHOW:
                     app.get(url, middlewares, handler);
-                    docs.push(Enums_1.HttpMethods.GET, url, model);
+                    docs.push(HttpMethods.GET, url, model);
                     break;
-                case Enums_1.HandlerTypes.UPDATE:
+                case HandlerTypes.UPDATE:
                     app.put(url, middlewares, handler);
-                    docs.push(Enums_1.HttpMethods.PUT, url, model);
+                    docs.push(HttpMethods.PUT, url, model);
                     break;
                 default:
                     throw new Error("Undefined handler type");
@@ -163,9 +158,9 @@ 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 factory = yield IoCService.useByType("HandlerFactory");
+                const database = (yield IoCService.use("Database"));
+                hasTransaction = yield TransactionResolver.resolve(model, handlerType);
                 if (hasTransaction) {
                     trx = yield database.transaction();
                 }
@@ -202,7 +197,7 @@ class RouterBuilder {
                 });
                 break;
             default:
-                res.status(http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR).json({
+                res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
                     error: "An error occurred.",
                 });
                 break;
@@ -210,10 +205,10 @@ class RouterBuilder {
     }
     getResourcePath(model, relation) {
         // TODO: Fix
-        return (0, change_case_1.paramCase)(pluralize_1.default.plural(model.name)).toLowerCase();
+        return paramCase(pluralize.plural(model.name)).toLowerCase();
         // return relation
         //   ? relation.resource
         //   : paramCase(pluralize.plural(model.name)).toLowerCase();
     }
 }
-exports.default = RouterBuilder;
+export default RouterBuilder;

package/build/src/Builders/index.js

@@ -1,10 +1,3 @@
-"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;
+import ModelTreeBuilder from "./ModelTreeBuilder";
+import RouterBuilder from "./RouterBuilder";
+export { ModelTreeBuilder, RouterBuilder };

package/build/src/Enums.js

@@ -1,7 +1,4 @@
-"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;
+export var ConditionTypes;
 (function (ConditionTypes) {
     ConditionTypes["NotNull"] = "NotNull";
     ConditionTypes["Null"] = "NotNull";
@@ -17,13 +14,13 @@ var ConditionTypes;
     ConditionTypes["NotIn"] = "NotIn";
     ConditionTypes["Between"] = "Between";
     ConditionTypes["NotBetween"] = "NotBetween";
-})(ConditionTypes = exports.ConditionTypes || (exports.ConditionTypes = {}));
-var DependencyTypes;
+})(ConditionTypes || (ConditionTypes = {}));
+export var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["BIND"] = "BIND";
     DependencyTypes["SINGLETON"] = "SINGLETON";
-})(DependencyTypes = exports.DependencyTypes || (exports.DependencyTypes = {}));
-var HandlerTypes;
+})(DependencyTypes || (DependencyTypes = {}));
+export var HandlerTypes;
 (function (HandlerTypes) {
     HandlerTypes["INSERT"] = "store";
     HandlerTypes["PAGINATE"] = "paginate";
@@ -32,8 +29,8 @@ var HandlerTypes;
     HandlerTypes["DELETE"] = "destroy";
     HandlerTypes["PATCH"] = "patch";
     HandlerTypes["ALL"] = "all";
-})(HandlerTypes = exports.HandlerTypes || (exports.HandlerTypes = {}));
-var HookFunctionTypes;
+})(HandlerTypes || (HandlerTypes = {}));
+export var HookFunctionTypes;
 (function (HookFunctionTypes) {
     HookFunctionTypes["onBeforeInsert"] = "onBeforeInsert";
     HookFunctionTypes["onBeforeUpdateQuery"] = "onBeforeUpdateQuery";
@@ -51,40 +48,40 @@ var HookFunctionTypes;
     HookFunctionTypes["onAfterPaginate"] = "onAfterPaginate";
     HookFunctionTypes["onAfterAll"] = "onAfterAll";
     HookFunctionTypes["onAfterShow"] = "onAfterShow";
-})(HookFunctionTypes = exports.HookFunctionTypes || (exports.HookFunctionTypes = {}));
-var Extensions;
+})(HookFunctionTypes || (HookFunctionTypes = {}));
+export var Extensions;
 (function (Extensions) {
     Extensions["Hooks"] = "Hooks";
     Extensions["Events"] = "Events";
-})(Extensions = exports.Extensions || (exports.Extensions = {}));
-var HttpMethods;
+})(Extensions || (Extensions = {}));
+export 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;
+})(HttpMethods || (HttpMethods = {}));
+export 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;
+})(LogLevels || (LogLevels = {}));
+export var Relationships;
 (function (Relationships) {
     Relationships["HAS_ONE"] = "HAS_ONE";
     Relationships["HAS_MANY"] = "HAS_MANY";
-})(Relationships = exports.Relationships || (exports.Relationships = {}));
-var SortTypes;
+})(Relationships || (Relationships = {}));
+export var SortTypes;
 (function (SortTypes) {
     SortTypes["ASC"] = "ASC";
     SortTypes["DESC"] = "DESC";
-})(SortTypes = exports.SortTypes || (exports.SortTypes = {}));
-var TimestampColumns;
+})(SortTypes || (SortTypes = {}));
+export var TimestampColumns;
 (function (TimestampColumns) {
     TimestampColumns["CREATED_AT"] = "createdAtColumn";
     TimestampColumns["UPDATED_AT"] = "updatedAtColumn";
-})(TimestampColumns = exports.TimestampColumns || (exports.TimestampColumns = {}));
+})(TimestampColumns || (TimestampColumns = {}));

package/build/src/Exceptions/ApiError.js

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

package/build/src/Handlers/AllHandler.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,14 +7,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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");
+import { addForeignKeyQuery, getRelatedData, serializeData, filterHiddenFields, callHooks, } from "./Helpers";
+import { IoCService, QueryService } from "../Services";
+import { HandlerTypes, HookFunctionTypes } from "../Enums";
+export default (pack) => __awaiter(void 0, void 0, void 0, function* () {
+    const modelList = yield IoCService.useByType("ModelListService");
     const { model, req, res, database, relation, parentModel } = pack;
-    const queryParser = new Services_1.QueryService(model, modelList.get());
+    const queryParser = new 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
@@ -23,22 +21,22 @@ exports.default = (pack) => __awaiter(void 0, void 0, void 0, function* () {
     // 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);
+    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,
+    yield callHooks(model, 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,
+    yield getRelatedData(result, conditions.with, model, modelList, database, HandlerTypes.ALL, req);
+    yield callHooks(model, 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 serializeData(result, model.instance.serialize, HandlerTypes.ALL, req);
     // Filtering hidden fields from the response data.
-    (0, Helpers_1.filterHiddenFields)(result, model.instance.hiddens);
+    filterHiddenFields(result, model.instance.hiddens);
     return res.json(result);
 });

package/build/src/Handlers/DestroyHandler.js

@@ -1,4 +1,3 @@
-"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) {
@@ -8,30 +7,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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* () {
+import { addForeignKeyQuery, callHooks } from "./Helpers";
+import { HookFunctionTypes } from "../Enums";
+import ApiError from "../Exceptions/ApiError";
+export 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 }));
+    addForeignKeyQuery(req, query, relation, parentModel);
+    yield callHooks(model, HookFunctionTypes.onBeforeDeleteQuery, Object.assign(Object.assign({}, pack), { query }));
     let item = yield query.first();
     if (!item) {
-        throw new ApiError_1.default(`The item is not found on ${model.name}.`);
+        throw new ApiError(`The item is not found on ${model.name}.`);
     }
-    yield (0, Helpers_1.callHooks)(model, Enums_1.HookFunctionTypes.onAfterDeleteQuery, Object.assign(Object.assign({}, pack), { query,
+    yield callHooks(model, 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,
+    yield callHooks(model, 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 }));
+    yield callHooks(model, HookFunctionTypes.onAfterDelete, Object.assign(Object.assign({}, pack), { item }));
     return res.json();
 });

package/build/src/Handlers/HandlerFactory.js

@@ -1,36 +1,31 @@
-"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");
+import AllHandler from "./AllHandler";
+import DestroyHandler from "./DestroyHandler";
+import PaginateHandler from "./PaginateHandler";
+import PatchHandler from "./PatchHandler";
+import UpdateHandler from "./UpdateHandler";
+import ShowHandler from "./ShowHandler";
+import StoreHandler from "./StoreHandler";
+import { HandlerTypes } from "../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;
+            case HandlerTypes.ALL:
+                return AllHandler;
+            case HandlerTypes.DELETE:
+                return DestroyHandler;
+            case HandlerTypes.INSERT:
+                return StoreHandler;
+            case HandlerTypes.PAGINATE:
+                return PaginateHandler;
+            case HandlerTypes.PATCH:
+                return PatchHandler;
+            case HandlerTypes.SHOW:
+                return ShowHandler;
+            case HandlerTypes.UPDATE:
+                return UpdateHandler;
             default:
                 throw new Error("Handler type is not defined");
         }
     }
 }
-exports.default = HandlerFactory;
+export default HandlerFactory;

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

@@ -11,4 +11,4 @@ export declare const getParentColumn: (relation: IRelation | null) => string | n
 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, handler: HandlerTypes, request: Request) => Promise<void>;
+export declare const getRelatedData: (data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: Request) => Promise<void>;