axe-api 0.31.4 → 1.0.0-rc10

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.status(400).json(validation.errors);
+            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.status(400).json(validation.errors);
+        }
+    }
+    // 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/Resolvers/ModelResolver.js

@@ -26,16 +26,22 @@ class ModelResolver {
     }
     resolve() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = Services_1.LogService.getInstance();
             const modelList = new Services_1.ModelListService(yield this.getModelList());
+            Services_1.LogService.debug(`[${this.version.name}] Model list has been resolved`);
             yield this.setModelRelations(modelList);
+            Services_1.LogService.debug(`[${this.version.name}] Model relations have been resolved`);
             yield this.setDatabaseColumns(modelList);
+            Services_1.LogService.debug(`[${this.version.name}] Database columns have been bonded with models`);
             yield this.setModelHooks(modelList, Enums_1.Extensions.Hooks);
+            Services_1.LogService.debug(`[${this.version.name}] Model hooks have been loaded`);
             yield this.setModelHooks(modelList, Enums_1.Extensions.Events);
+            Services_1.LogService.debug(`[${this.version.name}] Model events have been loaded`);
             yield this.setModelSerializations(modelList);
+            Services_1.LogService.debug(`[${this.version.name}] Model serializers have been loaded`);
             yield this.setModelQueryLimits(modelList);
+            Services_1.LogService.debug(`[${this.version.name}] Model query limits have been loaded`);
             this.version.modelList = modelList;
-            logger.info(`[${this.version.name}] All models have been resolved.`);
+            Services_1.LogService.debug(`[${this.version.name}] All models have been resolved.`);
         });
     }
     setModelRelations(modelList) {
@@ -88,7 +94,6 @@ class ModelResolver {
     }
     setModelHooks(modelList, hookType) {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = Services_1.LogService.getInstance();
             // What kind of hooks that we can have
             const hookList = Object.keys(Enums_1.HookFunctionTypes);
             const fileResolver = new FileResolver_1.default();
@@ -119,7 +124,7 @@ class ModelResolver {
                         currentModel.setExtensions(hookType, hookName, hooks[hookName].default);
                     }
                     else {
-                        logger.warn(`Invalid ${hookType} type: "${hookName}" in this folder: "${subfolderPath}"`);
+                        Services_1.LogService.warn(`Invalid ${hookType} type: "${hookName}" in this folder: "${subfolderPath}"`);
                     }
                 }
             }

package/build/src/Resolvers/VersionConfigResolver.js

@@ -39,6 +39,7 @@ const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const AxeError_1 = __importDefault(require("../Exceptions/AxeError"));
 const Enums_1 = require("../Enums");
+const constants_1 = require("../constants");
 class VersionConfigResolver {
     constructor(version) {
         this.version = version;
@@ -50,8 +51,12 @@ class VersionConfigResolver {
                 !fs_1.default.existsSync(`${versionConfigFile}.js`)) {
                 throw new AxeError_1.default(Enums_1.AxeErrorCode.VERSION_CONFIG_NOT_FOUND, `The version file not found: ${versionConfigFile}.ts`);
             }
+            // Loading the configuration file
             const { default: content } = yield Promise.resolve(`${versionConfigFile}`).then(s => __importStar(require(s)));
-            this.version.config = content;
+            // Merging the configurations with the default version configurations
+            const apiConfiguration = Object.assign(Object.assign({}, constants_1.DEFAULT_VERSION_CONFIG), content);
+            // Setting the config values
+            this.version.config = apiConfiguration;
         });
     }
 }

package/build/src/Resolvers/VersionResolver.js

