axe-api 0.20.0 → 0.20.2

package/build/src/Interfaces.d.ts

@@ -0,0 +1,146 @@
+import { Knex } from "knex";
+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";
+export interface IColumn extends Column {
+    table_name: string;
+}
+export interface IConfig {
+}
+export interface IHandlerBasedTransactionConfig {
+    handler: HandlerTypes | HandlerTypes[];
+    transaction: boolean;
+}
+interface IHandlerBasedSerializer {
+    handler: HandlerTypes[];
+    serializer: ((data: any, request: Request) => void)[];
+}
+export interface IApplicationConfig extends IConfig {
+    env: string;
+    port: number;
+    logLevel: LogLevels;
+    prefix: string;
+    transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
+    serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
+}
+export declare type IDatabaseConfig = Knex.Config;
+export interface IFolders {
+    App: string;
+    Config: string;
+    Events: string;
+    Hooks: string;
+    Middlewares: string;
+    Models: string;
+}
+export interface IGeneralHooks {
+    onBeforeInit: (app: Express) => void | null;
+    onAfterInit: (app: Express) => void | null;
+}
+export interface IHandlerBaseMiddleware {
+    handler: HandlerTypes[];
+    middleware: (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
+}
+export interface IHookParameter {
+    req: Request;
+    res: Response;
+    handlerType: HandlerTypes;
+    model: IModelService;
+    parentModel: IModelService | null;
+    relation: IRelation | null;
+    database: Knex | Knex.Transaction;
+    conditions: IQuery | null;
+    query: Knex.QueryBuilder | null;
+    result: any | null;
+    item: any | null;
+    formData: any | null;
+}
+export interface IMethodBaseConfig {
+    [HttpMethods.POST]?: string[];
+    [HttpMethods.PUT]?: string[];
+    [HttpMethods.PATCH]?: string[];
+}
+export interface IMethodBaseValidations {
+    [HttpMethods.POST]?: Record<string, string>;
+    [HttpMethods.PUT]?: Record<string, string>;
+}
+export interface IModelService {
+    name: string;
+    instance: Model;
+    relations: IRelation[];
+    columns: IColumn[];
+    columnNames: string[];
+    hooks: Record<HookFunctionTypes, (params: IHookParameter) => void>;
+    events: Record<HookFunctionTypes, (params: IHookParameter) => void>;
+    isRecursive: boolean;
+    children: IModelService[];
+    setColumns(columns: IColumn[]): void;
+    setExtensions(type: Extensions, hookFunctionType: HookFunctionTypes, data: (params: IHookParameter) => void): void;
+}
+export interface IRelation {
+    type: Relationships;
+    name: string;
+    model: string;
+    primaryKey: string;
+    foreignKey: string;
+}
+export interface IRequestPack {
+    req: Request;
+    res: Response;
+    handlerType: HandlerTypes;
+    model: IModelService;
+    parentModel: IModelService | null;
+    relation: IRelation | null;
+    database: Knex | Knex.Transaction;
+}
+export interface IRouteDocumentation {
+    model: string;
+    table: string;
+    columns: IColumn[];
+    method: HttpMethods;
+    url: string;
+    fillables: string[];
+    validations: Record<string, string> | null;
+}
+export interface IRawQuery {
+    q: string | null;
+    page: string | null;
+    per_page: string | null;
+    sort: string | null;
+    fields: string | null;
+    with: string | null;
+}
+export interface ISortField {
+    name: string;
+    type: SortTypes;
+}
+export interface IWith {
+    relationship: string;
+    relationModel: IModelService;
+    fields: string[];
+    children: IWith[];
+}
+export interface IQuery {
+    q: NestedWhere;
+    page: number;
+    per_page: number;
+    sort: ISortField[];
+    fields: string[];
+    with: IWith[];
+}
+export interface IWhere {
+    prefix: string | null;
+    model: IModelService;
+    table: string;
+    field: string;
+    condition: ConditionTypes;
+    value: any;
+    relation: IRelation | null;
+}
+export declare type NestedWhere = Array<NestedWhere | IWhere>;
+export interface IDependency {
+    type: DependencyTypes;
+    callback: any;
+    instance: any;
+}
+export {};

package/build/src/Interfaces.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const Enums_1 = require("./Enums");

package/build/src/Model.d.ts

@@ -0,0 +1,25 @@
+import { Request, Response, NextFunction } from "express";
+import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBaseMiddleware, IHandlerBasedTransactionConfig } from "./Interfaces";
+import { HandlerTypes, HttpMethods } from "./Enums";
+declare class Model {
+    get primaryKey(): string;
+    get table(): string;
+    get fillable(): string[] | IMethodBaseConfig;
+    get validations(): IMethodBaseValidations | Record<string, string>;
+    get handlers(): HandlerTypes[];
+    get middlewares(): ((req: Request, res: Response, next: NextFunction) => void)[] | IHandlerBaseMiddleware[] | IHandlerBaseMiddleware;
+    get hiddens(): string[];
+    get createdAtColumn(): string | null;
+    get updatedAtColumn(): string | null;
+    get transaction(): boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[] | null;
+    get ignore(): boolean;
+    getFillableFields(methodType: HttpMethods): string[];
+    getValidationRules(methodType: HttpMethods): Record<string, string> | null;
+    getMiddlewares(handlerType: HandlerTypes): ((req: Request, res: Response, next: NextFunction) => void)[];
+    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

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pluralize_1 = __importDefault(require("pluralize"));
+const snake_case_1 = require("snake-case");
+const Enums_1 = require("./Enums");
+const constants_1 = require("./constants");
+class Model {
+    get primaryKey() {
+        return "id";
+    }
+    get table() {
+        return (0, pluralize_1.default)((0, snake_case_1.snakeCase)(this.constructor.name));
+    }
+    get fillable() {
+        return [];
+    }
+    get validations() {
+        return {};
+    }
+    get handlers() {
+        return [...constants_1.DEFAULT_HANDLERS];
+    }
+    get middlewares() {
+        return [];
+    }
+    get hiddens() {
+        return [];
+    }
+    get createdAtColumn() {
+        return "created_at";
+    }
+    get updatedAtColumn() {
+        return "updated_at";
+    }
+    get transaction() {
+        return null;
+    }
+    get ignore() {
+        return false;
+    }
+    getFillableFields(methodType) {
+        if (this.fillable === null) {
+            return [];
+        }
+        if (Array.isArray(this.fillable)) {
+            return this.fillable;
+        }
+        const values = this.fillable;
+        switch (methodType) {
+            case Enums_1.HttpMethods.PATCH:
+                return values.PATCH || [];
+            case Enums_1.HttpMethods.POST:
+                return values.POST || [];
+            case Enums_1.HttpMethods.PUT:
+                return values.PUT || [];
+            default:
+                return [];
+        }
+    }
+    getValidationRules(methodType) {
+        if (this.hasStringValue()) {
+            return this.validations;
+        }
+        const values = this.validations;
+        switch (methodType) {
+            case Enums_1.HttpMethods.POST:
+                return values.POST || null;
+            case Enums_1.HttpMethods.PATCH:
+            case Enums_1.HttpMethods.PUT:
+                return values.PUT || null;
+            default:
+                return null;
+        }
+    }
+    getMiddlewares(handlerType) {
+        const results = [];
+        const middlewares = this.middlewares;
+        if (Array.isArray(middlewares)) {
+            middlewares.forEach((item) => {
+                if (item === null || item === void 0 ? void 0 : item.handler) {
+                    const methodBasedMiddlewares = item;
+                    if (methodBasedMiddlewares.handler.includes(handlerType)) {
+                        results.push(methodBasedMiddlewares.middleware);
+                    }
+                }
+                else {
+                    results.push(item);
+                }
+            });
+        }
+        else {
+            const methodBasedMiddlewares = middlewares;
+            if (methodBasedMiddlewares.handler.includes(handlerType)) {
+                results.push(methodBasedMiddlewares.middleware);
+            }
+        }
+        return results;
+    }
+    hasMany(relatedModel, primaryKey = "id", foreignKey = "") {
+        if (!foreignKey) {
+            const currentModelName = pluralize_1.default.singular(this.constructor.name.toLowerCase());
+            foreignKey = `${currentModelName}_id`;
+        }
+        return {
+            name: relatedModel,
+            type: Enums_1.Relationships.HAS_MANY,
+            model: relatedModel,
+            primaryKey,
+            foreignKey,
+        };
+    }
+    hasOne(relatedModel, primaryKey = "id", foreignKey = "") {
+        if (foreignKey === "") {
+            foreignKey = `${pluralize_1.default.singular(relatedModel.toLowerCase())}_id`;
+        }
+        return {
+            name: relatedModel,
+            type: Enums_1.Relationships.HAS_ONE,
+            model: relatedModel,
+            primaryKey,
+            foreignKey,
+        };
+    }
+    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;
+        for (const key of Object.keys(tester)) {
+            if (typeof tester[key] === "string") {
+                status = true;
+            }
+        }
+        return status;
+    }
+}
+exports.default = Model;

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

