axe-api 0.22.0 → 0.30.0-rc10

package/build/src/Resolvers/ModelResolver.js

@@ -12,21 +12,30 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const promises_1 = require("fs/promises");
 const FileResolver_1 = __importDefault(require("./FileResolver"));
 const Enums_1 = require("../Enums");
 const Services_1 = require("../Services");
 const constants_1 = require("../constants");
+const AxeError_1 = __importDefault(require("../Exceptions/AxeError"));
 class ModelResolver {
+    constructor(version) {
+        this.version = version;
+    }
     resolve() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = yield Services_1.IoCService.useByType("LogService");
+            const logger = Services_1.LogService.getInstance();
             const modelList = new Services_1.ModelListService(yield this.getModelList());
             yield this.setModelRelations(modelList);
             yield this.setDatabaseColumns(modelList);
             yield this.setModelHooks(modelList, Enums_1.Extensions.Hooks);
             yield this.setModelHooks(modelList, Enums_1.Extensions.Events);
-            Services_1.IoCService.singleton("ModelListService", () => modelList);
-            logger.info("All models have been resolved.");
+            yield this.setModelSerializations(modelList);
+            yield this.setModelQueryLimits(modelList);
+            this.version.modelList = modelList;
+            logger.info(`[${this.version.name}] All models have been resolved.`);
         });
     }
     setModelRelations(modelList) {
@@ -48,9 +57,8 @@ class ModelResolver {
     getModelList() {
         return __awaiter(this, void 0, void 0, function* () {
             const list = [];
-            const folders = (yield Services_1.IoCService.use("Folders"));
             const fileResolver = new FileResolver_1.default();
-            const models = yield fileResolver.resolve(folders.Models);
+            const models = yield fileResolver.resolve(this.version.folders.models);
             for (const key in models) {
                 list.push(new Services_1.ModelService(key, models[key]));
             }
@@ -72,7 +80,7 @@ class ModelResolver {
             for (const model of modelList.get()) {
                 const modelColumns = columns.filter((column) => column.table_name === model.instance.table);
                 if (modelColumns.length === 0) {
-                    throw new Error(`The "${model.instance.table}" table doesn't have any column. Are you sure about the table name?`);
+                    throw new AxeError_1.default(Enums_1.AxeErrorCode.TABLE_DOESNT_HAVE_ANY_COLUMN, `The "${model.instance.table}" table doesn't have any column.`);
                 }
                 model.setColumns(modelColumns);
             }
@@ -80,25 +88,97 @@ class ModelResolver {
     }
     setModelHooks(modelList, hookType) {
         return __awaiter(this, void 0, void 0, function* () {
-            const folders = (yield Services_1.IoCService.use("Folders"));
+            // What kind of hooks that we can have
+            const hookList = Object.keys(Enums_1.HookFunctionTypes);
+            const fileResolver = new FileResolver_1.default();
+            // Basic hook/event folder path
+            const folder = hookType === Enums_1.Extensions.Hooks
+                ? this.version.folders.hooks
+                : this.version.folders.events;
+            // We should check the old-style hooks files
+            yield this.checkOldStyleHookFiles(folder);
+            // Get model-based subfolders
+            const hookSubfolders = yield this.getDirectories(folder);
+            // For each subfolder, we can have many different hook file
+            for (const hookSubfolder of hookSubfolders) {
+                // Full path of the subfolder
+                const subfolderPath = path_1.default.join(folder, hookSubfolder);
+                // Determining which model we are working on by subfolder
+                const currentModel = modelList.find(hookSubfolder);
+                // If we can't find a model, it means that the developer are using wrong name
+                if (!currentModel) {
+                    throw new AxeError_1.default(Enums_1.AxeErrorCode.UNDEFINED_HOOK_MODEL_RELATION, `Undefined model relation: ${subfolderPath}`);
+                }
+                // Loading all hooks files in the subfolder
+                const hooks = yield fileResolver.resolveContent(subfolderPath);
+                for (const hookName of hookList) {
+                    // If we have an acceptable hook
+                    if (hooks[hookName]) {
+                        // We bind the hook with the model
+                        currentModel.setExtensions(hookType, hookName, hooks[hookName].default);
+                    }
+                }
+            }
+        });
+    }
+    getDirectories(source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!fs_1.default.existsSync(source)) {
+                return [];
+            }
+            return (yield (0, promises_1.readdir)(source, { withFileTypes: true }))
+                .filter((dirent) => dirent.isDirectory())
+                .map((dirent) => dirent.name);
+        });
+    }
+    checkOldStyleHookFiles(source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!fs_1.default.existsSync(source)) {
+                return;
+            }
+            // We are fetching the root-level file list
+            const files = (yield (0, promises_1.readdir)(source, { withFileTypes: true }))
+                .filter((dirent) => !dirent.isDirectory())
+                .map((dirent) => dirent.name)
+                .filter((filename) => filename !== ".gitignore");
+            // If there is any hook or event file in the root level
+            const hasHookorEvent = files.some((file) => file.includes("Hook.ts") || file.includes("Event.ts"));
+            // Throwing an exception
+            if (hasHookorEvent) {
+                throw new AxeError_1.default(Enums_1.AxeErrorCode.UNACCEPTABLE_HOOK_FILE, `All hook or event files should be located under a model folder: ${source}`);
+            }
+        });
+    }
+    setModelSerializations(modelList) {
+        return __awaiter(this, void 0, void 0, function* () {
             const fileResolver = new FileResolver_1.default();
-            const folder = hookType === Enums_1.Extensions.Hooks ? folders.Hooks : folders.Events;
-            const hooks = yield fileResolver.resolveContent(folder);
+            const serializations = yield fileResolver.resolveContent(this.version.folders.serialization);
             for (const model of modelList.get()) {
-                const hookFileName = `${model.name}${hookType
-                    .toString()
-                    .replace("s", "")}`;
-                if (hooks[hookFileName]) {
-                    const keys = Object.keys(hooks[hookFileName]);
-                    keys.forEach((key) => {
-                        const strEnum = key;
-                        const hookFunctionType = Enums_1.HookFunctionTypes[strEnum];
-                        model.setExtensions(hookType, hookFunctionType, hooks[hookFileName][key]);
-                    });
+                const fileName = `${model.name}Serialization`;
+                if (serializations[fileName]) {
+                    const file = serializations[fileName];
+                    model.setSerialization(file.default);
                 }
             }
         });
     }
+    setModelQueryLimits(modelList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const model of modelList.get()) {
+                // We should use the full field name like `users.name`
+                const modelLimits = model.instance.limits.flat().map((item) => {
+                    if (item.key) {
+                        item.key = `${model.instance.table}.${item.key}`;
+                    }
+                    return Object.assign({}, item);
+                });
+                model.setQueryLimits([
+                    ...this.version.config.query.limits.flat(),
+                    ...modelLimits,
+                ]);
+            }
+        });
+    }
     getInstanceMethods(obj) {
         const properties = Object.getOwnPropertyNames(obj.instance.constructor.prototype);
         return properties.filter((name) => !constants_1.DEFAULT_METHODS_OF_MODELS.includes(name));

package/build/src/Resolvers/TransactionResolver.d.ts

@@ -1,7 +1,9 @@
-import { IModelService } from "../Interfaces";
+import { IModelService, IVersion } from "../Interfaces";
 import { HandlerTypes } from "../Enums";
 declare class TransactionResolver {
-    static resolve(model: IModelService, handlerType: HandlerTypes): Promise<boolean>;
+    private version;
+    constructor(version: IVersion);
+    resolve(model: IModelService, handlerType: HandlerTypes): Promise<boolean>;
     private static resolveTransactionOption;
     private static getTransactionConfiguration;
 }

package/build/src/Resolvers/TransactionResolver.js

@@ -9,12 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Services_1 = require("../Services");
 class TransactionResolver {
-    static resolve(model, handlerType) {
+    constructor(version) {
+        this.version = version;
+    }
+    resolve(model, handlerType) {
         return __awaiter(this, void 0, void 0, function* () {
-            const config = yield Services_1.IoCService.use("Config");
-            const global = config.Application.transaction;
+            const global = this.version.config.transaction;
             const local = model.instance.transaction;
             let privilegedOption = false;
             if (global) {

package/build/src/Resolvers/VersionConfigResolver.d.ts

@@ -0,0 +1,7 @@
+import { IVersion } from "../Interfaces";
+declare class VersionConfigResolver {
+    private version;
+    constructor(version: IVersion);
+    resolve(): Promise<void>;
+}
+export default VersionConfigResolver;

package/build/src/Resolvers/VersionConfigResolver.js

@@ -0,0 +1,58 @@
+"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 __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 path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const AxeError_1 = __importDefault(require("../Exceptions/AxeError"));
+const Enums_1 = require("../Enums");
+class VersionConfigResolver {
+    constructor(version) {
+        this.version = version;
+    }
+    resolve() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const versionConfigFile = path_1.default.join(this.version.folders.root, "config");
+            if (!fs_1.default.existsSync(`${versionConfigFile}.ts`) &&
+                !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`);
+            }
+            const { default: content } = yield Promise.resolve(`${versionConfigFile}`).then(s => __importStar(require(s)));
+            this.version.config = content;
+        });
+    }
+}
+exports.default = VersionConfigResolver;

package/build/src/Resolvers/VersionResolver.d.ts

@@ -0,0 +1,7 @@
+declare class VersionResolver {
+    resolve(): Promise<void>;
+    private getVersions;
+    private getDirectories;
+    private checkReservedKeys;
+}
+export default VersionResolver;

package/build/src/Resolvers/VersionResolver.js

@@ -0,0 +1,65 @@
+"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 promises_1 = require("fs/promises");
+const Services_1 = require("../Services");
+const AxeError_1 = __importDefault(require("../Exceptions/AxeError"));
+const Enums_1 = require("../Enums");
+const RESERVED_VERSION_FOLDERS = [
+    "Config",
+    "Events",
+    "Hooks",
+    "Models",
+    "Serialization",
+];
+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.");
+        });
+    }
+    getVersions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = Services_1.APIService.getInstance();
+            const versionFolders = yield this.getDirectories(api.appFolder);
+            this.checkReservedKeys(versionFolders);
+            versionFolders.forEach((version) => {
+                const validation = new validatorjs_1.default({ version }, { version: "required|alpha_num" });
+                if (validation.fails()) {
+                    const { version: versionError } = validation.errors.errors;
+                    const [message] = versionError;
+                    throw new AxeError_1.default(Enums_1.AxeErrorCode.UNACCEPTABLE_VERSION_NAME, `${message} ("${version}")`);
+                }
+                api.addVersion(version);
+            });
+        });
+    }
+    getDirectories(source) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return (yield (0, promises_1.readdir)(source, { withFileTypes: true }))
+                .filter((dirent) => dirent.isDirectory())
+                .map((dirent) => dirent.name);
+        });
+    }
+    checkReservedKeys(names) {
+        const reservedName = names.find((name) => RESERVED_VERSION_FOLDERS.includes(name));
+        if (reservedName) {
+            throw new AxeError_1.default(Enums_1.AxeErrorCode.RESERVED_VERSION_NAME, `You can not use a reserved name in the app directory: ${reservedName}`);
+        }
+    }
+}
+exports.default = VersionResolver;

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

@@ -1,8 +1,9 @@
 import AcceptLanguageResolver from "./AcceptLanguageResolver";
 import FileResolver from "./FileResolver";
-import FolderResolver from "./FolderResolver";
 import GeneralHookResolver from "./GeneralHookResolver";
 import ModelResolver from "./ModelResolver";
 import TransactionResolver from "./TransactionResolver";
+import VersionConfigResolver from "./VersionConfigResolver";
+import VersionResolver from "./VersionResolver";
 import WithQueryResolver from "./WithQueryResolver";
-export { AcceptLanguageResolver, FileResolver, FolderResolver, GeneralHookResolver, ModelResolver, TransactionResolver, WithQueryResolver, };
+export { AcceptLanguageResolver, FileResolver, GeneralHookResolver, ModelResolver, TransactionResolver, VersionConfigResolver, VersionResolver, WithQueryResolver, };

package/build/src/Resolvers/index.js

@@ -3,18 +3,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WithQueryResolver = exports.TransactionResolver = exports.ModelResolver = exports.GeneralHookResolver = exports.FolderResolver = exports.FileResolver = exports.AcceptLanguageResolver = void 0;
+exports.WithQueryResolver = exports.VersionResolver = exports.VersionConfigResolver = exports.TransactionResolver = exports.ModelResolver = exports.GeneralHookResolver = exports.FileResolver = exports.AcceptLanguageResolver = void 0;
 const AcceptLanguageResolver_1 = __importDefault(require("./AcceptLanguageResolver"));
 exports.AcceptLanguageResolver = AcceptLanguageResolver_1.default;
 const FileResolver_1 = __importDefault(require("./FileResolver"));
 exports.FileResolver = FileResolver_1.default;
-const FolderResolver_1 = __importDefault(require("./FolderResolver"));
-exports.FolderResolver = FolderResolver_1.default;
 const GeneralHookResolver_1 = __importDefault(require("./GeneralHookResolver"));
 exports.GeneralHookResolver = GeneralHookResolver_1.default;
 const ModelResolver_1 = __importDefault(require("./ModelResolver"));
 exports.ModelResolver = ModelResolver_1.default;
 const TransactionResolver_1 = __importDefault(require("./TransactionResolver"));
 exports.TransactionResolver = TransactionResolver_1.default;
+const VersionConfigResolver_1 = __importDefault(require("./VersionConfigResolver"));
+exports.VersionConfigResolver = VersionConfigResolver_1.default;
+const VersionResolver_1 = __importDefault(require("./VersionResolver"));
+exports.VersionResolver = VersionResolver_1.default;
 const WithQueryResolver_1 = __importDefault(require("./WithQueryResolver"));
 exports.WithQueryResolver = WithQueryResolver_1.default;

package/build/src/Server.d.ts

@@ -1,8 +1,9 @@
 declare class Server {
-    start(appFolder: string): Promise<void>;
+    start(rootFolder: string): Promise<void>;
     private bindDependencies;
     private loadExpress;
-    private analyzeModels;
+    private analyzeVersions;
+    private loadGeneralConfiguration;
     private listen;
 }
 export default Server;

package/build/src/Server.js

@@ -1,4 +1,27 @@
 "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 __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) {
@@ -14,50 +37,51 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 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");
 const Builders_1 = require("./Builders");
-const HandlerFactory_1 = __importDefault(require("./Handlers/HandlerFactory"));
 const Services_1 = require("./Services");
+const DocsHandler_1 = __importDefault(require("./Handlers/DocsHandler"));
+const RoutesHandler_1 = __importDefault(require("./Handlers/RoutesHandler"));
+const Helpers_1 = require("./Helpers");
 class Server {
-    start(appFolder) {
+    start(rootFolder) {
         return __awaiter(this, void 0, void 0, function* () {
             dotenv_1.default.config();
-            const folders = new Resolvers_1.FolderResolver().resolve(appFolder);
-            const fileResolver = new Resolvers_1.FileResolver();
-            const config = yield fileResolver.resolve(folders.Config);
-            const models = yield fileResolver.resolve(folders.Models);
-            yield this.bindDependencies(folders, config, models);
-            yield this.loadExpress();
-            yield this.analyzeModels();
-            yield this.listen();
+            try {
+                yield this.bindDependencies(rootFolder);
+                yield this.loadGeneralConfiguration();
+                yield this.loadExpress();
+                yield this.analyzeVersions();
+                yield this.listen();
+            }
+            catch (error) {
+                if (error.type === "AxeError") {
+                    (0, Helpers_1.consoleAxeError)(error);
+                }
+                else {
+                    throw error;
+                }
+            }
         });
     }
-    bindDependencies(folders, config, models) {
+    bindDependencies(rootFolder) {
         return __awaiter(this, void 0, void 0, function* () {
-            Services_1.IoCService.singleton("Folders", () => folders);
-            Services_1.IoCService.singleton("Config", () => config);
-            Services_1.IoCService.singleton("Models", () => models);
+            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("Database", () => __awaiter(this, void 0, void 0, function* () {
-                const config = yield Services_1.IoCService.use("Config");
-                const database = (0, knex_1.default)(config.Database);
+                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.IoCService.singleton("HandlerFactory", () => {
-                return new HandlerFactory_1.default();
-            });
-            Services_1.IoCService.singleton("DocumentationService", () => __awaiter(this, void 0, void 0, function* () { return new Services_1.DocumentationService(); }));
-            Services_1.IoCService.singleton("LogService", () => __awaiter(this, void 0, void 0, function* () {
-                const config = yield Services_1.IoCService.use("Config");
-                return new Services_1.LogService(config.Application.logLevel);
-            }));
+            Services_1.LogService.setInstance(api.config.logLevel);
         });
     }
     loadExpress() {
@@ -67,35 +91,38 @@ class Server {
             app.use(express_1.default.json());
         });
     }
-    analyzeModels() {
+    analyzeVersions() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const api = Services_1.APIService.getInstance();
+            yield new Resolvers_1.VersionResolver().resolve();
+            for (const version of api.versions) {
+                yield new Resolvers_1.VersionConfigResolver(version).resolve();
+                yield new Resolvers_1.ModelResolver(version).resolve();
+                yield new Services_1.SchemaValidatorService(version).validate();
+                yield new Builders_1.ModelTreeBuilder(version).build();
+                yield new Builders_1.RouterBuilder(version).build();
+            }
+        });
+    }
+    loadGeneralConfiguration() {
         return __awaiter(this, void 0, void 0, function* () {
-            yield new Resolvers_1.ModelResolver().resolve();
-            yield new Services_1.SchemaValidatorService().validate();
-            yield new Builders_1.ModelTreeBuilder().build();
-            yield new Builders_1.RouterBuilder().build();
+            const api = Services_1.APIService.getInstance();
+            const generalConfigFile = path_1.default.join(api.appFolder, "config");
+            const { default: content } = yield Promise.resolve(`${generalConfigFile}`).then(s => __importStar(require(s)));
+            api.setConfig(content);
         });
     }
     listen() {
         return __awaiter(this, void 0, void 0, function* () {
-            const config = yield Services_1.IoCService.use("Config");
             const app = yield Services_1.IoCService.use("App");
-            const logger = yield Services_1.IoCService.useByType("LogService");
-            if (config.Application.env === "development") {
-                app.get("/docs", (req, res) => __awaiter(this, void 0, void 0, function* () {
-                    const docs = yield Services_1.IoCService.useByType("DocumentationService");
-                    const modelTree = yield Services_1.IoCService.use("ModelTree");
-                    res.json({
-                        routes: docs.get(),
-                        modelTree,
-                    });
-                }));
-                app.get("/docs/routes", (req, res) => __awaiter(this, void 0, void 0, function* () {
-                    const docs = yield Services_1.IoCService.useByType("DocumentationService");
-                    res.json(docs.get().map((route) => `${route.method} ${route.url}`));
-                }));
+            const logger = Services_1.LogService.getInstance();
+            const api = Services_1.APIService.getInstance();
+            if (api.config.env === "development") {
+                app.get("/docs", DocsHandler_1.default);
+                app.get("/routes", RoutesHandler_1.default);
             }
-            app.listen(config.Application.port, () => {
-                logger.info(`API listens requests on http://localhost:${config.Application.port}`);
+            app.listen(api.config.port, () => {
+                logger.info(`API listens requests on http://localhost:${api.config.port}`);
             });
         });
     }

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

@@ -0,0 +1,16 @@
+import { IApplicationConfig, IVersion } from "../Interfaces";
+declare class APIService {
+    private folders;
+    private static instance;
+    constructor(rootFolder: string);
+    static getInstance(): APIService;
+    static setInsance(rootFolder: string): void;
+    get rootFolder(): string;
+    get appFolder(): string;
+    get versions(): IVersion[];
+    get config(): IApplicationConfig;
+    setConfig(config: IApplicationConfig): void;
+    addVersion(name: string): void;
+    getVersion(name: string): IVersion;
+}
+export default APIService;

package/build/src/Services/APIService.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const Enums_1 = require("../Enums");
+const ModelListService_1 = __importDefault(require("./ModelListService"));
+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: {},
+            },
+        };
+    }
+    static getInstance() {
+        return APIService.instance;
+    }
+    static setInsance(rootFolder) {
+        if (APIService.instance) {
+            throw new Error(`The instance already created: ${APIService.name}`);
+        }
+        APIService.instance = new APIService(rootFolder);
+    }
+    get rootFolder() {
+        return this.folders.rootFolder;
+    }
+    get appFolder() {
+        return this.folders.appFolder;
+    }
+    get versions() {
+        return this.folders.versions;
+    }
+    get config() {
+        return this.folders.config;
+    }
+    setConfig(config) {
+        this.folders.config = config;
+    }
+    addVersion(name) {
+        const root = path_1.default.join(this.folders.appFolder, name);
+        this.folders.versions.push({
+            name,
+            config: {
+                transaction: [],
+                serializers: [],
+                supportedLanguages: ["en"],
+                defaultLanguage: "en",
+                query: {
+                    limits: [],
+                },
+            },
+            folders: {
+                root,
+                config: path_1.default.join(root, "Config"),
+                events: path_1.default.join(root, "Events"),
+                hooks: path_1.default.join(root, "Hooks"),
+                middlewares: path_1.default.join(root, "Middlewares"),
+                models: path_1.default.join(root, "Models"),
+                serialization: path_1.default.join(root, "Serialization"),
+            },
+            modelList: new ModelListService_1.default([]),
+            modelTree: [],
+        });
+    }
+    getVersion(name) {
+        const version = this.folders.versions.find((i) => i.name === name);
+        if (!version) {
+            throw new Error(`Undefined version: ${version}`);
+        }
+        return version;
+    }
+}
+exports.default = APIService;