axe-api 0.31.4 → 1.0.0-rc1

package/build/src/Phases/Single/PrepareGetPhase.js

@@ -0,0 +1,19 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("../../Handlers/Helpers");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    context.query = context.database.from(context.model.instance.table);
+    // If there is a relation, we should bind it
+    (0, Helpers_1.addForeignKeyQuery)(context.req, context.query, context.relation, context.parentModel);
+    // If there is a deletedAtColumn, it means that this table support soft-delete
+    (0, Helpers_1.addSoftDeleteQuery)(context.model, null, context.query);
+});

package/build/src/Phases/Single/RelationalPhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/Single/RelationalPhase.js

@@ -0,0 +1,17 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("../../Handlers/Helpers");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    // We should try to get related data if there is any
+    yield (0, Helpers_1.getRelatedData)(context.version, [context.item], ((_a = context.conditions) === null || _a === void 0 ? void 0 : _a.with) || [], context.model, context.version.modelList, context.database, context.handlerType, context.req);
+});

package/build/src/Phases/Single/ResultPhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/Single/ResultPhase.js

@@ -0,0 +1,14 @@
+"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 });
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    context.res.json(context.item);
+});

package/build/src/Phases/Single/SerializePhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/Single/SerializePhase.js

@@ -0,0 +1,18 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("../../Handlers/Helpers");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    // Serializing the data by the model's serialize method
+    context.item = yield (0, Helpers_1.serializeData)(context.version, context.item, context.model.serialize, context.handlerType, context.req);
+    // Filtering hidden fields from the response data.
+    (0, Helpers_1.filterHiddenFields)([context.item], context.model.instance.hiddens);
+});

package/build/src/Phases/Single/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    RelationalPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+    ResultPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+    SerializePhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+    PrepareGetPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+    GetPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+};
+export default _default;

package/build/src/Phases/Single/index.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 RelationalPhase_1 = __importDefault(require("./RelationalPhase"));
+const ResultPhase_1 = __importDefault(require("./ResultPhase"));
+const SerializePhase_1 = __importDefault(require("./SerializePhase"));
+const PrepareGetPhase_1 = __importDefault(require("./PrepareGetPhase"));
+const GetPhase_1 = __importDefault(require("./GetPhase"));
+exports.default = {
+    RelationalPhase: RelationalPhase_1.default,
+    ResultPhase: ResultPhase_1.default,
+    SerializePhase: SerializePhase_1.default,
+    PrepareGetPhase: PrepareGetPhase_1.default,
+    GetPhase: GetPhase_1.default,
+};

package/build/src/Phases/Store/ActionPhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/Store/ActionPhase.js

@@ -0,0 +1,29 @@
+"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 });
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const [returningResult] = yield context
+        .database(context.model.instance.table)
+        .insert(context.formData)
+        .returning(context.model.instance.primaryKey);
+    let insertedPrimaryKeyValue = typeof returningResult === "number"
+        ? returningResult
+        : returningResult[context.model.instance.primaryKey];
+    // If the user use a special primary key value, we should use that value
+    if (insertedPrimaryKeyValue === 0) {
+        insertedPrimaryKeyValue =
+            context.formData[context.model.instance.primaryKey];
+    }
+    context.item = yield context
+        .database(context.model.instance.table)
+        .where(context.model.instance.primaryKey, insertedPrimaryKeyValue)
+        .first();
+});

package/build/src/Phases/Store/PreparePhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/Store/PreparePhase.js