@@ -27,9 +27,8 @@ const RESERVED_VERSION_FOLDERS = [
 class VersionResolver {
     resolve() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = Services_1.LogService.getInstance();
             yield this.getVersions();
-            logger.info("All API versions have been resolved.");
+            Services_1.LogService.debug("All API versions have been resolved.");
         });
     }
     getVersions() {

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");
@@ -47,21 +46,24 @@ const Services_1 = require("./Services");
 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"));
+const constants_1 = require("./constants");
 class Server {
     start(rootFolder) {
         return __awaiter(this, void 0, void 0, function* () {
             dotenv_1.default.config();
             try {
-                yield this.bindDependencies(rootFolder);
+                Services_1.APIService.setInsance(rootFolder);
                 yield this.loadGeneralConfiguration();
-                yield this.loadExpress();
+                yield this.bindDependencies();
                 yield this.analyzeVersions();
                 yield this.listen();
             }
             catch (error) {
                 if (error.type === "AxeError") {
-                    (0, Helpers_1.consoleAxeError)(error);
+                    Services_1.LogService.error(error);
                 }
                 else {
                     throw error;
@@ -69,27 +71,18 @@ class Server {
             }
         });
     }
-    bindDependencies(rootFolder) {
+    bindDependencies() {
         return __awaiter(this, void 0, void 0, function* () {
-            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);
+                Services_1.LogService.debug("Created a knex connection instance");
                 (0, knex_paginate_1.attachPaginate)();
+                Services_1.LogService.debug("Added pagination support to the knex");
                 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() {
@@ -108,24 +101,36 @@ class Server {
     loadGeneralConfiguration() {
         return __awaiter(this, void 0, void 0, function* () {
             const api = Services_1.APIService.getInstance();
+            // Getting configuration file path
             const generalConfigFile = path_1.default.join(api.appFolder, "config");
+            // Loading the configurations
             const { default: content } = yield Promise.resolve(`${generalConfigFile}`).then(s => __importStar(require(s)));
-            api.setConfig(content);
+            // Merge the configuration with the default configurations
+            const apiConfiguration = Object.assign(Object.assign({}, constants_1.DEFAULT_APP_CONFIG), content);
+            // Setting the configurations
+            api.setConfig(apiConfiguration);
+            // Setting the logger instance
+            Services_1.LogService.setInstance(api.config.pino);
+            Services_1.LogService.debug("Configurations are loaded");
         });
     }
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
-            const app = yield Services_1.IoCService.use("App");
-            const logger = Services_1.LogService.getInstance();
+            const app = yield Services_1.IoCService.useByType("App");
+            app.use(RequestHandler_1.default);
+            const server = http_1.default.createServer(app.instance);
             const api = Services_1.APIService.getInstance();
+            server.on("error", function (e) {
+                // Handle your error here
+                console.log("GENERAL", e);
+            });
             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}`);
-            });
+            server.listen(api.config.port);
+            Services_1.LogService.info(`Axe API listens requests on http://localhost:${api.config.port}`);
         });
     }
 }

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

@@ -1,4 +1,4 @@
-import { IApplicationConfig, IVersion } from "../Interfaces";
+import { AxeConfig, IVersion } from "../Interfaces";
 declare class APIService {
     private folders;
     private static instance;
@@ -8,8 +8,8 @@ declare class APIService {
     get rootFolder(): string;
     get appFolder(): string;
     get versions(): IVersion[];
-    get config(): IApplicationConfig;
-    setConfig(config: IApplicationConfig): void;
+    get config(): AxeConfig;
+    setConfig(config: AxeConfig): void;
     addVersion(name: string): void;
     getVersion(name: string): IVersion;
 }

package/build/src/Services/APIService.js

@@ -4,21 +4,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
-const Enums_1 = require("../Enums");
 const ModelListService_1 = __importDefault(require("./ModelListService"));
+const constants_1 = require("../constants");
 class APIService {
     constructor(rootFolder) {
         this.folders = {
             rootFolder: rootFolder,
             appFolder: path_1.default.join(rootFolder, "app"),
             versions: [],
-            config: {
-                env: "production",
-                port: 3000,
-                logLevel: Enums_1.LogLevels.INFO,
-                prefix: "/api",
-                database: {},
-            },
+            config: constants_1.DEFAULT_APP_CONFIG,
         };
     }
     static getInstance() {
@@ -57,6 +51,7 @@ class APIService {
                 query: {
                     limits: [],
                 },
+                formidable: {},
             },
             folders: {
                 root,

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

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

package/build/src/Services/App.js

@@ -0,0 +1,80 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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"));
+const LogService_1 = __importDefault(require("./LogService"));
+const RateLimit_1 = __importStar(require("../Middlewares/RateLimit"));
+const APIService_1 = __importDefault(require("./APIService"));
+const ConverterService_1 = require("./ConverterService");
+class App {
+    constructor() {
+        var _a;
+        this.connect = (0, connect_1.default)();
+        LogService_1.default.debug("Created a new connect() instance");
+        this.connect.use(body_parser_1.default.urlencoded({ extended: true }));
+        this.connect.use(body_parser_1.default.json());
+        LogService_1.default.debug("New middleware: bodyParser()");
+        // Activate the Rate Limit middleware
+        const api = APIService_1.default.getInstance();
+        (0, RateLimit_1.setupRateLimitAdaptors)(api.config);
+        if ((_a = api.config.rateLimit) === null || _a === void 0 ? void 0 : _a.enabled) {
+            LogService_1.default.debug("New middleware: rateLimit()");
+            this.connect.use(RateLimit_1.default);
+        }
+    }
+    get instance() {
+        return this.connect;
+    }
+    use(middleware) {
+        this.connect.use(middleware);
+        LogService_1.default.debug(`New middleware: ${middleware.name || "anonymous"}()`);
+    }
+    get(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("GET", url, handler, middlewares);
+    }
+    post(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("POST", url, handler, middlewares);
+    }
+    put(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("PUT", url, handler, middlewares);
+    }
+    patch(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("PATCH", url, handler, middlewares);
+    }
+    delete(url, ...args) {
+        const { handler, middlewares } = (0, ConverterService_1.resolveMiddlewares)(args);
+        URLService_1.default.addHandler("DELETE", url, handler, middlewares);
+    }
+}
+exports.default = App;

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

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+/// <reference types="express" />
+import formidable, { Options as FormOptions } from "formidable";
+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;
+    files(options?: FormOptions): Promise<[formidable.Fields, formidable.Files]>;
+    get original(): IncomingMessage;
+}
+export default AxeRequest;