@@ -0,0 +1,5 @@
+declare class FileResolver {
+    resolve<T>(directory: string): Promise<Record<string, T>>;
+    resolveContent(directory: string): Promise<Record<string, any>>;
+}
+export default FileResolver;

package/build/src/Resolvers/FileResolver.js

@@ -0,0 +1,85 @@
+"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 fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class FileResolver {
+    resolve(directory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = {};
+            if (!fs_1.default.existsSync(directory)) {
+                return results;
+            }
+            const files = (yield fs_1.default.readdirSync(directory, { withFileTypes: true }))
+                .filter((item) => !item.isDirectory())
+                .filter((filename) => filename.name.includes(".ts") || filename.name.includes(".js"))
+                .map((item) => item.name);
+            for (const file of files) {
+                const configFile = path_1.default.join(directory, file);
+                const { default: content } = yield Promise.resolve().then(() => __importStar(require(configFile)));
+                const key = file.replace(".ts", "").replace(".js", "");
+                if (content === null || content === void 0 ? void 0 : content.prototype) {
+                    results[key] = new content();
+                }
+                else {
+                    results[key] = content;
+                }
+            }
+            return results;
+        });
+    }
+    resolveContent(directory) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const results = {};
+            if (!fs_1.default.existsSync(directory)) {
+                return results;
+            }
+            const files = yield fs_1.default
+                .readdirSync(directory, { withFileTypes: true })
+                .filter((item) => !item.isDirectory())
+                .map((item) => item.name);
+            for (const file of files) {
+                const configFile = path_1.default.join(directory, file);
+                const content = yield Promise.resolve().then(() => __importStar(require(configFile)));
+                const key = file.replace(".ts", "").replace(".js", "");
+                results[key] = content;
+            }
+            return results;
+        });
+    }
+}
+exports.default = FileResolver;

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