@@ -0,0 +1,46 @@
+"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 validatorjs_1 = __importDefault(require("validatorjs"));
+const Helpers_1 = require("../../Handlers/Helpers");
+const Enums_1 = require("../../Enums");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const requestMethod = context.req
+        .method;
+    const fillables = context.model.instance.getFillableFields(requestMethod);
+    context.formData = (0, Helpers_1.getMergedFormData)(context.req, fillables);
+    const validationRules = context.model.instance.getValidationRules(requestMethod);
+    if (validationRules) {
+        // The validation language should be set
+        validatorjs_1.default.useLang(context.req.currentLanguage.language);
+        // Validate the data
+        const validation = new validatorjs_1.default(context.formData, validationRules);
+        if (validation.fails()) {
+            context.res.json(validation.errors, 400);
+            return;
+        }
+    }
+    if (context.relation && context.parentModel) {
+        const parentColumn = (0, Helpers_1.getParentColumn)(context.relation);
+        if (parentColumn) {
+            context.formData[context.relation.foreignKey] =
+                context.params[parentColumn];
+        }
+    }
+    // We should bind the timestamp values
+    (0, Helpers_1.bindTimestampValues)(context.formData, context.model, [
+        Enums_1.TimestampColumns.CREATED_AT,
+        Enums_1.TimestampColumns.UPDATED_AT,
+    ]);
+});

package/build/src/Phases/Store/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    PreparePhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+    ActionPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+};
+export default _default;

package/build/src/Phases/Store/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const PreparePhase_1 = __importDefault(require("./PreparePhase"));
+const ActionPhase_1 = __importDefault(require("./ActionPhase"));
+exports.default = {
+    PreparePhase: PreparePhase_1.default,
+    ActionPhase: ActionPhase_1.default,
+};

package/build/src/Phases/Update/ActionPhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/Update/ActionPhase.js

@@ -0,0 +1,22 @@
+"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 });
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    if (context.query) {
+        yield context.query
+            .where(context.model.instance.primaryKey, context.item[context.model.instance.primaryKey])
+            .update(context.formData);
+        context.item = yield context
+            .database(context.model.instance.table)
+            .where(context.model.instance.primaryKey, context.item[context.model.instance.primaryKey])
+            .first();
+    }
+});

package/build/src/Phases/Update/PrepareActionPhase.d.ts

@@ -0,0 +1,3 @@
+import { IRequestPack } from "../../Interfaces";
+declare const _default: (context: IRequestPack) => Promise<void>;
+export default _default;

package/build/src/Phases/Update/PrepareActionPhase.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const validatorjs_1 = __importDefault(require("validatorjs"));
+const Enums_1 = require("../../Enums");
+const Helpers_1 = require("../../Handlers/Helpers");
+exports.default = (context) => __awaiter(void 0, void 0, void 0, function* () {
+    const requestMethod = context.req
+        .method;
+    const fillables = context.model.instance.getFillableFields(requestMethod);
+    context.formData = (0, Helpers_1.getMergedFormData)(context.req, fillables);
+    const validationRules = context.model.instance.getValidationRules(requestMethod);
+    if (validationRules) {
+        // The validation language should be set
+        validatorjs_1.default.useLang(context.req.currentLanguage.language);
+        // Validate the data
+        const validation = new validatorjs_1.default(context.formData, validationRules);
+        if (validation.fails()) {
+            return context.res.json(validation.errors, 400);
+        }
+    }
+    // We should bind the timestamp values
+    (0, Helpers_1.bindTimestampValues)(context.formData, context.model, [
+        Enums_1.TimestampColumns.UPDATED_AT,
+    ]);
+});

package/build/src/Phases/Update/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    ActionPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+    PrepareActionPhase: (context: import("../../Interfaces").IRequestPack) => Promise<void>;
+};
+export default _default;

package/build/src/Phases/Update/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ActionPhase_1 = __importDefault(require("./ActionPhase"));
+const PrepareActionPhase_1 = __importDefault(require("./PrepareActionPhase"));
+exports.default = {
+    ActionPhase: ActionPhase_1.default,
+    PrepareActionPhase: PrepareActionPhase_1.default,
+};

package/build/src/Server.d.ts

