axe-api 1.0.0-rc1 → 1.0.0-rc10

package/build/index.d.ts

@@ -3,6 +3,7 @@ import Model from "./src/Model";
 import ApiError from "./src/Exceptions/ApiError";
 import { DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG } from "./src/constants";
 import { IoCService, allow, deny, App, AxeRequest, AxeResponse } from "./src/Services";
+import { rateLimit } from "./src/Middlewares/RateLimit";
 export * from "./src/Enums";
 export * from "./src/Interfaces";
-export { App, AxeRequest, AxeResponse, Server, Model, ApiError, DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG, IoCService, allow, deny, };
+export { App, AxeRequest, AxeResponse, Server, Model, ApiError, DEFAULT_HANDLERS, DEFAULT_VERSION_CONFIG, IoCService, allow, deny, rateLimit, };

package/build/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deny = exports.allow = exports.IoCService = exports.DEFAULT_VERSION_CONFIG = exports.DEFAULT_HANDLERS = exports.ApiError = exports.Model = exports.Server = exports.AxeResponse = exports.AxeRequest = exports.App = void 0;
+exports.rateLimit = exports.deny = exports.allow = exports.IoCService = exports.DEFAULT_VERSION_CONFIG = exports.DEFAULT_HANDLERS = exports.ApiError = exports.Model = exports.Server = exports.AxeResponse = exports.AxeRequest = exports.App = void 0;
 const Server_1 = __importDefault(require("./src/Server"));
 exports.Server = Server_1.default;
 const Model_1 = __importDefault(require("./src/Model"));
