axe-api 0.31.4 → 1.0.0-rc10

package/build/src/Services/AxeRequest.js

@@ -0,0 +1,85 @@
+"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 formidable_1 = __importDefault(require("formidable"));
+const Helpers_1 = require("../Helpers");
+const Resolvers_1 = require("../Resolvers");
+const LogService_1 = __importDefault(require("./LogService"));
+class AxeRequest {
+    constructor(request) {
+        this.privateParams = {};
+        this.request = request;
+        this.urlObject = new URL(request.url || "", "http://127.0.0.1");
+        // Application configuration is need for the default setting.
+        this.version = (0, Helpers_1.getVersionByRequest)(this.urlObject);
+        if (this.version) {
+            // Setting the current language by the supported, default and the client prefences
+            this.language = Resolvers_1.AcceptLanguageResolver.resolve(this.request.headers["accept-language"] || "", this.version.config.supportedLanguages || ["en"], this.version.config.defaultLanguage || "en");
+        }
+        else {
+            this.language = {
+                title: "en",
+                language: "en",
+                region: null,
+            };
+        }
+    }
+    get url() {
+        return this.urlObject;
+    }
+    get params() {
+        return this.privateParams;
+    }
+    set params(value) {
+        this.privateParams = value;
+    }
+    get query() {
+        return this.urlObject.searchParams;
+    }
+    get path() {
+        // TODO: Path
+        return this.request.url || "";
+    }
+    get method() {
+        return this.request.method || "GET";
+    }
+    get body() {
+        return this.request.body;
+    }
+    get currentLanguage() {
+        return this.language;
+    }
+    set currentLanguage(language) {
+        this.language = language;
+    }
+    header(key) {
+        return this.request.headers[key];
+    }
+    files(options) {
+        var _a, _b;
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!((_a = this.header("content-type")) === null || _a === void 0 ? void 0 : _a.includes("multipart/form-data"))) {
+                LogService_1.default.warn(`Content-type must be 'multipart/form-data'.`);
+                throw new Error(`Content-type must be 'multipart/form-data'.`);
+            }
+            LogService_1.default.debug(`Form data is parsing`);
+            const form = (0, formidable_1.default)(options || ((_b = this.version) === null || _b === void 0 ? void 0 : _b.config.formidable) || {});
+            return yield form.parse(this.request);
+        });
+    }
+    get original() {
+        return this.request;
+    }
+}
+exports.default = AxeRequest;

package/build/src/Services/AxeResponse.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/// <reference types="express" />
+import { ServerResponse } from "http";
+import { ILanguage } from "src/Interfaces";
+declare class AxeResponse {
+    private response;
+    private responseStatus;
+    private language;
+    constructor(response: ServerResponse, language: ILanguage);
+    get original(): ServerResponse<import("http").IncomingMessage>;
+    status(statusCode: number): this;
+    json(data: object): void;
+    send(content: string): void;
+    noContent(): void;
+    isResponded(): boolean;
+    statusCode(): number;
+}
+export default AxeResponse;

package/build/src/Services/AxeResponse.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AxeResponse {
+    constructor(response, language) {
+        this.responseStatus = false;
+        this.response = response;
+        this.response.statusCode = 200;
+        this.language = language;
+    }
+    get original() {
+        return this.response;
+    }
+    status(statusCode) {
+        this.response.statusCode = statusCode;
+        return this;
+    }
+    json(data) {
+        this.response.setHeader("Content-Type", "application/json");
+        this.response.setHeader("Content-Language", this.language.language);
+        this.response.write(JSON.stringify(data));
+        this.response.end();
+        this.responseStatus = true;
+    }
+    send(content) {
+        this.response.write(content);
+        this.response.end();
+        this.responseStatus = true;
+    }
+    noContent() {
+        this.response.statusCode = 204;
+        this.response.end();
+        this.responseStatus = true;
+    }
+    isResponded() {
+        return this.responseStatus;
+    }
+    statusCode() {
+        return this.response.statusCode;
+    }
+}
+exports.default = AxeResponse;

package/build/src/Services/ConverterService.d.ts

