axe-api 0.19.1 → 0.20.0-rc10

package/build/src/Resolvers/TransactionResolver.js

@@ -0,0 +1,75 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Services_1 = require("../Services");
+class TransactionResolver {
+    static 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 local = model.instance.transaction;
+            let privilegedOption = false;
+            if (global) {
+                privilegedOption = TransactionResolver.resolveTransactionOption(global, handlerType, privilegedOption);
+            }
+            if (local !== null) {
+                privilegedOption = TransactionResolver.resolveTransactionOption(local, handlerType, privilegedOption);
+            }
+            return privilegedOption;
+        });
+    }
+    static getTransactionConfiguration(configItem, handlerType) {
+        // An item definitions might have handler array such as;
+        //
+        // handler: [HandlerTypes.ALL, HandlerTypes.INSERT]
+        if (Array.isArray(configItem.handler)) {
+            // If this is an array, we should find the matched handler type
+            const found = configItem.handler.find((item) => item === handlerType);
+            // If there is, this is the our transaction choice
+            if (found) {
+                return configItem.transaction;
+            }
+        }
+        else if (configItem.handler === handlerType) {
+            // If the "configItem.handler" is not an array, should be matched
+            // with the handlerType. If it matches, it means that this is our
+            // transaction configuration
+            return configItem.transaction;
+        }
+        return null;
+    }
+}
+TransactionResolver.resolveTransactionOption = (option, handlerType, defaultValue) => {
+    if (Array.isArray(option)) {
+        // If this is an array, we should treat it like an array.
+        const configs = option;
+        // We should check every item of the array
+        for (const configItem of configs) {
+            const value = TransactionResolver.getTransactionConfiguration(configItem, handlerType);
+            if (value) {
+                defaultValue = configItem.transaction;
+            }
+        }
+    }
+    else if (typeof option === "boolean") {
+        // Developer should be able to select a boolean value for all kind of routes
+        defaultValue = option;
+    }
+    else {
+        const configItem = option;
+        const value = TransactionResolver.getTransactionConfiguration(configItem, handlerType);
+        if (value) {
+            defaultValue = configItem.transaction;
+        }
+    }
+    return defaultValue;
+};
+exports.default = TransactionResolver;

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

@@ -0,0 +1,7 @@
+import FileResolver from "./FileResolver";
+import FolderResolver from "./FolderResolver";
+import GeneralHookResolver from "./GeneralHookResolver";
+import ModelMiddlewareResolver from "./ModelMiddlewareResolver";
+import ModelResolver from "./ModelResolver";
+import TransactionResolver from "./TransactionResolver";
+export { FileResolver, FolderResolver, GeneralHookResolver, ModelMiddlewareResolver, ModelResolver, TransactionResolver, };

package/build/src/Resolvers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionResolver = exports.ModelResolver = exports.ModelMiddlewareResolver = exports.GeneralHookResolver = exports.FolderResolver = exports.FileResolver = void 0;
+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 ModelMiddlewareResolver_1 = __importDefault(require("./ModelMiddlewareResolver"));
+exports.ModelMiddlewareResolver = ModelMiddlewareResolver_1.default;
+const ModelResolver_1 = __importDefault(require("./ModelResolver"));
+exports.ModelResolver = ModelResolver_1.default;
+const TransactionResolver_1 = __importDefault(require("./TransactionResolver"));
+exports.TransactionResolver = TransactionResolver_1.default;

package/build/src/Server.d.ts

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

package/build/src/Server.js

@@ -0,0 +1,101 @@
+"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 Resolvers_1 = require("./Resolvers");
+const dotenv_1 = __importDefault(require("dotenv"));
+const express_1 = __importDefault(require("express"));
+const knex_1 = __importDefault(require("knex"));
+const knex_paginate_1 = require("knex-paginate");
+const Builders_1 = require("./Builders");
+const HandlerFactory_1 = __importDefault(require("./Handlers/HandlerFactory"));
+const Services_1 = require("./Services");
+class Server {
+    start(appFolder) {
+        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();
+        });
+    }
+    bindDependencies(folders, config, models) {
+        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.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);
+                (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);
+            }));
+        });
+    }
+    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());
+        });
+    }
+    analyzeModels() {
+        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();
+        });
+    }
+    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}`));
+                }));
+            }
+            app.listen(config.Application.port, () => {
+                logger.info(`API listens requests on http://localhost:${config.Application.port}`);
+            });
+        });
+    }
+}
+exports.default = Server;

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