@@ -0,0 +1,5 @@
+import { IFolders } from "../Interfaces";
+declare class FolderResolver {
+    resolve(appFolder: string): IFolders;
+}
+export default FolderResolver;

package/build/src/Resolvers/FolderResolver.js

@@ -0,0 +1,19 @@
+"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"));
+class FolderResolver {
+    resolve(appFolder) {
+        return {
+            App: appFolder,
+            Config: path_1.default.join(appFolder, "app", "Config"),
+            Events: path_1.default.join(appFolder, "app", "Events"),
+            Hooks: path_1.default.join(appFolder, "app", "Hooks"),
+            Middlewares: path_1.default.join(appFolder, "app", "Middlewares"),
+            Models: path_1.default.join(appFolder, "app", "Models"),
+        };
+    }
+}
+exports.default = FolderResolver;

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

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

package/build/src/Resolvers/GeneralHookResolver.js

@@ -0,0 +1,35 @@
+"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 path_1 = __importDefault(require("path"));
+const Services_1 = require("../Services");
+const _1 = require(".");
+class GeneralHookResolver {
+    static 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"));
+            if (content && content.init) {
+                const { onBeforeInit = null, onAfterInit = null } = content.init;
+                return { onBeforeInit, onAfterInit };
+            }
+            return {
+                onBeforeInit: null,
+                onAfterInit: null,
+            };
+        });
+    }
+}
+exports.default = GeneralHookResolver;

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