@@ -0,0 +1,9 @@
+import { IncomingMessage, ServerResponse } from "http";
+import { AxeRequestResponsePair, MiddlewareResolution } from "../Interfaces";
+import { DynamicFunctionType, PhaseFunction, StepTypes } from "src/Types";
+export declare const toAxeRequestResponsePair: (request: IncomingMessage, response: ServerResponse) => AxeRequestResponsePair;
+export declare const resolveMiddlewares: (args: DynamicFunctionType) => MiddlewareResolution;
+export declare const isMiddlewareFunction: (callback: any) => boolean;
+export declare const isHandlerFunction: (callback: any) => boolean;
+export declare const isPhaseFunction: (callback: any) => boolean;
+export declare const toPhaseFunction: (callback: StepTypes) => PhaseFunction;

package/build/src/Services/ConverterService.js

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPhaseFunction = exports.isPhaseFunction = exports.isHandlerFunction = exports.isMiddlewareFunction = exports.resolveMiddlewares = exports.toAxeRequestResponsePair = void 0;
+const util_1 = require("util");
+const AxeRequest_1 = __importDefault(require("./AxeRequest"));
+const AxeResponse_1 = __importDefault(require("./AxeResponse"));
+const toAxeRequestResponsePair = (request, response) => {
+    const axeRequest = new AxeRequest_1.default(request);
+    const axeResponse = new AxeResponse_1.default(response, axeRequest.currentLanguage);
+    return {
+        axeRequest,
+        axeResponse,
+    };
+};
+exports.toAxeRequestResponsePair = toAxeRequestResponsePair;
+const resolveMiddlewares = (args) => {
+    const middlewares = args.slice(0, -1);
+    const handler = args.at(-1);
+    return {
+        middlewares,
+        handler,
+    };
+};
+exports.resolveMiddlewares = resolveMiddlewares;
+const isMiddlewareFunction = (callback) => {
+    return callback.length === 3;
+};
+exports.isMiddlewareFunction = isMiddlewareFunction;
+const isHandlerFunction = (callback) => {
+    return callback.length === 2;
+};
+exports.isHandlerFunction = isHandlerFunction;
+const isPhaseFunction = (callback) => {
+    return callback.length === 1;
+};
+exports.isPhaseFunction = isPhaseFunction;
+const toPhaseFunction = (callback) => {
+    if ((0, exports.isMiddlewareFunction)(callback)) {
+        return (0, util_1.promisify)((context, next) => callback(context.req.original, context.res.original, next));
+    }
+    if ((0, exports.isHandlerFunction)(callback)) {
+        return (context) => callback(context.req, context.res);
+    }
+    return callback;
+};
+exports.toPhaseFunction = toPhaseFunction;

package/build/src/Services/LogService.d.ts

@@ -1,15 +1,11 @@
-import { LogLevels } from "../Enums";
+import logger from "pino";
 declare class LogService {
-    private static instance;
-    private level;
-    constructor(level: LogLevels);
-    static setInstance(level: LogLevels): void;
-    static getInstance(): LogService;
-    error(message: string): void;
-    warn(message: string): void;
-    info(message: string): void;
-    success(message: string): void;
-    debug(message: string): void;
-    log(message: string): void;
+    private static logger;
+    static setInstance(options?: logger.LoggerOptions | undefined): void;
+    static instance(): logger.Logger<logger.LoggerOptions>;
+    static error(message: string): void;
+    static warn(message: string): void;
+    static info(message: string): void;
+    static debug(message: string): void;
 }
 export default LogService;

package/build/src/Services/LogService.js

