axe-api 0.22.0 → 0.30.0-rc1

package/build/src/Interfaces.d.ts

@@ -3,6 +3,8 @@ import { Express, Request, Response, NextFunction } from "express";
 import { Column } from "knex-schema-inspector/lib/types/column";
 import { HandlerTypes, LogLevels, HttpMethods, HookFunctionTypes, Extensions, Relationships, SortTypes, ConditionTypes, DependencyTypes } from "./Enums";
 import Model from "./Model";
+import { SerializationFunction } from "./Types";
+import { ModelListService } from "./Services";
 export interface IColumn extends Column {
     table_name: string;
 }
@@ -16,15 +18,18 @@ interface IHandlerBasedSerializer {
     handler: HandlerTypes[];
     serializer: ((data: any, request: Request) => void)[];
 }
+export interface IVersionConfig {
+    transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
+    serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
+    supportedLanguages: string[];
+    defaultLanguage: string;
+}
 export interface IApplicationConfig extends IConfig {
     env: string;
     port: number;
     logLevel: LogLevels;
     prefix: string;
-    transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
-    serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
-    supportedLanguages: string[];
-    defaultLanguage: string;
+    database: IDatabaseConfig;
 }
 export interface ILanguage {
     title: string;
@@ -36,13 +41,27 @@ export interface IAcceptedLanguage {
     quality: number;
 }
 export declare type IDatabaseConfig = Knex.Config;
-export interface IFolders {
-    App: string;
-    Config: string;
-    Events: string;
-    Hooks: string;
-    Middlewares: string;
-    Models: string;
+export interface IVersionFolder {
+    root: string;
+    config: string;
+    events: string;
+    hooks: string;
+    middlewares: string;
+    models: string;
+    serialization: string;
+}
+export interface IVersion {
+    name: string;
+    config: IVersionConfig;
+    folders: IVersionFolder;
+    modelList: ModelListService;
+    modelTree: IModelService[];
+}
+export interface IAPI {
+    rootFolder: string;
+    appFolder: string;
+    versions: IVersion[];
+    config: IApplicationConfig;
 }
 export interface IGeneralHooks {
     onBeforeInit: (app: Express) => void | null;
@@ -85,8 +104,10 @@ export interface IModelService {
     events: Record<HookFunctionTypes, (params: IHookParameter) => void>;
     isRecursive: boolean;
     children: IModelService[];
+    serialize: SerializationFunction | null;
     setColumns(columns: IColumn[]): void;
     setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: (params: IHookParameter) => void): void;
+    setSerialization(callback: SerializationFunction): void;
 }
 export interface IRelation {
     type: Relationships;
@@ -96,6 +117,8 @@ export interface IRelation {
     foreignKey: string;
 }
 export interface IRequestPack {
+    api: IAPI;
+    version: IVersion;
     req: Request;
     res: Response;
     handlerType: HandlerTypes;

package/build/src/Middlewares/acceptLanguageMiddleware.js

@@ -9,15 +9,13 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const Services_1 = require("../Services");
 const Resolvers_1 = require("../Resolvers");
+const Helpers_1 = require("../Helpers");
 exports.default = (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     // Application configuration is need for the default setting.
-    const configs = yield Services_1.IoCService.use("Config");
-    const application = configs.Application;
-    const { supportedLanguages, defaultLanguage } = application;
+    const version = yield (0, Helpers_1.getVersionByRequest)(req);
     // Setting the current language by the supported, default and the client prefences
-    req.currentLanguage = Resolvers_1.AcceptLanguageResolver.resolve(req.get("accept-language") || "", supportedLanguages || ["en"], defaultLanguage || "en");
+    req.currentLanguage = Resolvers_1.AcceptLanguageResolver.resolve(req.get("accept-language") || "", version.config.supportedLanguages || ["en"], version.config.defaultLanguage || "en");
     // Adding the `Content-Language` header to the response object
     res.setHeader("Content-Language", req.currentLanguage.title);
     next();

package/build/src/Model.d.ts

@@ -20,7 +20,6 @@ declare class Model {
     hasMany(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
     hasOne(relatedModel: string, primaryKey?: string, foreignKey?: string): IRelation;
     belongsTo(relatedModel: string, primaryKey: string, foreignKey: string): IRelation;
-    serialize(data: any, request: Request): any;
     private hasStringValue;
 }
 export default Model;

package/build/src/Model.js

@@ -130,10 +130,6 @@ class Model {
     belongsTo(relatedModel, primaryKey, foreignKey) {
         return this.hasOne(relatedModel, foreignKey, primaryKey);
     }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    serialize(data, request) {
-        return data;
-    }
     hasStringValue() {
         const tester = this.validations;
         let status = false;

package/build/src/Resolvers/FolderResolver.js

@@ -13,6 +13,7 @@ class FolderResolver {
             Hooks: path_1.default.join(appFolder, "app", "Hooks"),
             Middlewares: path_1.default.join(appFolder, "app", "Middlewares"),
             Models: path_1.default.join(appFolder, "app", "Models"),
+            Serialization: path_1.default.join(appFolder, "app", "Serialization"),
         };
     }
 }

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

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

package/build/src/Resolvers/GeneralHookResolver.js

@@ -8,19 +8,16 @@ 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 path_1 = __importDefault(require("path"));
-const Services_1 = require("../Services");
 const _1 = require(".");
 class GeneralHookResolver {
-    static resolve() {
+    constructor(version) {
+        this.version = version;
+    }
+    resolve() {
         return __awaiter(this, void 0, void 0, function* () {
-            const folders = (yield Services_1.IoCService.use("Folders"));
             const fileResolver = new _1.FileResolver();
-            const content = yield fileResolver.resolveContent(path_1.default.join(folders.App, "app"));
+            const content = yield fileResolver.resolveContent(this.version.folders.root);
             if (content && content.init) {
                 const { onBeforeInit = null, onAfterInit = null } = content.init;
                 return { onBeforeInit, onAfterInit };

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

@@ -1,9 +1,13 @@
+import { IVersion } from "../Interfaces";
 declare class ModelResolver {
+    private version;
+    constructor(version: IVersion);
     resolve(): Promise<void>;
     private setModelRelations;
     private getModelList;
     private setDatabaseColumns;
     private setModelHooks;
+    private setModelSerializations;
     private getInstanceMethods;
 }
 export default ModelResolver;

package/build/src/Resolvers/ModelResolver.js

@@ -16,17 +16,22 @@ 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);
+            this.version.modelList = modelList;
+            logger.info(`[${this.version.name}] All models have been resolved.`);
         });
     }
     setModelRelations(modelList) {
@@ -48,9 +53,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 +76,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,9 +84,10 @@ class ModelResolver {
     }
     setModelHooks(modelList, hookType) {
         return __awaiter(this, void 0, void 0, function* () {
-            const folders = (yield Services_1.IoCService.use("Folders"));
             const fileResolver = new FileResolver_1.default();
-            const folder = hookType === Enums_1.Extensions.Hooks ? folders.Hooks : folders.Events;
+            const folder = hookType === Enums_1.Extensions.Hooks
+                ? this.version.folders.hooks
+                : this.version.folders.events;
             const hooks = yield fileResolver.resolveContent(folder);
             for (const model of modelList.get()) {
                 const hookFileName = `${model.name}${hookType
@@ -99,6 +104,19 @@ class ModelResolver {
             }
         });
     }
+    setModelSerializations(modelList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fileResolver = new FileResolver_1.default();
+            const serializations = yield fileResolver.resolveContent(this.version.folders.serialization);
+            for (const model of modelList.get()) {
+                const fileName = `${model.name}Serialization`;
+                if (serializations[fileName]) {
+                    const file = serializations[fileName];
+                    model.setSerialization(file.default);
+                }
+            }
+        });
+    }
     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().then(() => __importStar(require(versionConfigFile)));
+            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;