@@ -0,0 +1,9 @@
+declare class ModelResolver {
+    resolve(): Promise<void>;
+    private setModelRelations;
+    private getModelList;
+    private setDatabaseColumns;
+    private setModelHooks;
+    private getInstanceMethods;
+}
+export default ModelResolver;

package/build/src/Resolvers/ModelResolver.js

@@ -0,0 +1,107 @@
+"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 FileResolver_1 = __importDefault(require("./FileResolver"));
+const Enums_1 = require("../Enums");
+const Services_1 = require("../Services");
+const constants_1 = require("../constants");
+class ModelResolver {
+    resolve() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logger = yield Services_1.IoCService.useByType("LogService");
+            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.");
+        });
+    }
+    setModelRelations(modelList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            for (const model of modelList.get()) {
+                const relationMethods = this.getInstanceMethods(model);
+                for (const relationMethod of relationMethods) {
+                    const relationFunction = model.instance[relationMethod];
+                    if (typeof relationFunction !== "function") {
+                        throw new Error(`Model relation definition should be a function: ${model.name}.${relationMethod}`);
+                    }
+                    const definition = relationFunction.call(model.instance);
+                    definition.name = relationMethod;
+                    model.relations.push(definition);
+                }
+            }
+        });
+    }
+    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);
+            for (const key in models) {
+                list.push(new Services_1.ModelService(key, models[key]));
+            }
+            return list;
+        });
+    }
+    setDatabaseColumns(modelList) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const database = (yield Services_1.IoCService.use("Database"));
+            const schemaInspector = (yield Services_1.IoCService.use("SchemaInspector"));
+            const inspector = schemaInspector(database);
+            const columns = [];
+            for (const table of yield inspector.tables()) {
+                const dbColumns = yield inspector.columnInfo(table);
+                columns.push(...dbColumns.map((column) => {
+                    return Object.assign(Object.assign({}, column), { table_name: table });
+                }));
+            }
+            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?`);
+                }
+                model.setColumns(modelColumns);
+            }
+        });
+    }
+    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 hooks = yield fileResolver.resolveContent(folder);
+            for (const model of modelList.get()) {
+                const hookFileName = `${model.name}${hookType
+                    .toString()
+                    .replace("s", "")}`;
+                if (hooks[hookFileName]) {
+                    const keys = Object.keys(hooks[hookFileName]);
+                    keys.forEach((key) => {
+                        const strEnum = key;
+                        const hookFunctionType = Enums_1.HookFunctionTypes[strEnum];
+                        model.setExtensions(hookType, hookFunctionType, hooks[hookFileName][key]);
+                    });
+                }
+            }
+        });
+    }
+    getInstanceMethods(obj) {
+        const properties = Object.getOwnPropertyNames(obj.instance.constructor.prototype);
+        return properties.filter((name) => !constants_1.DEFAULT_METHODS_OF_MODELS.includes(name));
+    }
+}
+exports.default = ModelResolver;

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

@@ -0,0 +1,8 @@
+import { IModelService } from "../Interfaces";
+import { HandlerTypes } from "../Enums";
+declare class TransactionResolver {
+    static resolve(model: IModelService, handlerType: HandlerTypes): Promise<boolean>;
+    private static resolveTransactionOption;
+    private static getTransactionConfiguration;
+}
+export default TransactionResolver;