@@ -1,45 +1,27 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const Enums_1 = require("../Enums");
-const constants_1 = require("../constants");
-const { fgRed, fgGreen, fgYellow, fgCyan, fgReset } = constants_1.LOG_COLORS;
+const pino_1 = __importDefault(require("pino"));
 class LogService {
-    constructor(level) {
-        this.level = level;
+    static setInstance(options) {
+        LogService.logger = (0, pino_1.default)(options);
     }
-    static setInstance(level) {
-        LogService.instance = new LogService(level);
+    static instance() {
+        return LogService.logger;
     }
-    static getInstance() {
-        return LogService.instance;
+    static error(message) {
+        LogService.logger.error(message);
     }
-    error(message) {
-        if (this.level >= Enums_1.LogLevels.ERROR) {
-            console.error(fgRed, "[axe]", message, fgReset);
-        }
+    static warn(message) {
+        LogService.logger.warn(message);
     }
-    warn(message) {
-        if (this.level >= Enums_1.LogLevels.WARNING) {
-            console.warn(fgYellow, "[axe]", message, fgReset);
-        }
+    static info(message) {
+        LogService.logger.info(message);
     }
-    info(message) {
-        if (this.level >= Enums_1.LogLevels.INFO) {
-            console.info(fgCyan, "[axe]", message, fgReset);
-        }
-    }
-    success(message) {
-        if (this.level >= Enums_1.LogLevels.INFO) {
-            console.info(fgGreen, "[axe]", message, fgReset);
-        }
-    }
-    debug(message) {
-        this.log(message);
-    }
-    log(message) {
-        if (this.level === Enums_1.LogLevels.ALL) {
-            console.log(message);
-        }
+    static debug(message) {
+        LogService.logger.debug(message);
     }
 }
 exports.default = LogService;

package/build/src/Services/ModelService.d.ts

@@ -1,22 +1,22 @@
 import { HookFunctionTypes, Extensions } from "../Enums";
 import { IColumn, IModelService, IQueryLimitConfig, IRelation } from "../Interfaces";
 import Model from "./../Model";
-import { HookFunction, SerializationFunction } from "../Types";
+import { HookFunctions, PhaseFunction, SerializationFunction } from "../Types";
 declare class ModelService implements IModelService {
     name: string;
     instance: Model;
     relations: IRelation[];
     columns: IColumn[];
     columnNames: string[];
-    hooks: Record<HookFunctionTypes, HookFunction>;
-    events: Record<HookFunctionTypes, HookFunction>;
+    hooks: HookFunctions;
+    events: HookFunctions;
     children: IModelService[];
     isRecursive: boolean;
     queryLimits: IQueryLimitConfig[];
     serialize: SerializationFunction | null;
     constructor(name: string, instance: Model);
     setColumns(columns: IColumn[]): void;
-    setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: HookFunction): void;
+    setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: PhaseFunction): void;
     setQueryLimits(limits: IQueryLimitConfig[]): void;
     setSerialization(callback: SerializationFunction): void;
     private setHooks;

package/build/src/Services/QueryService.d.ts

@@ -1,4 +1,4 @@
-import { IQuery, ISortField, NestedWhere, IWhere, IModelService, IVersionConfig } from "../Interfaces";
+import { IQuery, ISortField, NestedWhere, IWhere, IModelService, AxeVersionConfig } from "../Interfaces";
 import { Knex } from "knex";
 declare class QueryService {
     model: IModelService;
@@ -6,13 +6,13 @@ declare class QueryService {
     usedConditionColumns: string[];
     relationColumns: string[];
     createdJoins: string[];
-    config: IVersionConfig;
-    constructor(model: IModelService, models: IModelService[], config: IVersionConfig);
+    config: AxeVersionConfig;
+    constructor(model: IModelService, models: IModelService[], config: AxeVersionConfig);
     applyFields(query: Knex.QueryBuilder, fields: string[]): void;
     applySorting(query: Knex.QueryBuilder, sort: ISortField[]): void;
     applyWheresInsideGroup(sub: Knex.QueryBuilder, ruleSet: NestedWhere | IWhere): void;
     applyWheres(query: Knex.QueryBuilder, ruleSet: NestedWhere): void;
-    get(query: any): IQuery;
+    get(query: URLSearchParams): IQuery;
     private getUsedColumns;
     private applyConditionRule;
     private applyRelatedQueryJoins;

package/build/src/Services/QueryService.js

@@ -164,12 +164,13 @@ class QueryService {
     }
     parseSections(sections) {
         var _a, _b, _c, _d;
-        if (sections.q) {
-            const queryContent = sections.q.replace(/%20/g, "").replace(/ /g, "");
+        let q = sections.get("q");
+        if (q) {
+            const queryContent = q.replace(/%20/g, "").replace(/ /g, "");
             // Users can send an unacceptable query string. We shouldn't allow them to
             // send unacceptable structure because of security reasons.
             try {
-                sections.q = JSON.parse(queryContent);
+                q = JSON.parse(queryContent);
             }
             catch (err) {
                 throw new ApiError_1.default(`Unacceptable query string: ${queryContent}`);
@@ -177,13 +178,15 @@ class QueryService {
         }
         const withQueryResolver = new Resolvers_1.WithQueryResolver(this.model, this.models);
         const query = {
-            page: this.parsePage(sections.page),
-            per_page: this.parsePerPage(sections.per_page),
-            fields: this.parseFields(sections.fields),
-            sort: this.parseSortingOptions(sections.sort),
-            q: this.parseCondition(sections.q),
-            with: withQueryResolver.resolve((sections === null || sections === void 0 ? void 0 : sections.with) || ""),
-            trashed: (sections === null || sections === void 0 ? void 0 : sections.trashed) ? (0, Helpers_1.isBoolean)(sections.trashed) : false,
+            page: this.parsePage(sections.get("page")),
+            per_page: this.parsePerPage(sections.get("per_page")),
+            fields: this.parseFields(sections.get("fields")),
+            sort: this.parseSortingOptions(sections.get("sort")),
+            q: this.parseCondition(q),
+            with: withQueryResolver.resolve(sections.get("with") || ""),
+            trashed: sections.get("trashed")
+                ? (0, Helpers_1.isBoolean)(sections.get("trashed"))
+                : false,
         };
         const configPerPage = ((_b = (_a = this.config) === null || _a === void 0 ? void 0 : _a.query.defaults) === null || _b === void 0 ? void 0 : _b.perPage) ||
             ((_d = (_c = constants_1.DEFAULT_VERSION_CONFIG.query) === null || _c === void 0 ? void 0 : _c.defaults) === null || _d === void 0 ? void 0 : _d.perPage) ||
@@ -217,7 +220,7 @@ class QueryService {
             ((_j = constants_1.DEFAULT_VERSION_CONFIG.query.defaults) === null || _j === void 0 ? void 0 : _j.maxPerPage) ||
             100;
         if (isNaN(value) || value < minPerPage || value > maxPerPage) {
-            throw new ApiError_1.default(`Unacceptable 'per_page' value! Current value is '${value}'. It should be between ${minPerPage}-${maxPerPage}`);
+            throw new ApiError_1.default(`Unacceptable 'per_page' value! Current value is '${value}'. It should be between ${minPerPage}-${maxPerPage}`, Enums_1.StatusCodes.BAD_REQUEST);
         }
         return value;
     }

package/build/src/Services/SchemaValidatorService.js

@@ -119,7 +119,6 @@ class SchemaValidatorService {
     }
     validate() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = Services_1.LogService.getInstance();
             this.version.modelList.get().forEach((model) => {
                 this.checkModelReservedKeywordsOrFail(model);
                 this.checkModelColumnsOrFail(model, this.getModelFillableColumns(model));
@@ -131,7 +130,7 @@ class SchemaValidatorService {
                 this.checkRelationNamesOrFail(model, this.getQueryLimitRelations(model));
                 this.checkRelationColumnsOrFail(this.version.modelList, model);
             });
-            logger.info(`[${this.version.name}] Database schema has been validated.`);
+            Services_1.LogService.debug(`[${this.version.name}] Database schema has been validated.`);
         });
     }
     checkModelReservedKeywordsOrFail(model) {

package/build/src/Services/URLService.d.ts

@@ -0,0 +1,29 @@
+import { HandlerFunction, MiddlewareFunction, StepTypes } from "../Types";
+import { IPhaseDefinition, IRouteData } from "../Interfaces";
+import AxeRequest from "./AxeRequest";
+interface Pair {
+    method: string;
+    pattern: string;
+    data: IRouteData;
+    phases: IPhaseDefinition[];
+    hasTransaction: boolean;
+    params?: any;
+    customHandler?: HandlerFunction;
+}
+declare class URLService {
+    private static urls;
+    static add(method: string, pattern: string, data: IRouteData, middlewares: StepTypes[]): Promise<void>;
+    static addHandler(method: string, pattern: string, customHandler: HandlerFunction, middlewares: (MiddlewareFunction | HandlerFunction)[]): Promise<void>;
+    static match(request: AxeRequest): {
+        params: any;
+        method: string;
+        pattern: string;
+        data: IRouteData;
+        phases: IPhaseDefinition[];
+        hasTransaction: boolean;
+        customHandler?: HandlerFunction | undefined;
+    } | undefined;
+    static getAllURLs(): Pair[];
+    private static getDefaultPhases;
+}
+export default URLService;

package/build/src/Services/URLService.js

@@ -0,0 +1,144 @@
+"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 util_1 = require("util");
+const constants_1 = require("../constants");
+const Resolvers_1 = require("../Resolvers");
+const Enums_1 = require("../Enums");
+const LogService_1 = __importDefault(require("./LogService"));
+const ConverterService_1 = require("./ConverterService");
+const check = (url, pattern) => {
+    // Escape special characters in the pattern and replace parameter placeholders with regular expression groups
+    const regexPattern = new RegExp("^" + pattern.replace(/:[a-zA-Z0-9_]+/g, "([a-zA-Z0-9_-]+)") + "$");
+    // Test if the URL matches the pattern
+    const match = url.match(regexPattern);
+    if (match) {
+        // Extract parameter values from the URL
+        const params = {};
+        const paramNames = pattern.match(/:[a-zA-Z0-9_]+/g) || [];
+        paramNames.forEach((param, index) => {
+            const paramName = param.slice(1); // Remove the leading ":"
+            params[paramName] = match[index + 1]; // index + 1 because match[0] is the whole matched string
+        });
+        return params;
+    }
+    return null; // URL does not match the pattern
+};
+class URLService {
+    static add(method, pattern, data, middlewares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const phases = this.getDefaultPhases(middlewares);
+            if (data.handlerType && data.model) {
+                for (const cycle of constants_1.HANDLER_CYLES[data.handlerType]) {
+                    const item = cycle.get(data.model);
+                    if (item) {
+                        phases.push({
+                            name: cycle.name,
+                            isAsync: cycle.isAsync(),
+                            callback: item,
+                        });
+                    }
+                }
+            }
+            let hasTransaction = false;
+            if (data.version && data.model && data.handlerType) {
+                hasTransaction = yield new Resolvers_1.TransactionResolver(data.version).resolve(data.model, data.handlerType);
+            }
+            LogService_1.default.info(`${method} ${pattern}`);
+            this.urls.push({
+                method,
+                pattern,
+                data,
+                phases,
+                hasTransaction,
+            });
+        });
+    }
+    static addHandler(method, pattern, customHandler, middlewares) {
+        return __awaiter(this, void 0, void 0, function* () {
+            LogService_1.default.info(`${method} ${pattern}`);
+            const phases = middlewares.map((middleware) => {
+                return {
+                    isAsync: false,
+                    name: `middleware:test`,
+                    callback: (context) => __awaiter(this, void 0, void 0, function* () {
+                        if ((0, ConverterService_1.isMiddlewareFunction)(middleware)) {
+                            // It should be wrapped
+                            const caller = (0, util_1.promisify)((context, next) => middleware(context.req.original, context.res.original, next));
+                            yield caller(context);
+                        }
+                        else {
+                            // We call it directly.
+                            yield middleware(context.req, context.res);
+                        }
+                    }),
+                };
+            });
+            const hasTransaction = false;
+            phases.push({
+                isAsync: false,
+                name: "customHandler",
+                callback: (context) => __awaiter(this, void 0, void 0, function* () {
+                    customHandler(context.req, context.res);
+                }),
+            });
+            this.urls.push({
+                method,
+                pattern,
+                phases,
+                hasTransaction,
+                customHandler,
+                data: {
+                    version: {},
+                    handlerType: Enums_1.HandlerTypes.INSERT,
+                    model: {},
+                    parentModel: null,
+                    relation: null,
+                },
+            });
+        });
+    }
+    static match(request) {
+        if (!request) {
+            return undefined;
+        }
+        for (const item of URLService.urls) {
+            const found = item.method === request.method &&
+                check(request.url.pathname, item.pattern);
+            if (found) {
+                return Object.assign(Object.assign({}, item), { params: found });
+            }
+        }
+    }
+    static getAllURLs() {
+        return this.urls;
+    }
+    static getDefaultPhases(middlewares) {
+        // We should convert to all StepTypes functions to PhaseFunctions
+        const callbacks = middlewares.map(ConverterService_1.toPhaseFunction);
+        const phases = [
+            // Internal middlewares
+            ...callbacks.map((callback) => {
+                return {
+                    isAsync: true,
+                    name: `middleware:${callback.name || "anonymous"}`,
+                    callback,
+                };
+            }),
+        ];
+        return phases;
+    }
+}
+URLService.urls = [];
+exports.default = URLService;

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

@@ -1,4 +1,5 @@
 import APIService from "./APIService";
+import App from "./App";
 import DocumentationService from "./DocumentationService";
 import IoCService from "./IoCService";
 import { allow, deny } from "./LimitService";
@@ -7,4 +8,6 @@ import ModelListService from "./ModelListService";
 import ModelService from "./ModelService";
 import QueryService from "./QueryService";
 import SchemaValidatorService from "./SchemaValidatorService";
-export { DocumentationService, APIService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, allow, deny, };
+import AxeRequest from "./AxeRequest";
+import AxeResponse from "./AxeResponse";
+export { App, AxeRequest, AxeResponse, DocumentationService, APIService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, allow, deny, };

package/build/src/Services/index.js

@@ -3,9 +3,11 @@ 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.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.APIService = exports.DocumentationService = void 0;
+exports.deny = exports.allow = exports.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.APIService = exports.DocumentationService = exports.AxeResponse = exports.AxeRequest = exports.App = void 0;
 const APIService_1 = __importDefault(require("./APIService"));
 exports.APIService = APIService_1.default;
+const App_1 = __importDefault(require("./App"));
+exports.App = App_1.default;
 const DocumentationService_1 = __importDefault(require("./DocumentationService"));
 exports.DocumentationService = DocumentationService_1.default;
 const IoCService_1 = __importDefault(require("./IoCService"));
@@ -23,3 +25,7 @@ const QueryService_1 = __importDefault(require("./QueryService"));
 exports.QueryService = QueryService_1.default;
 const SchemaValidatorService_1 = __importDefault(require("./SchemaValidatorService"));
 exports.SchemaValidatorService = SchemaValidatorService_1.default;
+const AxeRequest_1 = __importDefault(require("./AxeRequest"));
+exports.AxeRequest = AxeRequest_1.default;
+const AxeResponse_1 = __importDefault(require("./AxeResponse"));
+exports.AxeResponse = AxeResponse_1.default;

package/build/src/Types.d.ts

@@ -1,8 +1,20 @@
-import { NextFunction, Request, Response } from "express";
-import { IRequestPack, IHookParameter } from "./Interfaces";
-export type SerializationFunction = (item: any, request: Request) => any;
-export type HandlerFunction = (pack: IRequestPack) => void;
-export type MiddlewareFunction = (req: Request, res: Response, next: NextFunction) => void;
+/// <reference types="node" />
+/// <reference types="express" />
+import { IncomingMessage, ServerResponse } from "http";
+import { IHandlerBaseMiddleware, IRequestPack } from "./Interfaces";
+import AxeRequest from "./Services/AxeRequest";
+import AxeResponse from "./Services/AxeResponse";
+import { HookFunctionTypes } from "./Enums";
 export type ModelValidation = Record<string, string>;
 export type FieldList = string[];
-export type HookFunction = (pack: IHookParameter) => Promise<void>;
+export type DefaultResponse = Promise<void> | void | undefined;
+export type AdaptorTypes = "redis" | "memory";
+export type MiddlewareFunction = (req: IncomingMessage, res: ServerResponse, next: NextFunction) => DefaultResponse;
+export type HandlerFunction = (request: AxeRequest, response: AxeResponse) => DefaultResponse;
+export type PhaseFunction = (context: IRequestPack) => DefaultResponse;
+export type SerializationFunction = (item: any, request: AxeRequest) => any;
+export type HookFunctions = Record<HookFunctionTypes, PhaseFunction>;
+export type NextFunction = (error: any) => void;
+export type DynamicFunctionType = (MiddlewareFunction | HandlerFunction)[];
+export type StepTypes = MiddlewareFunction | HandlerFunction | PhaseFunction;
+export type ModelMiddlewareDefinition = Array<StepTypes | IHandlerBaseMiddleware>;