axe-api 0.20.0-rc7 → 0.20.0-rc8

package/build/index.js

@@ -1,7 +1,30 @@
-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 };
+"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);

package/build/src/Builders/ModelTreeBuilder.js

@@ -1,20 +1,33 @@
-import { Relationships } from "../Enums";
-import { IoCService } from "../Services";
+"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 {
-    async build() {
-        const logger = await IoCService.useByType("LogService");
-        const modelList = await IoCService.useByType("ModelListService");
-        const tree = this.getRootLevelOfTree(modelList);
-        this.createRecursiveTree(tree, modelList);
-        this.addNestedRoutes(tree, modelList);
-        IoCService.singleton("ModelTree", () => tree);
-        logger.info("Model tree has been created.");
+    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 === Relationships.HAS_MANY)
+                .filter((relation) => relation.type === Enums_1.Relationships.HAS_MANY)
                 .map((relation) => relation.model));
         });
         return modelList.get().filter((model) => !childModels.includes(model.name));
@@ -35,7 +48,7 @@ class ModelTreeBuilder {
     }
     getChildModelNames(model) {
         return model.relations
-            .filter((item) => item.type === Relationships.HAS_MANY)
+            .filter((item) => item.type === Enums_1.Relationships.HAS_MANY)
             .map((item) => item.model);
     }
     addNestedRoutes(tree, modelList) {
@@ -43,13 +56,9 @@ class ModelTreeBuilder {
         modelList.get().forEach((model) => {
             const recursiveRelations = model.relations.filter((relation) => relation.model === model.name);
             if (recursiveRelations.length === 2) {
-                tree.push({
-                    ...model,
-                    isRecursive: true,
-                    children: [],
-                });
+                tree.push(Object.assign(Object.assign({}, model), { isRecursive: true, children: [] }));
             }
         });
     }
 }
-export default ModelTreeBuilder;
+exports.default = ModelTreeBuilder;

package/build/src/Builders/RouterBuilder.js

@@ -1,154 +1,196 @@
-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";
+"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 {
-    async build() {
-        const logger = await IoCService.useByType("LogService");
-        const modelTree = await IoCService.useByType("ModelTree");
-        const modelList = await IoCService.useByType("ModelListService");
-        const generalHooks = await GeneralHookResolver.resolve();
-        if (generalHooks.onBeforeInit) {
-            generalHooks.onBeforeInit();
-        }
-        await this.createRoutesByModelTree(modelTree, modelList);
-        if (generalHooks.onAfterInit) {
-            generalHooks.onAfterInit();
-        }
-        logger.info("Express routes have been created.");
-    }
-    async createRoutesByModelTree(modelTree, modelList) {
-        for (const model of modelTree) {
-            await this.createRouteByModel(model, modelList);
-        }
+    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;
+        });
     }
-    async createRouteByModel(model, modelList, urlPrefix = "", parentModel = null, relation = null, allowRecursive = true) {
-        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(API_ROUTE_TEMPLATES)) {
-            const handlerType = handler;
-            if (!model.instance.handlers.includes(handlerType)) {
-                continue;
+    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();
+            if (generalHooks.onBeforeInit) {
+                generalHooks.onBeforeInit();
             }
-            const urlCreator = API_ROUTE_TEMPLATES[handlerType];
-            const url = urlCreator(await this.getRootPrefix(), urlPrefix, resource, model.instance.primaryKey);
-            // Detecting filters
-            const middlewares = ModelMiddlewareResolver.resolve(model, handlerType);
-            // Adding the route to the express
-            await this.addExpressRoute(handlerType, url, middlewares, model, parentModel, relation);
-        }
-        await this.createChildRoutes(model, modelList, resource, urlPrefix);
-        await this.createNestedRoutes(model, modelList, allowRecursive, urlPrefix, resource);
+            yield this.createRoutesByModelTree(modelTree, modelList);
+            if (generalHooks.onAfterInit) {
+                generalHooks.onAfterInit();
+            }
+            logger.info("Express routes have been created.");
+        });
     }
-    async createNestedRoutes(model, modelList, allowRecursive, urlPrefix, resource) {
-        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 === Relationships.HAS_MANY);
-        if (relation) {
-            await this.createRouteByModel(model, modelList, `${urlPrefix}${resource}/:${camelCase(relation.foreignKey)}/`, model, relation, false);
-        }
+    createRoutesByModelTree(modelTree, modelList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const model of modelTree) {
+                yield this.createRouteByModel(model, modelList);
+            }
+        });
     }