@@ -1,7 +1,6 @@
 declare class Server {
     start(rootFolder: string): Promise<void>;
     private bindDependencies;
-    private loadExpress;
     private analyzeVersions;
     private loadGeneralConfiguration;
     private listen;

package/build/src/Server.js

@@ -38,7 +38,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const Resolvers_1 = require("./Resolvers");
 const dotenv_1 = __importDefault(require("dotenv"));
 const path_1 = __importDefault(require("path"));
-const express_1 = __importDefault(require("express"));
 const knex_1 = __importDefault(require("knex"));
 const knex_schema_inspector_1 = __importDefault(require("knex-schema-inspector"));
 const knex_paginate_1 = require("knex-paginate");
@@ -48,6 +47,9 @@ const MetadataHandler_1 = __importDefault(require("./Handlers/MetadataHandler"))
 const DocsHTMLHandler_1 = __importDefault(require("./Handlers/DocsHTMLHandler"));
 const RoutesHandler_1 = __importDefault(require("./Handlers/RoutesHandler"));
 const Helpers_1 = require("./Helpers");
+const http_1 = __importDefault(require("http"));
+const RequestHandler_1 = __importDefault(require("./Handlers/RequestHandler"));
+const App_1 = __importDefault(require("./Services/App"));
 class Server {
     start(rootFolder) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -55,7 +57,6 @@ class Server {
             try {
                 yield this.bindDependencies(rootFolder);
                 yield this.loadGeneralConfiguration();
-                yield this.loadExpress();
                 yield this.analyzeVersions();
                 yield this.listen();
             }
@@ -74,24 +75,15 @@ class Server {
             Services_1.APIService.setInsance(rootFolder);
             const api = Services_1.APIService.getInstance();
             Services_1.IoCService.singleton("SchemaInspector", () => knex_schema_inspector_1.default);
+            Services_1.IoCService.singleton("App", () => new App_1.default());
             Services_1.IoCService.singleton("Database", () => __awaiter(this, void 0, void 0, function* () {
                 const database = (0, knex_1.default)(api.config.database);
                 (0, knex_paginate_1.attachPaginate)();
                 return database;
             }));
-            Services_1.IoCService.singleton("App", () => __awaiter(this, void 0, void 0, function* () {
-                return (0, express_1.default)();
-            }));
             Services_1.LogService.setInstance(api.config.logLevel);
         });
     }
-    loadExpress() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const app = yield Services_1.IoCService.use("App");
-            app.use(express_1.default.urlencoded({ extended: true }));
-            app.use(express_1.default.json());
-        });
-    }
     analyzeVersions() {
         return __awaiter(this, void 0, void 0, function* () {
             const api = Services_1.APIService.getInstance();
@@ -115,17 +107,22 @@ class Server {
     }
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
-            const app = yield Services_1.IoCService.use("App");
+            const app = yield Services_1.IoCService.useByType("App");
+            app.use(RequestHandler_1.default);
+            const server = http_1.default.createServer(app.instance);
             const logger = Services_1.LogService.getInstance();
             const api = Services_1.APIService.getInstance();
+            server.on("error", function (e) {
+                // Handle your error here
+                console.log("GENERAL", e);
+            });
+            server.listen(api.config.port);
+            logger.info(`API listens requests on http://localhost:${api.config.port}`);
             if (api.config.env === "development") {
                 app.get("/metadata", MetadataHandler_1.default);
                 app.get("/docs", DocsHTMLHandler_1.default);
                 app.get("/routes", RoutesHandler_1.default);
             }
-            app.listen(api.config.port, () => {
-                logger.info(`API listens requests on http://localhost:${api.config.port}`);
-            });
         });
     }
 }

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

@@ -0,0 +1,14 @@
+import connect from "connect";
+import { HandlerFunction } from "../Types";
+declare class App {
+    private connect;
+    constructor();
+    get instance(): connect.Server;
+    use(middleware: connect.NextHandleFunction): void;
+    get(url: string, handler: HandlerFunction): void;
+    post(url: string, handler: HandlerFunction): void;
+    put(url: string, handler: HandlerFunction): void;
+    patch(url: string, handler: HandlerFunction): void;
+    delete(url: string, handler: HandlerFunction): void;
+}
+export default App;

