axe-api 0.20.0 → 0.20.2

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/WithQueryResolver.d.ts

@@ -0,0 +1,13 @@
+import { IModelService, IWith } from "../Interfaces";
+declare class WithQueryResolver {
+    model: IModelService;
+    models: IModelService[];
+    constructor(model: IModelService, models: IModelService[]);
+    resolve(expression: string): IWith[];
+    private resolveRelationsByKey;
+    private toNestedArray;
+    private getKey;
+    private getGroupValue;
+    private splitByGroups;
+}
+export default WithQueryResolver;

package/build/src/Resolvers/WithQueryResolver.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+class WithQueryResolver {
+    constructor(model, models) {
+        this.getKey = (group) => {
+            const firstIndex = group.indexOf("{");
+            if (firstIndex > -1) {
+                return group.substring(0, firstIndex);
+            }
+            return null;
+        };
+        this.getGroupValue = (group) => {
+            const firstIndex = group.indexOf("{");
+            if (firstIndex > -1) {
+                return group.substring(firstIndex + 1, group.length - 1);
+            }
+            return group;
+        };
+        this.model = model;
+        this.models = models;
+    }
+    resolve(expression) {
+        const result = [];
+        const root = {
+            key: "root",
+            children: [],
+        };
+        const currentModel = this.model;
+        this.toNestedArray(root, expression);
+        this.resolveRelationsByKey(result, null, root.children, currentModel);
+        return result;
+    }
+    resolveRelationsByKey(result, fields, expressions, model) {
+        for (const expression of expressions) {
+            if (expression.key.trim().length === 0) {
+                continue;
+            }
+            const relationFunction = model.instance[expression.key];
+            if (typeof relationFunction === "function") {
+                const definition = relationFunction.call(model.instance);
+                const relationModel = this.models.find((item) => item.name === definition.model);
+                if (relationModel === undefined) {
+                    throw new ApiError_1.default(`Undefined relation model: ${definition.model} (${expression.key})`);
+                }
+                const data = {
+                    relationship: expression.key,
+                    relationModel,
+                    fields: [],
+                    children: [],
+                };
+                if (expression.children.length > 0) {
+                    this.resolveRelationsByKey(data.children, data.fields, expression.children, relationModel);
+                }
+                result.push(data);
+            }
+            else if (fields !== null) {
+                if (model.columnNames.includes(expression.key)) {
+                    fields.push(expression.key);
+                }
+                else {
+                    throw new ApiError_1.default(`It is not a field or a relation: ${expression.key}`);
+                }
+            }
+            else {
+                throw new ApiError_1.default(`Unknown expression: ${expression.key}`);
+            }
+        }
+    }
+    toNestedArray(root, expression) {
+        const groups = this.splitByGroups(expression);
+        for (const group of groups) {
+            const key = this.getKey(group);
+            if (key) {
+                const child = {
+                    key,
+                    children: [],
+                };
+                this.toNestedArray(child, this.getGroupValue(group));
+                root.children.push(child);
+            }
+            else {
+                root.children.push(...group.split("|").map((field) => {
+                    return {
+                        key: field,
+                        children: [],
+                    };
+                }));
+            }
+        }
+    }
+    splitByGroups(expression) {
+        const result = [];
+        let bracket = 0;
+        let startedAt = 0;
+        for (let index = 0; index < expression.length; index++) {
+            const char = expression[index];
+            if (char === "{") {
+                bracket++;
+            }
+            else if (char === "}") {
+                bracket--;
+            }
+            if (bracket === 0 && char === ",") {
+                result.push(expression.substring(startedAt, index));
+                startedAt = index + 1;
+            }
+        }
+        result.push(expression.substring(startedAt, expression.length));
+        return result;
+    }
+}
+exports.default = WithQueryResolver;

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

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

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.WithQueryResolver = exports.TransactionResolver = exports.ModelResolver = 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 ModelResolver_1 = __importDefault(require("./ModelResolver"));
+exports.ModelResolver = ModelResolver_1.default;
+const TransactionResolver_1 = __importDefault(require("./TransactionResolver"));
+exports.TransactionResolver = TransactionResolver_1.default;
+const WithQueryResolver_1 = __importDefault(require("./WithQueryResolver"));
+exports.WithQueryResolver = WithQueryResolver_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,103 @@
+"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_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");
+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("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);
+                (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 @@
+declare class IoCService {
+    private static items;
+    static bind(name: string, callback: any): void;
+    static singleton(name: string, callback: any): void;
+    static use(name: string): Promise<any>;
+    static useByType<T>(name: string): Promise<T>;
+    private static _add;
+}
+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");
+class IoCService {
+    static bind(name, callback) {
+        this._add(Enums_1.DependencyTypes.BIND, name, callback);
+    }
+    static singleton(name, callback) {
+        this._add(Enums_1.DependencyTypes.SINGLETON, name, callback);
+    }
+    static use(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const item = IoCService.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;
+        });
+    }
+    static useByType(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield IoCService.use(name);
+            return result;
+        });
+    }
+    static _add(type, name, callback) {
+        IoCService.items[name] = {
+            type,
+            callback,
+            instance: null,
+        };
+    }
+}
+IoCService.items = {};
+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,34 @@
+import { IQuery, ISortField, NestedWhere, IWhere, 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;
+    private getUsedColumns;
+    private applyConditionRule;
+    private applyRelatedQueryJoins;
+    private applyJoinIfNecessary;
+    private addJoinOnce;
+    private parseSections;
+    private parsePage;
+    private parsePerPage;
+    private parseFields;
+    private parseSortingOptions;
+    private parseConditions;
+    private parseCondition;
+    private parseConditionObject;
+    private applySpecialCondition;
+    private addRelationColumns;
+    private getConditionMethodName;
+    private hasSpecialStructure;
+    private shouldBeAcceptableColumn;
+}
+export default QueryService;