@@ -0,0 +1,9 @@
+import { IModelService, IRouteDocumentation } from "../Interfaces";
+import { HttpMethods } from "../Enums";
+declare class DocumentationService {
+    routes: IRouteDocumentation[];
+    constructor();
+    push(method: HttpMethods, url: string, model: IModelService): void;
+    get(): IRouteDocumentation[];
+}
+export default DocumentationService;

package/build/src/Services/DocumentationService.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class DocumentationService {
+    constructor() {
+        this.routes = [];
+    }
+    push(method, url, model) {
+        this.routes.push({
+            model: model.name,
+            table: model.instance.table,
+            columns: model.columns,
+            method,
+            url,
+            fillables: model.instance.getFillableFields(method),
+            validations: model.instance.getValidationRules(method),
+        });
+    }
+    get() {
+        return this.routes;
+    }
+}
+exports.default = DocumentationService;

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

@@ -0,0 +1,9 @@
+import { DependencyTypes } from "../Enums";
+declare const IoCService: {
+    bind(name: string, callback: any): void;
+    singleton(name: string, callback: any): void;
+    use(name: string): Promise<any>;
+    useByType<T>(name: string): Promise<T>;
+    _add(type: DependencyTypes, name: string, callback: any): void;
+};
+export default IoCService;

package/build/src/Services/IoCService.js

@@ -0,0 +1,51 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Enums_1 = require("../Enums");
+const items = {};
+const IoCService = {
+    bind(name, callback) {
+        this._add(Enums_1.DependencyTypes.BIND, name, callback);
+    },
+    singleton(name, callback) {
+        this._add(Enums_1.DependencyTypes.SINGLETON, name, callback);
+    },
+    use(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const item = items[name];
+            if (!item) {
+                throw new Error(`Dependency is not found ${name}`);
+            }
+            if (item.type === Enums_1.DependencyTypes.BIND) {
+                return yield item.callback();
+            }
+            if (item.instance) {
+                return item.instance;
+            }
+            item.instance = yield item.callback();
+            return item.instance;
+        });
+    },
+    useByType(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield IoCService.use(name);
+            return result;
+        });
+    },
+    _add(type, name, callback) {
+        items[name] = {
+            type,
+            callback,
+            instance: null,
+        };
+    },
+};
+exports.default = IoCService;

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

@@ -0,0 +1,12 @@
+import { LogLevels } from "../Enums";
+declare class LogService {
+    level: LogLevels;
+    constructor(level: LogLevels);
+    error(message: string): void;
+    warn(message: string): void;
+    info(message: string): void;
+    success(message: string): void;
+    log(message: string): void;
+    debug(message: string): void;
+}
+export default LogService;

package/build/src/Services/LogService.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Enums_1 = require("../Enums");
+const constants_1 = require("../constants");
+const { fgRed, fgGreen, fgYellow, fgCyan, fgReset } = constants_1.LOG_COLORS;
+class LogService {
+    constructor(level) {
+        this.level = level;
+    }
+    error(message) {
+        if (this.level <= Enums_1.LogLevels.ERROR) {
+            console.error(fgRed, "[axe]", message, fgReset);
+        }
+    }
+    warn(message) {
+        if (this.level <= Enums_1.LogLevels.WARNING) {
+            console.warn(fgYellow, "[axe]", message, fgReset);
+        }
+    }
+    info(message) {
+        if (this.level <= Enums_1.LogLevels.INFO) {
+            console.info(fgCyan, "[axe]", message, fgReset);
+        }
+    }
+    success(message) {
+        if (this.level <= Enums_1.LogLevels.INFO) {
+            console.info(fgGreen, "[axe]", message, fgReset);
+        }
+    }
+    log(message) {
+        if (this.level === Enums_1.LogLevels.ALL) {
+            console.log(message);
+        }
+    }
+    debug(message) {
+        if (this.level === Enums_1.LogLevels.ALL) {
+            console.log(message);
+        }
+    }
+}
+exports.default = LogService;

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

@@ -0,0 +1,8 @@
+import { IModelService } from "../Interfaces";
+declare class ModelListService {
+    private models;
+    constructor(models: IModelService[]);
+    find(name: string): IModelService | null;
+    get(): IModelService[];
+}
+export default ModelListService;

package/build/src/Services/ModelListService.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ModelListService {
+    constructor(models) {
+        this.models = models;
+    }
+    find(name) {
+        const found = this.models.find((i) => i.name === name);
+        if (found) {
+            return found;
+        }
+        return null;
+    }
+    get() {
+        return this.models;
+    }
+}
+exports.default = ModelListService;

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