package/build/src/Services/App.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const connect_1 = __importDefault(require("connect"));
+const body_parser_1 = __importDefault(require("body-parser"));
+const URLService_1 = __importDefault(require("./URLService"));
+class App {
+    constructor() {
+        this.connect = (0, connect_1.default)();
+        this.connect.use(body_parser_1.default.urlencoded({ extended: true }));
+        this.connect.use(body_parser_1.default.json());
+    }
+    get instance() {
+        return this.connect;
+    }
+    use(middleware) {
+        this.connect.use(middleware);
+    }
+    get(url, handler) {
+        URLService_1.default.addHandler("GET", url, handler);
+    }
+    post(url, handler) {
+        URLService_1.default.addHandler("POST", url, handler);
+    }
+    put(url, handler) {
+        URLService_1.default.addHandler("PUT", url, handler);
+    }
+    patch(url, handler) {
+        URLService_1.default.addHandler("PATCH", url, handler);
+    }
+    delete(url, handler) {
+        URLService_1.default.addHandler("DELETE", url, handler);
+    }
+}
+exports.default = App;

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

@@ -0,0 +1,24 @@
+/// <reference types="node" />
+/// <reference types="express" />
+import { IncomingMessage } from "http";
+import { ILanguage } from "../Interfaces";
+declare class AxeRequest {
+    private request;
+    private language;
+    private urlObject;
+    private privateParams;
+    private version;
+    constructor(request: IncomingMessage);
+    get url(): URL;
+    get params(): any;
+    set params(value: any);
+    get query(): URLSearchParams;
+    get path(): string;
+    get method(): string;
+    get body(): any;
+    get currentLanguage(): ILanguage;
+    set currentLanguage(language: ILanguage);
+    header(key: string): string | string[] | undefined;
+    get original(): IncomingMessage;
+}
+export default AxeRequest;

package/build/src/Services/AxeRequest.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Helpers_1 = require("../Helpers");
+const Resolvers_1 = require("../Resolvers");
+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];
+    }
+    get original() {
+        return this.request;
+    }
+}
+exports.default = AxeRequest;

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

@@ -0,0 +1,17 @@
+/// <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>;
+    json(data: object, statusCode?: number): void;
+    send(content: string, statusCode?: number): void;
+    noContent(): void;
+    isResponded(): boolean;
+    statusCode(): number;
+}
+export default AxeResponse;

package/build/src/Services/AxeResponse.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class AxeResponse {
+    constructor(response, language) {
+        this.responseStatus = false;
+        this.response = response;
+        this.language = language;
+    }
+    get original() {
+        return this.response;
+    }
+    json(data, statusCode = 200) {
+        this.response.setHeader("Content-Type", "application/json");
+        this.response.setHeader("Content-Language", this.language.language);
+        this.response.statusCode = statusCode;
+        this.response.write(JSON.stringify(data));
+        this.response.end();
+        this.responseStatus = true;
+    }
+    send(content, statusCode = 200) {
+        this.response.statusCode = statusCode;
+        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/LogService.js

@@ -2,7 +2,6 @@
 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;
 class LogService {
     constructor(level) {
         this.level = level;
@@ -15,22 +14,22 @@ class LogService {
     }
     error(message) {
         if (this.level >= Enums_1.LogLevels.ERROR) {
-            console.error(fgRed, "[axe]", message, fgReset);
+            console.error(constants_1.LOG_COLORS.fgRed, "[axe]", message, constants_1.LOG_COLORS.fgReset);
         }
     }
     warn(message) {
         if (this.level >= Enums_1.LogLevels.WARNING) {
-            console.warn(fgYellow, "[axe]", message, fgReset);
+            console.warn(constants_1.LOG_COLORS.fgYellow, "[axe]", message, constants_1.LOG_COLORS.fgReset);
         }
     }
     info(message) {
         if (this.level >= Enums_1.LogLevels.INFO) {
-            console.info(fgCyan, "[axe]", message, fgReset);
+            console.info(constants_1.LOG_COLORS.fgCyan, "[axe]", message, constants_1.LOG_COLORS.fgReset);
         }
     }
     success(message) {
         if (this.level >= Enums_1.LogLevels.INFO) {
-            console.info(fgGreen, "[axe]", message, fgReset);
+            console.info(constants_1.LOG_COLORS.fgGreen, "[axe]", message, constants_1.LOG_COLORS.fgReset);
         }
     }
     debug(message) {