@@ -34,5 +34,7 @@ Object.defineProperty(exports, "deny", { enumerable: true, get: function () { re
 Object.defineProperty(exports, "App", { enumerable: true, get: function () { return Services_1.App; } });
 Object.defineProperty(exports, "AxeRequest", { enumerable: true, get: function () { return Services_1.AxeRequest; } });
 Object.defineProperty(exports, "AxeResponse", { enumerable: true, get: function () { return Services_1.AxeResponse; } });
+const RateLimit_1 = require("./src/Middlewares/RateLimit");
+Object.defineProperty(exports, "rateLimit", { enumerable: true, get: function () { return RateLimit_1.rateLimit; } });
 __exportStar(require("./src/Enums"), exports);
 __exportStar(require("./src/Interfaces"), exports);

package/build/src/Builders/ModelTreeBuilder.js

@@ -17,12 +17,11 @@ class ModelTreeBuilder {
     }
     build() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = Services_1.LogService.getInstance();
             const tree = this.getRootLevelOfTree();
             this.createRecursiveTree(tree);
             this.addNestedRoutes(tree);
             this.version.modelTree = tree;
-            logger.info(`[${this.version.name}] Model tree has been created.`);
+            Services_1.LogService.debug(`[${this.version.name}] Model tree has been created.`);
         });
     }
     getRootLevelOfTree() {

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

@@ -7,7 +7,7 @@ declare class RouterBuilder {
     private createRouteByModel;
     private createNestedRoutes;
     private createChildRoutes;
-    private addExpressRoute;
+    private addRoute;
     private getResourcePath;
     private getRootPrefix;
 }

package/build/src/Builders/RouterBuilder.js

@@ -37,13 +37,12 @@ class RouterBuilder {
     build() {
         return __awaiter(this, void 0, void 0, function* () {
             const app = yield Services_1.IoCService.useByType("App");
-            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();
-            logger.info(`[${this.version.name}] Express routes have been created.`);
+            Services_1.LogService.debug(`[${this.version.name}] All endpoints have been created.`);
             if (generalHooks.onAfterInit) {
                 generalHooks.onAfterInit(app);
             }
@@ -76,8 +75,8 @@ class RouterBuilder {
                 const middlewares = [
                     ...model.instance.getMiddlewares(handlerType),
                 ];
-                // Adding the route to the express
-                yield this.addExpressRoute(handlerType, url, middlewares, model, parentModel, relation);
+                // Adding the endpoint
+                yield this.addRoute(handlerType, url, middlewares, model, parentModel, relation);
             }
             yield this.createChildRoutes(model, resource, urlPrefix);
             yield this.createNestedRoutes(model, allowRecursive, urlPrefix, resource);
@@ -112,7 +111,7 @@ class RouterBuilder {
             }
         });
     }
-    addExpressRoute(handlerType, url, middlewares, model, parentModel, relation) {
+    addRoute(handlerType, url, middlewares, model, parentModel, relation) {
         return __awaiter(this, void 0, void 0, function* () {
             const docs = Services_1.DocumentationService.getInstance();
             const data = {

package/build/src/Enums.d.ts

@@ -61,13 +61,6 @@ export declare enum HttpMethods {
     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"

package/build/src/Enums.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StatusCodes = exports.QueryFeature = exports.QueryFeatureType = exports.AxeErrorCode = exports.TimestampColumns = exports.SortTypes = exports.Relationships = exports.LogLevels = exports.HttpMethods = exports.Extensions = exports.HookFunctionTypes = exports.HandlerTypes = exports.DependencyTypes = exports.ConditionTypes = void 0;
+exports.StatusCodes = exports.QueryFeature = exports.QueryFeatureType = exports.AxeErrorCode = exports.TimestampColumns = exports.SortTypes = exports.Relationships = exports.HttpMethods = exports.Extensions = exports.HookFunctionTypes = exports.HandlerTypes = exports.DependencyTypes = exports.ConditionTypes = void 0;
 var ConditionTypes;
 (function (ConditionTypes) {
     ConditionTypes["NotNull"] = "NotNull";
@@ -17,12 +17,12 @@ var ConditionTypes;
     ConditionTypes["NotIn"] = "NotIn";
     ConditionTypes["Between"] = "Between";
     ConditionTypes["NotBetween"] = "NotBetween";
-})(ConditionTypes = exports.ConditionTypes || (exports.ConditionTypes = {}));
+})(ConditionTypes || (exports.ConditionTypes = ConditionTypes = {}));
 var DependencyTypes;
 (function (DependencyTypes) {
     DependencyTypes["BIND"] = "BIND";
     DependencyTypes["SINGLETON"] = "SINGLETON";
-})(DependencyTypes = exports.DependencyTypes || (exports.DependencyTypes = {}));
+})(DependencyTypes || (exports.DependencyTypes = DependencyTypes = {}));
 var HandlerTypes;
 (function (HandlerTypes) {
     HandlerTypes["INSERT"] = "store";
@@ -33,7 +33,7 @@ var HandlerTypes;
     HandlerTypes["FORCE_DELETE"] = "force_delete";
     HandlerTypes["PATCH"] = "patch";
     HandlerTypes["ALL"] = "all";
-})(HandlerTypes = exports.HandlerTypes || (exports.HandlerTypes = {}));
+})(HandlerTypes || (exports.HandlerTypes = HandlerTypes = {}));
 var HookFunctionTypes;
 (function (HookFunctionTypes) {
     HookFunctionTypes["onBeforeInsert"] = "onBeforeInsert";
@@ -56,12 +56,12 @@ var HookFunctionTypes;
     HookFunctionTypes["onAfterPaginate"] = "onAfterPaginate";
     HookFunctionTypes["onAfterAll"] = "onAfterAll";
     HookFunctionTypes["onAfterShow"] = "onAfterShow";
-})(HookFunctionTypes = exports.HookFunctionTypes || (exports.HookFunctionTypes = {}));
+})(HookFunctionTypes || (exports.HookFunctionTypes = HookFunctionTypes = {}));
 var Extensions;
 (function (Extensions) {
     Extensions["Hooks"] = "Hooks";
     Extensions["Events"] = "Events";
-})(Extensions = exports.Extensions || (exports.Extensions = {}));
+})(Extensions || (exports.Extensions = Extensions = {}));
 var HttpMethods;
 (function (HttpMethods) {
     HttpMethods["POST"] = "POST";
@@ -69,30 +69,22 @@ var HttpMethods;
     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 = {}));
