axe-api 0.22.0 → 0.30.0-rc1

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().then(() => __importStar(require(generalConfigFile)));
+            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,79 @@
+"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",
+            },
+            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;

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

@@ -1,8 +1,10 @@
 import { IModelService, IRouteDocumentation } from "../Interfaces";
 import { HttpMethods } from "../Enums";
 declare class DocumentationService {
-    routes: IRouteDocumentation[];
+    private static instance;
+    private routes;
     constructor();
+    static getInstance(): DocumentationService;
     push(method: HttpMethods, url: string, model: IModelService): void;
     get(): IRouteDocumentation[];
 }

package/build/src/Services/DocumentationService.js

@@ -4,6 +4,12 @@ class DocumentationService {
     constructor() {
         this.routes = [];
     }
+    static getInstance() {
+        if (!DocumentationService.instance) {
+            DocumentationService.instance = new DocumentationService();
+        }
+        return DocumentationService.instance;
+    }
     push(method, url, model) {
         this.routes.push({
             model: model.name,

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

@@ -1,7 +1,10 @@
 import { LogLevels } from "../Enums";
 declare class LogService {
-    level: LogLevels;
+    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;

package/build/src/Services/LogService.js

@@ -7,6 +7,12 @@ class LogService {
     constructor(level) {
         this.level = level;
     }
+    static setInstance(level) {
+        LogService.instance = new LogService(level);
+    }
+    static getInstance() {
+        return LogService.instance;
+    }
     error(message) {
         if (this.level >= Enums_1.LogLevels.ERROR) {
             console.error(fgRed, "[axe]", message, fgReset);

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

@@ -1,6 +1,7 @@
 import { HookFunctionTypes, Extensions } from "../Enums";
 import { IColumn, IHookParameter, IModelService, IRelation } from "../Interfaces";
 import Model from "./../Model";
+import { SerializationFunction } from "../Types";
 declare class ModelService implements IModelService {
     name: string;
     instance: Model;
@@ -11,9 +12,11 @@ declare class ModelService implements IModelService {
     events: Record<HookFunctionTypes, (params: IHookParameter) => void>;
     children: IModelService[];
     isRecursive: boolean;
+    serialize: SerializationFunction | null;
     constructor(name: string, instance: Model);
     setColumns(columns: IColumn[]): void;
     setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: (params: IHookParameter) => void): void;
+    setSerialization(callback: SerializationFunction): void;
     private setHooks;
     private setEvents;
 }

package/build/src/Services/ModelService.js

@@ -12,6 +12,7 @@ class ModelService {
         this.columnNames = [];
         this.children = [];
         this.isRecursive = false;
+        this.serialize = null;
     }
     setColumns(columns) {
         this.columns = columns;
@@ -28,6 +29,9 @@ class ModelService {
             throw new Error("Undefined hook type.");
         }
     }
+    setSerialization(callback) {
+        this.serialize = callback;
+    }
     setHooks(hookFunctionType, data) {
         this.hooks[hookFunctionType] = data;
     }

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

@@ -1,4 +1,7 @@
+import { IVersion } from "../Interfaces";
 declare class SchemaValidatorService {
+    private version;
+    constructor(version: IVersion);
     validate(): Promise<void>;
     private checkModelColumnsOrFail;
     private getModelFillableColumns;

package/build/src/Services/SchemaValidatorService.js

@@ -8,11 +8,15 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 AxeError_1 = __importDefault(require("../Exceptions/AxeError"));
 const Enums_1 = require("../Enums");
 const Services_1 = require("../Services");
 class SchemaValidatorService {
-    constructor() {
+    constructor(version) {
         this.getModelFillableColumns = (model) => {
             const fillable = model.instance.fillable;
             if (!fillable) {
@@ -66,30 +70,30 @@ class SchemaValidatorService {
             this.checkModelColumnsOrFail(model, [relation.primaryKey]);
             const relatedModel = modelList.find(relation.model);
             if (!relatedModel) {
-                throw new Error(`Undefined related model: ${relation.model}`);
+                throw new AxeError_1.default(Enums_1.AxeErrorCode.UNDEFINED_RELATION_MODEL, `Undefined related model: ${relation.model} (${model.name}.${relation.name})`);
             }
             this.checkModelColumnsOrFail(relatedModel, [relation.foreignKey]);
         };
+        this.version = version;
     }
     validate() {
         return __awaiter(this, void 0, void 0, function* () {
-            const logger = yield Services_1.IoCService.useByType("LogService");
-            const modelList = yield Services_1.IoCService.useByType("ModelListService");
-            modelList.get().forEach((model) => {
+            const logger = Services_1.LogService.getInstance();
+            this.version.modelList.get().forEach((model) => {
                 this.checkModelColumnsOrFail(model, this.getModelFillableColumns(model));
                 this.checkModelColumnsOrFail(model, this.getModelFormValidationColumns(model));
                 this.checkModelColumnsOrFail(model, this.getModelHiddenColumns(model));
                 this.checkModelColumnsOrFail(model, this.getTimestampsColumns(model));
                 this.checkModelColumnsOrFail(model, [model.instance.primaryKey]);
-                this.checkRelationColumnsOrFail(modelList, model);
+                this.checkRelationColumnsOrFail(this.version.modelList, model);
             });
-            logger.info("Database schema has been validated.");
+            logger.info(`[${this.version.name}] Database schema has been validated.`);
         });
     }
     checkModelColumnsOrFail(model, modelColumns) {
         const undefinedColumns = modelColumns.filter((modelColumn) => !model.columnNames.includes(modelColumn));
         if (undefinedColumns.length > 0) {
-            throw new Error(`${model.name} model doesn't have the following columns on the database; "${model.instance.table}.${undefinedColumns.join(",")}"`);
+            throw new AxeError_1.default(Enums_1.AxeErrorCode.UNDEFINED_COLUMN, `${model.name} model doesn't have the following columns on the database; "${model.instance.table}.${undefinedColumns.join(",")}"`);
         }
     }
     checkRelationColumnsOrFail(modelList, model) {

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

@@ -1,3 +1,4 @@
+import APIService from "./APIService";
 import DocumentationService from "./DocumentationService";
 import IoCService from "./IoCService";
 import LogService from "./LogService";
@@ -5,4 +6,4 @@ import ModelListService from "./ModelListService";
 import ModelService from "./ModelService";
 import QueryService from "./QueryService";
 import SchemaValidatorService from "./SchemaValidatorService";
-export { DocumentationService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, };
+export { DocumentationService, APIService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, };

package/build/src/Services/index.js

@@ -3,7 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.DocumentationService = void 0;
+exports.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.APIService = exports.DocumentationService = void 0;
+const APIService_1 = __importDefault(require("./APIService"));
+exports.APIService = APIService_1.default;
 const DocumentationService_1 = __importDefault(require("./DocumentationService"));
 exports.DocumentationService = DocumentationService_1.default;
 const IoCService_1 = __importDefault(require("./IoCService"));

package/build/src/Types.d.ts

@@ -0,0 +1,2 @@
+import { Request } from "express";
+export declare type SerializationFunction = (item: any, request: Request) => any;

package/build/src/Types.js

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

package/build/src/constants.js

@@ -26,7 +26,6 @@ exports.DEFAULT_METHODS_OF_MODELS = [
     "hasMany",
     "hasOne",
     "belongsTo",
-    "serialize",
     "__defineGetter__",
     "__defineSetter__",
     "hasOwnProperty",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "0.22.0",
+  "version": "0.30.0-rc1",
   "description": "AXE API is a simple tool which has been created based on Express and Knex.js to create Rest APIs quickly.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -30,6 +30,7 @@
   },
   "dependencies": {
     "@types/express": "^4.17.15",
+    "chalk": "^4.1.2",
     "change-case": "^4.1.2",
     "dotenv": "^14.2.0",
     "express": "^4.18.2",