-    async createChildRoutes(model, modelList, resource, urlPrefix) {
-        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 === Relationships.HAS_MANY);
-        for (const relation of subRelations) {
-            const child = model.children.find((item) => item.name === relation.model);
-            // It should be recursive
-            if (child) {
-                await this.createRouteByModel(child, modelList, `${urlPrefix}${resource}/:${primaryKey}/`, model, relation);
+    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 = Resolvers_1.ModelMiddlewareResolver.resolve(model, 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);
+        });
     }
-    getPrimaryKeyName = (model) => {
-        return (pluralize.singular(model.name).toLowerCase() +
-            this.ucFirst(model.instance.primaryKey));
-    };
-    ucFirst = (value) => {
-        return value.charAt(0).toUpperCase() + value.slice(1);
-    };
-    async addExpressRoute(handlerType, url, middlewares, model, parentModel, relation) {
-        const docs = await IoCService.useByType("DocumentationService");
-        const app = await IoCService.useByType("App");
-        const handler = (req, res) => {
-            this.requestHandler(handlerType, req, res, model, parentModel, relation);
-        };
-        switch (handlerType) {
-            case HandlerTypes.ALL:
-                app.get(url, middlewares, handler);
-                docs.push(HttpMethods.GET, url, model);
-                break;
-            case HandlerTypes.DELETE:
-                app.delete(url, middlewares, handler);
-                docs.push(HttpMethods.DELETE, url, model);
-                break;
-            case HandlerTypes.INSERT:
-                app.post(url, middlewares, handler);
-                docs.push(HttpMethods.POST, url, model);
-                break;
-            case HandlerTypes.PAGINATE:
-                app.get(url, middlewares, handler);
-                docs.push(HttpMethods.GET, url, model);
-                break;
-            case HandlerTypes.PATCH:
-                app.patch(url, middlewares, handler);
-                docs.push(HttpMethods.PATCH, url, model);
-                break;
-            case HandlerTypes.SHOW:
-                app.get(url, middlewares, handler);
-                docs.push(HttpMethods.GET, url, model);
-                break;
-            case HandlerTypes.UPDATE:
-                app.put(url, middlewares, handler);
-                docs.push(HttpMethods.PUT, url, model);
-                break;
-            default:
-                throw new Error("Undefined handler type");
-        }
+    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);
+            }
+        });
     }
-    async requestHandler(handlerType, req, res, model, parentModel, relation) {
-        let trx = null;
-        let hasTransaction = false;
-        try {
-            const factory = await IoCService.useByType("HandlerFactory");
-            const database = (await IoCService.use("Database"));
-            hasTransaction = await TransactionResolver.resolve(model, handlerType);
-            if (hasTransaction) {
-                trx = await database.transaction();
+    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);
+                }
             }
-            const handler = factory.get(handlerType);
-            const pack = {
-                req,
-                res,
-                handlerType,
-                model,
-                parentModel,
-                relation,
-                database: hasTransaction && trx ? trx : database,
+        });
+    }
+    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);
             };
-            await handler(pack);
-            if (hasTransaction && trx) {
-                trx.commit();
+            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");
             }
-        }
-        catch (error) {
-            if (hasTransaction && trx) {
-                trx.rollback();
+        });
+    }
+    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();
+                }
             }
-            this.sendErrorAsResponse(res, error);
-        }
+            catch (error) {
+                if (hasTransaction && trx) {
+                    trx.rollback();
+                }
+                this.sendErrorAsResponse(res, error);
+            }
+        });
     }
     sendErrorAsResponse(res, error) {
         const type = error.type;
@@ -160,7 +202,7 @@ class RouterBuilder {
                 });
                 break;
             default:
-                res.status(StatusCodes.INTERNAL_SERVER_ERROR).json({
+                res.status(http_status_codes_1.StatusCodes.INTERNAL_SERVER_ERROR).json({
                     error: "An error occurred.",
                 });
                 break;
@@ -168,21 +210,10 @@ class RouterBuilder {
     }
     getResourcePath(model, relation) {
         // TODO: Fix
-        return paramCase(pluralize.plural(model.name)).toLowerCase();
+        return (0, change_case_1.paramCase)(pluralize_1.default.plural(model.name)).toLowerCase();
         // return relation
         //   ? relation.resource
         //   : paramCase(pluralize.plural(model.name)).toLowerCase();
     }
-    getRootPrefix = async () => {
-        const config = await IoCService.use("Config");
-        let prefix = config?.Application?.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;
-    };
 }
-export default RouterBuilder;
+exports.default = RouterBuilder;

package/build/src/Builders/index.js

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

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

package/build/src/Exceptions/ApiError.js

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