+})(HttpMethods || (exports.HttpMethods = HttpMethods = {}));
 var Relationships;
 (function (Relationships) {
     Relationships["HAS_ONE"] = "HAS_ONE";
     Relationships["HAS_MANY"] = "HAS_MANY";
-})(Relationships = exports.Relationships || (exports.Relationships = {}));
+})(Relationships || (exports.Relationships = Relationships = {}));
 var SortTypes;
 (function (SortTypes) {
     SortTypes["ASC"] = "ASC";
     SortTypes["DESC"] = "DESC";
-})(SortTypes = exports.SortTypes || (exports.SortTypes = {}));
+})(SortTypes || (exports.SortTypes = SortTypes = {}));
 var TimestampColumns;
 (function (TimestampColumns) {
     TimestampColumns["CREATED_AT"] = "createdAtColumn";
     TimestampColumns["UPDATED_AT"] = "updatedAtColumn";
-})(TimestampColumns = exports.TimestampColumns || (exports.TimestampColumns = {}));
+})(TimestampColumns || (exports.TimestampColumns = TimestampColumns = {}));
 var AxeErrorCode;
 (function (AxeErrorCode) {
     AxeErrorCode["UNACCEPTABLE_VERSION_NAME"] = "UNACCEPTABLE_VERSION_NAME";
@@ -104,12 +96,12 @@ var AxeErrorCode;
     AxeErrorCode["UNDEFINED_HOOK_MODEL_RELATION"] = "UNDEFINED_HOOK_MODEL_RELATION";
     AxeErrorCode["UNACCEPTABLE_HOOK_FILE"] = "UNACCEPTABLE_HOOK_FILE";
     AxeErrorCode["UNDEFINED_RELATION_NAME"] = "UNDEFINED_RELATION_NAME";
-})(AxeErrorCode = exports.AxeErrorCode || (exports.AxeErrorCode = {}));
+})(AxeErrorCode || (exports.AxeErrorCode = AxeErrorCode = {}));
 var QueryFeatureType;
 (function (QueryFeatureType) {
     QueryFeatureType["Allow"] = "Allow";
     QueryFeatureType["Deny"] = "Deny";
-})(QueryFeatureType = exports.QueryFeatureType || (exports.QueryFeatureType = {}));
+})(QueryFeatureType || (exports.QueryFeatureType = QueryFeatureType = {}));
 var QueryFeature;
 (function (QueryFeature) {
     QueryFeature["All"] = "all";
@@ -135,7 +127,7 @@ var QueryFeature;
     QueryFeature["WithAll"] = "with.*";
     QueryFeature["WithHasOne"] = "with.hasOne";
     QueryFeature["WithHasMany"] = "with.hasMany";
-})(QueryFeature = exports.QueryFeature || (exports.QueryFeature = {}));
+})(QueryFeature || (exports.QueryFeature = QueryFeature = {}));
 var StatusCodes;
 (function (StatusCodes) {
     StatusCodes[StatusCodes["ACCEPTED"] = 202] = "ACCEPTED";
@@ -194,4 +186,4 @@ var StatusCodes;
     StatusCodes[StatusCodes["UNSUPPORTED_MEDIA_TYPE"] = 415] = "UNSUPPORTED_MEDIA_TYPE";
     StatusCodes[StatusCodes["USE_PROXY"] = 305] = "USE_PROXY";
     StatusCodes[StatusCodes["MISDIRECTED_REQUEST"] = 421] = "MISDIRECTED_REQUEST";
-})(StatusCodes = exports.StatusCodes || (exports.StatusCodes = {}));
+})(StatusCodes || (exports.StatusCodes = StatusCodes = {}));

package/build/src/Handlers/RequestHandler.js

@@ -14,76 +14,86 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const Services_1 = require("../Services");
 const URLService_1 = __importDefault(require("../Services/URLService"));
-const AxeRequest_1 = __importDefault(require("../Services/AxeRequest"));
-const AxeResponse_1 = __importDefault(require("../Services/AxeResponse"));
+const ConverterService_1 = require("../Services/ConverterService");
 const api = Services_1.APIService.getInstance();
 const return404 = (response) => {
     response.statusCode = 404;
     response.write(JSON.stringify({ error: "Resource not found" }));
     response.end();
 };