@@ -0,0 +1,20 @@
+import { HookFunctionTypes, Extensions } from "../Enums";
+import { IColumn, IHookParameter, IModelService, IRelation } from "../Interfaces";
+import Model from "./../Model";
+declare class ModelService implements IModelService {
+    name: string;
+    instance: Model;
+    relations: IRelation[];
+    columns: IColumn[];
+    columnNames: string[];
+    hooks: Record<HookFunctionTypes, (params: IHookParameter) => void>;
+    events: Record<HookFunctionTypes, (params: IHookParameter) => void>;
+    children: IModelService[];
+    isRecursive: boolean;
+    constructor(name: string, instance: Model);
+    setColumns(columns: IColumn[]): void;
+    setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: (params: IHookParameter) => void): void;
+    private setHooks;
+    private setEvents;
+}
+export default ModelService;

package/build/src/Services/ModelService.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Enums_1 = require("../Enums");
+class ModelService {
+    constructor(name, instance) {
+        this.hooks = {};
+        this.events = {};
+        this.name = name;
+        this.instance = instance;
+        this.relations = [];
+        this.columns = [];
+        this.columnNames = [];
+        this.children = [];
+        this.isRecursive = false;
+    }
+    setColumns(columns) {
+        this.columns = columns;
+        this.columnNames = this.columns.map((i) => i.name);
+    }
+    setExtensions(type, hookFunctionType, data) {
+        if (type == Enums_1.Extensions.Hooks) {
+            this.setHooks(hookFunctionType, data);
+        }
+        else if (type == Enums_1.Extensions.Events) {
+            this.setEvents(hookFunctionType, data);
+        }
+        else {
+            throw new Error("Undefined hook type.");
+        }
+    }
+    setHooks(hookFunctionType, data) {
+        this.hooks[hookFunctionType] = data;
+    }
+    setEvents(hookFunctionType, data) {
+        this.events[hookFunctionType] = data;
+    }
+}
+exports.default = ModelService;

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

@@ -0,0 +1,39 @@
+import { ConditionTypes } from "../Enums";
+import { IRawQuery, IQuery, ISortField, NestedWhere, IWhere, IWith, IModelService } from "../Interfaces";
+import { Knex } from "knex";
+declare class QueryService {
+    model: IModelService;
+    models: IModelService[];
+    usedConditionColumns: string[];
+    relationColumns: string[];
+    createdJoins: string[];
+    constructor(model: IModelService, models: IModelService[]);
+    applyFields(query: Knex.QueryBuilder, fields: string[]): void;
+    applySorting(query: Knex.QueryBuilder, sort: ISortField[]): void;
+    applyWheresInsideGroup(sub: Knex.QueryBuilder, ruleSet: NestedWhere | IWhere): void;
+    applyWheres(query: Knex.QueryBuilder, ruleSet: NestedWhere): void;
+    get(query: any): IQuery;
+    _getUsedColumns(conditions: IQuery): string[];
+    _applyConditionRule(sub: Knex.QueryBuilder, ruleSet: IWhere): Knex.QueryBuilder;
+    _applyRelatedQueryJoins(query: Knex.QueryBuilder, ruleSet: NestedWhere): void;
+    _applyJoinIfNecessary(query: Knex.QueryBuilder, ruleSet: IWhere): void;
+    _addJoinOnce(query: Knex.QueryBuilder, ruleSet: IWhere): void;
+    _getSections(query: any): IRawQuery;
+    _parseSections(sections: IRawQuery): IQuery;
+    _parsePage(content: any): number;
+    _parsePerPage(content: any): number;
+    _parseFields(content: any): string[];
+    _parseSortingOptions(content: any): ISortField[];
+    _parseConditions(conditions: any): NestedWhere;
+    _parseCondition(content: any): NestedWhere;
+    _parseConditionObject(content: any, key: string): IWhere;
+    _parseWithSections(content: any): string[];
+    _parseWith(items: string[]): IWith[];
+    _splitWithRecursive(content: string): string[];
+    _applySpecialCondition(where: IWhere, structure: string, condition: ConditionTypes): void;
+    _addRelationColumns(withs: IWith[]): void;
+    _getConditionMethodName(ruleSet: IWhere): "orWhere" | "where";
+    _hasSpecialStructure(field: string, structure: string): boolean;
+    _shouldBeAcceptableColumn(field: string): void;
+}
+export default QueryService;