-exports.default = (request, response) => __awaiter(void 0, void 0, void 0, function* () {
-    const axeRequest = new AxeRequest_1.default(request);
-    const match = URLService_1.default.match(axeRequest);
-    const axeResponse = new AxeResponse_1.default(response, axeRequest.currentLanguage);
-    if (!match) {
-        return return404(response);
-    }
-    if (match.customHandler) {
-        match.customHandler(axeRequest, axeResponse);
-        return;
-    }
-    // We should set the params
-    axeRequest.params = match.params;
-    const database = (yield Services_1.IoCService.use("Database"));
-    // Prepare the database by the transaction option
-    let trx = null;
-    if (match.hasTransaction) {
-        trx = yield database.transaction();
-    }
-    const pack = Object.assign(Object.assign({}, match.data), { params: match.params, api, req: axeRequest, res: axeResponse, database: match.hasTransaction && trx ? trx : database });
-    response.setHeader("Content-Type", "application/json");
-    response.setHeader("x-powered-by", "Axe API");
-    for (const phase of match.phases) {
+const callPhases = (phases, context, match, trx, axeResponse) => __awaiter(void 0, void 0, void 0, function* () {
+    for (const phase of phases) {
         // If there is an non-async phase, it should be an Event function
         if (phase.isAsync === false) {
-            yield phase.callback(pack);
+            Services_1.LogService.debug(`\t${phase.name}()`);
+            yield phase.callback(context);
             continue;
         }
         // Middleware and hook calls
         try {
-            yield phase.callback(pack);
+            Services_1.LogService.debug(`\t${phase.name}()`);
+            yield phase.callback(context);
         }
         catch (error) {
+            Services_1.LogService.error(`\t${error.message} ${phase.callback}`);
             // Rollback transaction
             if (match.hasTransaction && trx) {
+                Services_1.LogService.warn("\tDB transaction rollback");
                 trx.rollback();
             }
             if (error.type === "ApiError") {
                 const apiError = error;
-                return axeResponse.json({ error: apiError.message }, apiError.status);
+                return axeResponse
+                    .status(apiError.status)
+                    .json({ error: apiError.message });
             }
             // TODO: We need an error handler.
-            axeResponse.json({ error: error.toString() }, 500);
+            axeResponse.status(500).json({ error: error.toString() });
             break;
         }
         // If the response is not created, we should go to the next phase
-        if (pack.res.isResponded() === false) {
+        if (context.res.isResponded() === false) {
             continue;
         }
         // If the response is an error, and we have an active transaction,
         // we should rollback it before the HTTP request end.
-        if (pack.res.statusCode() >= 400 && pack.res.statusCode() < 599) {
+        if (context.res.statusCode() >= 400 && context.res.statusCode() < 599) {
             if (match.hasTransaction && trx) {
+                Services_1.LogService.warn("\tDB transaction rollback");
                 trx.rollback();
             }
+            Services_1.LogService.debug(`\tResponse ${context.res.statusCode()}`);
             break;
         }
         // If there is a valid transaction, we should commit it
         if (match.hasTransaction && trx) {
+            Services_1.LogService.warn("\tDB transaction commit");
             trx.commit();
         }
+        Services_1.LogService.debug(`\tResponse ${context.res.statusCode()}`);
         // We should brake the for-loop
         break;
     }
 });
+exports.default = (request, response) => __awaiter(void 0, void 0, void 0, function* () {
+    Services_1.LogService.debug(`${request.method} ${request.url}`);
+    const { axeRequest, axeResponse } = (0, ConverterService_1.toAxeRequestResponsePair)(request, response);
+    const match = URLService_1.default.match(axeRequest);
+    if (!match) {
+        Services_1.LogService.warn(`The URL is not matched! ${request.method} ${request.url}`);
+        return return404(response);
+    }
+    // We should set the params
+    axeRequest.params = match.params;
+    const database = (yield Services_1.IoCService.use("Database"));
+    // Prepare the database by the transaction option
+    let trx = null;
+    if (match.hasTransaction) {
+        Services_1.LogService.warn("\tDB transaction created");
+        trx = yield database.transaction();
+    }
+    const context = Object.assign(Object.assign({}, match.data), { params: match.params, api, req: axeRequest, res: axeResponse, database: match.hasTransaction && trx ? trx : database });
+    response.setHeader("Content-Type", "application/json");
+    response.setHeader("x-powered-by", "Axe API");
+    yield callPhases(match.phases, context, match, trx, axeResponse);
+});

package/build/src/Helpers.d.ts

@@ -1,3 +1,2 @@
 import { IVersion } from "./Interfaces";
 export declare const getVersionByRequest: (urlObject: URL) => IVersion | undefined;
-export declare const consoleAxeError: (error: any) => void;

package/build/src/Helpers.js

@@ -1,11 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.consoleAxeError = exports.getVersionByRequest = void 0;
-const chalk_1 = __importDefault(require("chalk"));
-const change_case_1 = require("change-case");
+exports.getVersionByRequest = void 0;
 const Services_1 = require("./Services");
 const getVersionByRequest = (urlObject) => {
     // Application configuration is need for the default setting.
@@ -17,50 +12,3 @@ const getVersionByRequest = (urlObject) => {
     return matchedVersion;
 };
 exports.getVersionByRequest = getVersionByRequest;
-const consoleAxeError = (error) => {
-    const putWithSpace = (text, max) => {
-        const diff = max - text.length + 3;
-        for (let index = 0; index <= diff; index++) {
-            text = `${text} `;
-        }
-        text = `   ${text}`;
-        if (text.length > 77) {
-            let lines = [];
-            text = text.trim();
-            for (let step = 0; step < text.length / 70; step++) {
-                lines.push(text.substring(0, 70));
-                text = text.substring(70);
-            }
-            lines.push(text);
-            lines = lines.map((line) => putWithSpace(line, max));
-            return lines.flat();
-        }
-        return [text];
-    };
-    const getMaxLength = (code, message) => {
-        let maxLength = message.length;
-        if (code.length > message.length) {
-            maxLength = code.length;
-        }
-        if (maxLength > 70) {
-            maxLength = 70;
-        }
-        return maxLength;
-    };
-    const maxLength = getMaxLength(error.code, error.message);
-    const messages = [
-        "\n",
-        ...putWithSpace(" ", maxLength),
-        ...putWithSpace(`[${error.code}]`, maxLength),
-        ...putWithSpace(" ", maxLength),
-        ...putWithSpace(error.message, maxLength),
-        ...putWithSpace(" ", maxLength),
-    ];
-    console.log(chalk_1.default.bgRed.white(messages.join("\n")));
-    console.log(chalk_1.default.cyan([
-        "\n",
-        "You can find more in the documentation;",
-        `https://axe-api.com/errors.html#${(0, change_case_1.paramCase)(error.code)}`,
-    ].join("\n")));
-};
-exports.consoleAxeError = consoleAxeError;

package/build/src/Interfaces.d.ts

@@ -1,12 +1,17 @@
+/// <reference types="node" />
+/// <reference types="express" />
 import { Knex } from "knex";
+import { Options as FormOptions } from "formidable";
 import { Column } from "knex-schema-inspector/lib/types/column";
-import { HandlerTypes, LogLevels, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType } from "./Enums";
+import { HandlerTypes, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes, QueryFeature, QueryFeatureType } from "./Enums";
 import Model from "./Model";
-import { PhaseFunction, SerializationFunction } from "./Types";
+import { AdaptorTypes, HandlerFunction, HookFunctions, MiddlewareFunction, StepTypes, PhaseFunction, SerializationFunction } from "./Types";
 import { ModelListService, QueryService } from "./Services";
 import AxeRequest from "./Services/AxeRequest";
 import AxeResponse from "./Services/AxeResponse";
 import App from "./Services/App";
+import { LoggerOptions } from "pino";
+import { IncomingMessage } from "http";
 export interface IColumn extends Column {
     table_name: string;
 }
@@ -34,20 +39,44 @@ export interface IQueryConfig {
     limits: Array<IQueryLimitConfig[]>;
     defaults?: IQueryDefaultConfig;
 }
-export interface IVersionConfig {
+export interface IRedisOptions {
+    host?: string;
+    port?: number;
+    password?: string;
+    db?: number;
+}
+export interface IRateLimitAdaptorConfig {
+    type: AdaptorTypes;
+    redis?: IRedisOptions;
+}
+export interface IRateLimitOptions {
+    maxRequests: number;
+    windowInSeconds: number;
+}
+export interface IRateLimitConfig extends IRateLimitOptions {
+    enabled: boolean;
+    adaptor: IRateLimitAdaptorConfig;
+    trustProxyIP: boolean;
+    keyGenerator?: (req: IncomingMessage) => string;
+}
+export interface AxeVersionConfig {
     transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
     serializers: ((data: any, request: AxeRequest) => void)[] | IHandlerBasedSerializer[];
     supportedLanguages: string[];
     defaultLanguage: string;
     query: IQueryConfig;
+    formidable: FormOptions;
 }
-export interface IApplicationConfig extends IConfig {
+export type IVersionConfig = Partial<AxeVersionConfig>;
+export interface AxeConfig extends IConfig {
     env: string;
     port: number;
-    logLevel: LogLevels;
     prefix: string;
     database: IDatabaseConfig;
+    pino: LoggerOptions;
+    rateLimit: IRateLimitConfig;
 }
+export type IApplicationConfig = Partial<AxeConfig>;
 export interface ILanguage {
     title: string;
     language: string;
@@ -69,7 +98,7 @@ export interface IVersionFolder {
 }
 export interface IVersion {
     name: string;
-    config: IVersionConfig;
+    config: AxeVersionConfig;
     folders: IVersionFolder;
     modelList: ModelListService;
     modelTree: IModelService[];
@@ -78,7 +107,7 @@ export interface IAPI {
     rootFolder: string;
     appFolder: string;
     versions: IVersion[];
-    config: IApplicationConfig;
+    config: AxeConfig;
 }
 export interface IGeneralHooks {
     onBeforeInit: (app: App) => void | null;
@@ -86,7 +115,7 @@ export interface IGeneralHooks {
 }
 export interface IHandlerBaseMiddleware {
     handler: HandlerTypes[];
-    middleware: (context: IRequestPack) => Promise<void>;
+    middleware: StepTypes;
 }
 export interface IMethodBaseConfig {
     [HttpMethods.POST]?: string[];
@@ -103,8 +132,8 @@ export interface IModelService {
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: Record<HookFunctionTypes, PhaseFunction>;
-    events: Record<HookFunctionTypes, PhaseFunction>;
+    hooks: HookFunctions;
+    events: HookFunctions;
     isRecursive: boolean;
     children: IModelService[];
     queryLimits: IQueryLimitConfig[];
@@ -200,7 +229,16 @@ export interface IDependency {
     instance: any;
 }
 export interface IPhaseDefinition {
+    name: string;
     isAsync: boolean;
     callback: PhaseFunction;
 }
+export interface AxeRequestResponsePair {
+    axeRequest: AxeRequest;
+    axeResponse: AxeResponse;
+}
+export interface MiddlewareResolution {
+    middlewares: (MiddlewareFunction | HandlerFunction)[];
+    handler: HandlerFunction;
+}
 export {};

package/build/src/Middlewares/RateLimit/AdaptorFactory.d.ts

@@ -0,0 +1,6 @@
+import { AdaptorTypes } from "../../Types";
+import RedisAdaptor from "./RedisAdaptor";
+import MemoryAdaptor from "./MemoryAdaptor";
+import { IRedisOptions } from "src/Interfaces";
+declare const _default: (adaptor: AdaptorTypes, redisOptions: IRedisOptions | undefined, prefix: string) => RedisAdaptor | MemoryAdaptor;
+export default _default;

package/build/src/Middlewares/RateLimit/AdaptorFactory.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const RedisAdaptor_1 = __importDefault(require("./RedisAdaptor"));
+const MemoryAdaptor_1 = __importDefault(require("./MemoryAdaptor"));
+exports.default = (adaptor, redisOptions, prefix) => {
+    switch (adaptor) {
+        case "redis":
+            return new RedisAdaptor_1.default(redisOptions, prefix);
+        case "memory":
+            return new MemoryAdaptor_1.default(prefix);
+        default:
+            throw new Error(`Adaptor type is not found: ${adaptor}`);
+    }
+};

package/build/src/Middlewares/RateLimit/IAdaptor.d.ts

@@ -0,0 +1,6 @@
+interface IAdaptor {
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    decr(key: string, ttl: number): Promise<void>;
+}
+export default IAdaptor;

package/build/src/Middlewares/RateLimit/IAdaptor.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/src/Middlewares/RateLimit/MemoryAdaptor.d.ts

@@ -0,0 +1,10 @@
+import IAdaptor from "./IAdaptor";
+declare class MemoryAdaptor implements IAdaptor {
+    private client;
+    private prefix;
+    constructor(prefix: string);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    decr(key: string, ttl: number): Promise<void>;
+}
+export default MemoryAdaptor;

package/build/src/Middlewares/RateLimit/MemoryAdaptor.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 node_cache_1 = __importDefault(require("node-cache"));
+class MemoryAdaptor {
+    constructor(prefix) {
+        this.client = new node_cache_1.default();
+        this.prefix = prefix;
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.client.get(`${this.prefix}${key}`) || null;
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.client.set(`${this.prefix}${key}`, value, ttl);
+        });
+    }
+    decr(key, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const value = yield this.get(key);
+            if (value) {
+                const newValue = parseInt(value) - 1;
+                this.set(key, newValue.toString(), ttl);
+            }
+        });
+    }
+}
+exports.default = MemoryAdaptor;

package/build/src/Middlewares/RateLimit/RedisAdaptor.d.ts

@@ -0,0 +1,11 @@
+import IAdaptor from "./IAdaptor";
+import { IRedisOptions } from "../../Interfaces";
+declare class RedisAdaptor implements IAdaptor {
+    private client;
+    private prefix;
+    constructor(options: IRedisOptions | undefined, prefix: string);
+    get(key: string): Promise<string | null>;
+    set(key: string, value: string, ttl: number): Promise<void>;
+    decr(key: string): Promise<void>;
+}
+export default RedisAdaptor;