axe-api 0.20.0-rc2 → 0.20.0-rc21

package/build/index.d.ts

@@ -2,6 +2,7 @@ import Server from "./src/Server";
 import Model from "./src/Model";
 import ApiError from "./src/Exceptions/ApiError";
 import { DEFAULT_HANDLERS } from "./src/constants";
+import { IoCService } from "./src/Services";
 export * from "./src/Enums";
 export * from "./src/Interfaces";
-export { Server, Model, ApiError, DEFAULT_HANDLERS };
+export { Server, Model, ApiError, DEFAULT_HANDLERS, IoCService };

package/build/index.js

@@ -17,7 +17,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_HANDLERS = exports.ApiError = exports.Model = exports.Server = void 0;
+exports.IoCService = exports.DEFAULT_HANDLERS = exports.ApiError = exports.Model = exports.Server = void 0;
 const Server_1 = __importDefault(require("./src/Server"));
 exports.Server = Server_1.default;
 const Model_1 = __importDefault(require("./src/Model"));
@@ -26,5 +26,7 @@ const ApiError_1 = __importDefault(require("./src/Exceptions/ApiError"));
 exports.ApiError = ApiError_1.default;
 const constants_1 = require("./src/constants");
 Object.defineProperty(exports, "DEFAULT_HANDLERS", { enumerable: true, get: function () { return constants_1.DEFAULT_HANDLERS; } });
+const Services_1 = require("./src/Services");
+Object.defineProperty(exports, "IoCService", { enumerable: true, get: function () { return Services_1.IoCService; } });
 __exportStar(require("./src/Enums"), exports);
 __exportStar(require("./src/Interfaces"), exports);

package/build/src/Builders/RouterBuilder.d.ts

@@ -1,6 +1,5 @@
 declare class RouterBuilder {
     build(): Promise<void>;
-    private getGeneralHooks;
     private createRoutesByModelTree;
     private createRouteByModel;
     private createNestedRoutes;
@@ -12,6 +11,5 @@ declare class RouterBuilder {
     private sendErrorAsResponse;
     private getResourcePath;
     private getRootPrefix;
-    private getModelMiddlewares;
 }
 export default RouterBuilder;

package/build/src/Builders/RouterBuilder.js

@@ -12,7 +12,6 @@ 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 pluralize_1 = __importDefault(require("pluralize"));
 const http_status_codes_1 = require("http-status-codes");
 const change_case_1 = require("change-case");
@@ -44,35 +43,21 @@ class RouterBuilder {
     }
     build() {
         return __awaiter(this, void 0, void 0, function* () {
+            const app = yield Services_1.IoCService.useByType("App");
             const logger = yield Services_1.IoCService.useByType("LogService");
             const modelTree = yield Services_1.IoCService.useByType("ModelTree");
             const modelList = yield Services_1.IoCService.useByType("ModelListService");
-            const generalHooks = yield this.getGeneralHooks();
+            const generalHooks = yield Resolvers_1.GeneralHookResolver.resolve();
             if (generalHooks.onBeforeInit) {
-                generalHooks.onBeforeInit();
+                generalHooks.onBeforeInit(app);
             }
             yield this.createRoutesByModelTree(modelTree, modelList);
             if (generalHooks.onAfterInit) {
-                generalHooks.onAfterInit();
+                generalHooks.onAfterInit(app);
             }
             logger.info("Express routes have been created.");
         });
     }
-    getGeneralHooks() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const folders = (yield Services_1.IoCService.use("Folders"));
-            const fileResolver = new Resolvers_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,
-            };
-        });
-    }
     createRoutesByModelTree(modelTree, modelList) {
         return __awaiter(this, void 0, void 0, function* () {
             for (const model of modelTree) {
@@ -95,7 +80,7 @@ class RouterBuilder {
                 const urlCreator = constants_1.API_ROUTE_TEMPLATES[handlerType];
                 const url = urlCreator(yield this.getRootPrefix(), urlPrefix, resource, model.instance.primaryKey);
                 // Detecting filters
-                const middlewares = this.getModelMiddlewares(model, handlerType);
+                const middlewares = Resolvers_1.ModelMiddlewareResolver.resolve(model, handlerType);
                 // Adding the route to the express
                 yield this.addExpressRoute(handlerType, url, middlewares, model, parentModel, relation);
             }
@@ -176,9 +161,15 @@ class RouterBuilder {
     }
     requestHandler(handlerType, req, res, model, parentModel, relation) {
         return __awaiter(this, void 0, void 0, function* () {
+            let trx = null;
+            let hasTransaction = false;
             try {
                 const factory = yield Services_1.IoCService.useByType("HandlerFactory");
                 const database = (yield Services_1.IoCService.use("Database"));
+                hasTransaction = yield Resolvers_1.TransactionResolver.resolve(model, handlerType);
+                if (hasTransaction) {
+                    trx = yield database.transaction();
+                }
                 const handler = factory.get(handlerType);
                 const pack = {
                     req,
@@ -187,11 +178,17 @@ class RouterBuilder {
                     model,
                     parentModel,
                     relation,
-                    database,
+                    database: hasTransaction && trx ? trx : database,
                 };
                 yield handler(pack);
+                if (hasTransaction && trx) {
+                    trx.commit();
+                }
             }
             catch (error) {
+                if (hasTransaction && trx) {
+                    trx.rollback();
+                }
                 this.sendErrorAsResponse(res, error);
             }
         });
@@ -213,35 +210,11 @@ class RouterBuilder {
         }
     }
     getResourcePath(model, relation) {
-        // TODO: Fixe
+        // TODO: Fix
         return (0, change_case_1.paramCase)(pluralize_1.default.plural(model.name)).toLowerCase();
         // return relation
         //   ? relation.resource
         //   : paramCase(pluralize.plural(model.name)).toLowerCase();
     }
-    getModelMiddlewares(model, handlerType) {
-        const results = [];
-        const middlewares = model.instance.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;
-    }
 }
 exports.default = RouterBuilder;

package/build/src/Handlers/Helpers.d.ts

@@ -11,4 +11,4 @@ export declare const getParentColumn: (relation: IRelation | null) => string | n
 export declare const addForeignKeyQuery: (request: Request, query: Knex.QueryBuilder, relation: IRelation | null, parentModel: IModelService | null) => void;
 export declare const serializeData: (itemArray: any[] | any, modelSerializer: (data: any, request: Request) => void, handler: HandlerTypes, request: Request) => Promise<any[]>;
 export declare const filterHiddenFields: (itemArray: any[], hiddens: string[] | null) => void;
-export declare const getRelatedData: (data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex, handler: HandlerTypes, request: Request) => Promise<void>;
+export declare const getRelatedData: (data: any[], withArray: IWith[], model: IModelService, modelList: ModelListService, database: Knex | Knex.Transaction, handler: HandlerTypes, request: Request) => Promise<void>;

package/build/src/Handlers/Helpers.js

@@ -43,16 +43,13 @@ const callHooks = (model, type, params) => __awaiter(void 0, void 0, void 0, fun
         yield model.hooks[type](params);
     }
     if (model.events[type]) {
-        // const context = {
-        //   ...data,
-        // };
-        // // Developers shouldn't be able to access transaction in events. Because
-        // // we don't await for the events. If the developer uses the transaction and
-        // // try to commit something, it would be lost cause the transaction could be
-        // // already completed.
-        // if (context.trx) {
-        //   delete context.trx;
-        // }
+        // Developers shouldn't be able to access transaction in events. Because
+        // we don't await for the events. If the developer uses the transaction and
+        // try to commit something, it would be lost cause the transaction could be
+        // already completed.
+        const database = (yield Services_1.IoCService.use("Database"));
+        params.database = database;
+        // Calling the events
         model.events[type](params);
     }
 });
@@ -149,7 +146,7 @@ const getRelatedData = (data, withArray, model, modelList, database, handler, re
     for (const clientQuery of withArray) {
         // Find the relation of the model. If the model doesn't have any relationship like the
         // user wants, we can't show anything.
-        const definedRelation = model.relations.find((relation) => relation.model === clientQuery.relationModel.name);
+        const definedRelation = model.relations.find((relation) => relation.name === clientQuery.relationship);
         if (!definedRelation) {
             throw new ApiError_1.default(`Undefined relation: ${clientQuery.relationship}`);
         }
@@ -194,6 +191,15 @@ const getRelatedData = (data, withArray, model, modelList, database, handler, re
             //     };
             //   }),
             // ];
+            console.log([
+                ...workList.map((relationship) => {
+                    return {
+                        relationship,
+                        fields: [],
+                        children: [],
+                    };
+                }),
+            ]);
             // We should check if the column is defined on the table.
             const undefinedColumns = selectColumns.filter((column) => !foreignModel.columnNames.includes(column));
             if (undefinedColumns.length > 0) {

package/build/src/Interfaces.d.ts

@@ -1,5 +1,5 @@
 import { Knex } from "knex";
-import { Request, Response, NextFunction } from "express";
+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";
@@ -21,7 +21,7 @@ interface IPoolConfig {
 interface IMigrationConfig {
     tableName: "knex_migrations";
 }
-interface IHandlerBasedTransactionConfig {
+export interface IHandlerBasedTransactionConfig {
     handler: HandlerTypes | HandlerTypes[];
     transaction: boolean;
 }
@@ -33,6 +33,7 @@ export interface IApplicationConfig extends IConfig {
     env: string;
     port: number;
     logLevel: LogLevels;
+    prefix: string;
     transaction: boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[];
     serializers: ((data: any, request: Request) => void)[] | IHandlerBasedSerializer[];
 }
@@ -51,12 +52,12 @@ export interface IFolders {
     Models: string;
 }
 export interface IGeneralHooks {
-    onBeforeInit: () => void | null;
-    onAfterInit: () => void | null;
+    onBeforeInit: (app: Express) => void | null;
+    onAfterInit: (app: Express) => void | null;
 }
 export interface IHandlerBaseMiddleware {
     handler: HandlerTypes[];
-    middleware: (req: Request, res: Response, next: NextFunction) => void;
+    middleware: (req: Request, res: Response, next: NextFunction) => void | Promise<void>;
 }
 export interface IHookParameter {
     req: Request;
@@ -65,7 +66,7 @@ export interface IHookParameter {
     model: IModelService;
     parentModel: IModelService | null;
     relation: IRelation | null;
-    database: Knex;
+    database: Knex | Knex.Transaction;
     conditions: IQuery | null;
     query: Knex.QueryBuilder | null;
     result: any | null;
@@ -108,7 +109,7 @@ export interface IRequestPack {
     model: IModelService;
     parentModel: IModelService | null;
     relation: IRelation | null;
-    database: Knex;
+    database: Knex | Knex.Transaction;
 }
 export interface IRouteDocumentation {
     model: string;

package/build/src/Model.d.ts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from "express";
-import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBaseMiddleware } from "./Interfaces";
+import { IRelation, IMethodBaseConfig, IMethodBaseValidations, IHandlerBaseMiddleware, IHandlerBasedTransactionConfig } from "./Interfaces";
 import { HandlerTypes, HttpMethods } from "./Enums";
 declare class Model {
     constructor();
@@ -12,7 +12,7 @@ declare class Model {
     get hiddens(): string[];
     get createdAtColumn(): string | null;
     get updatedAtColumn(): string | null;
-    get transaction(): any;
+    get transaction(): boolean | IHandlerBasedTransactionConfig | IHandlerBasedTransactionConfig[] | null;
     get ignore(): boolean;
     getFillableFields(methodType: HttpMethods): string[];
     getValidationRules(methodType: HttpMethods): Record<string, string> | null;

package/build/src/Resolvers/FileResolver.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -18,10 +41,14 @@ class FileResolver {
     resolve(directory) {
         return __awaiter(this, void 0, void 0, function* () {
             const results = {};
-            const files = yield fs_1.default.readdirSync(directory);
+            const files = (yield fs_1.default.readdirSync(directory, { withFileTypes: true }))
+                .filter((item) => !item.isDirectory())
+                .filter((filename) => filename.name.includes(".ts"))
+                .filter((filename) => filename.name.includes(".ts"))
+                .map((item) => item.name);
             for (const file of files) {
                 const configFile = path_1.default.join(directory, file);
-                const { default: content } = require(configFile);
+                const { default: content } = yield Promise.resolve().then(() => __importStar(require(configFile)));
                 const key = file.replace(".ts", "");
                 if (content === null || content === void 0 ? void 0 : content.prototype) {
                     results[key] = new content();
@@ -42,7 +69,7 @@ class FileResolver {
                 .map((item) => item.name);
             for (const file of files) {
                 const configFile = path_1.default.join(directory, file);
-                const content = require(configFile);
+                const content = yield Promise.resolve().then(() => __importStar(require(configFile)));
                 const key = file.replace(".ts", "");
                 results[key] = content;
             }

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

@@ -0,0 +1,7 @@
+import { Request, Response, NextFunction } from "express";
+import { IModelService } from "../Interfaces";
+import { HandlerTypes } from "../Enums";
+declare class ModelMiddlewareResolver {
+    static resolve(model: IModelService, handlerType: HandlerTypes): ((req: Request, res: Response, next: NextFunction) => void)[];
+}
+export default ModelMiddlewareResolver;

package/build/src/Resolvers/ModelMiddlewareResolver.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ModelMiddlewareResolver {
+    static resolve(model, handlerType) {
+        const results = [];
+        const middlewares = model.instance.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;
+    }
+}
+exports.default = ModelMiddlewareResolver;

package/build/src/Resolvers/ModelResolver.js

@@ -35,7 +35,13 @@ class ModelResolver {
             for (const model of modelList.get()) {
                 const relationMethods = this.getInstanceMethods(model);
                 for (const relationMethod of relationMethods) {
-                    model.relations.push(model.instance[relationMethod]());
+                    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);
                 }
             }
         });

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;

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

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

package/build/src/Resolvers/index.js

@@ -3,10 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelResolver = exports.FolderResolver = exports.FileResolver = void 0;
+exports.WithQueryResolver = 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;
+const WithQueryResolver_1 = __importDefault(require("./WithQueryResolver"));
+exports.WithQueryResolver = WithQueryResolver_1.default;

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

@@ -1,5 +1,4 @@
-import { ConditionTypes } from "../Enums";
-import { IRawQuery, IQuery, ISortField, NestedWhere, IWhere, IWith, IModelService } from "../Interfaces";
+import { IQuery, ISortField, NestedWhere, IWhere, IModelService } from "../Interfaces";
 import { Knex } from "knex";
 declare class QueryService {
     model: IModelService;
@@ -13,27 +12,23 @@ declare class QueryService {
     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;
+    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;

package/build/src/Services/QueryService.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const Enums_1 = require("../Enums");
 const ApiError_1 = __importDefault(require("../Exceptions/ApiError"));
+const Resolvers_1 = require("../Resolvers");
 class QueryService {
     constructor(model, models) {
         this.model = model;
@@ -15,7 +16,7 @@ class QueryService {
     }
     applyFields(query, fields) {
         // Users should be able to select some fields to show.
-        if (fields.length === 1 && fields[0] === "*") {
+        if (fields.length === 0 || (fields.length === 1 && fields[0] === "*")) {
             query.select(`${this.model.instance.table}.*`);
         }
         else {
@@ -46,7 +47,7 @@ class QueryService {
                 // If the item is not an array, it means that it is a standard condition
                 if (Array.isArray(item) === false) {
                     const condition = item;
-                    this._applyConditionRule(sub, condition);
+                    this.applyConditionRule(sub, condition);
                 }
                 else {
                     // If the item is an array, we should create the query recursively.
@@ -66,18 +67,18 @@ class QueryService {
         }
         else {
             const condition = ruleSet;
-            this._applyConditionRule(sub, condition);
+            this.applyConditionRule(sub, condition);
         }
     }
     applyWheres(query, ruleSet) {
         query.where((sub) => {
             this.applyWheresInsideGroup(sub, ruleSet);
         });
-        this._applyRelatedQueryJoins(query, ruleSet);
+        this.applyRelatedQueryJoins(query, ruleSet);
     }
     get(query) {
-        const conditions = this._parseSections(query);
-        const usedColumns = this._getUsedColumns(conditions);
+        const conditions = this.parseSections(query);
+        const usedColumns = this.getUsedColumns(conditions);
         const undefinedColumns = usedColumns.filter((columnName) => {
             let currentModel = this.model;
             let realColumName = columnName;
@@ -93,15 +94,15 @@ class QueryService {
         }
         return conditions;
     }
-    _getUsedColumns(conditions) {
+    getUsedColumns(conditions) {
         return [
             ...conditions.fields,
             ...conditions.sort.map((item) => item.name),
             ...Array.from(this.usedConditionColumns),
         ];
     }
-    _applyConditionRule(sub, ruleSet) {
-        const method = this._getConditionMethodName(ruleSet);
+    applyConditionRule(sub, ruleSet) {
+        const method = this.getConditionMethodName(ruleSet);
         const zeroArguments = ["Null", "NotNull"];
         const oneArguments = ["In", "NotIn", "Between", "NotBetween"];
         const fullFieldPath = `${ruleSet.table}.${ruleSet.field}`;
@@ -115,7 +116,7 @@ class QueryService {
         }
         return sub[method](fullFieldPath, ruleSet.condition, ruleSet.value);
     }
-    _applyRelatedQueryJoins(query, ruleSet) {
+    applyRelatedQueryJoins(query, ruleSet) {
         if (!ruleSet) {
             return;
         }
@@ -124,23 +125,23 @@ class QueryService {
                 // If the item is not an array, it means that it is a standard condition
                 if (Array.isArray(item) === false) {
                     const condition = item;
-                    this._applyJoinIfNecessary(query, condition);
+                    this.applyJoinIfNecessary(query, condition);
                 }
                 else {
-                    this._applyRelatedQueryJoins(query, item);
+                    this.applyRelatedQueryJoins(query, item);
                 }
             }
         }
         else {
-            this._applyJoinIfNecessary(query, ruleSet);
+            this.applyJoinIfNecessary(query, ruleSet);
         }
     }
-    _applyJoinIfNecessary(query, ruleSet) {
+    applyJoinIfNecessary(query, ruleSet) {
         if (ruleSet.table !== this.model.instance.table) {
-            this._addJoinOnce(query, ruleSet);
+            this.addJoinOnce(query, ruleSet);
         }
     }
-    _addJoinOnce(query, ruleSet) {
+    addJoinOnce(query, ruleSet) {
         const { model, relation } = ruleSet;
         if (!relation) {
             return;
@@ -154,21 +155,7 @@ class QueryService {
         query.leftJoin(tableName, primaryKey, foreignKey);
         this.createdJoins.push(relation.name);
     }
-    _getSections(query) {
-        if (typeof query !== "object") {
-            throw new ApiError_1.default("You have to send an object to get sections.");
-        }
-        const sections = {
-            q: query.q || null,
-            page: query.page || 1,
-            per_page: query.per_page || 10,
-            sort: query.sory || null,
-            fields: query.fields || null,
-            with: query.with || null,
-        };
-        return sections;
-    }
-    _parseSections(sections) {
+    parseSections(sections) {
         if (sections.q) {
             const queryContent = sections.q.replace(/%20/g, "").replace(/ /g, "");
             // Users can send an unacceptable query string. We shouldn't allow them to
@@ -180,18 +167,19 @@ class QueryService {
                 throw new ApiError_1.default(`Unacceptable query string: ${queryContent}`);
             }
         }
+        const withQueryResolver = new Resolvers_1.WithQueryResolver(this.model, this.models);
         const query = {
-            page: this._parsePage(sections.page),
-            per_page: this._parsePerPage(sections.per_page),
-            fields: this._parseFields(sections.fields),
-            sort: this._parseSortingOptions(sections.sort),
-            q: this._parseCondition(sections.q),
-            with: this._parseWith(this._parseWithSections(sections.with)),
+            page: this.parsePage(sections.page),
+            per_page: this.parsePerPage(sections.per_page),
+            fields: this.parseFields(sections.fields),
+            sort: this.parseSortingOptions(sections.sort),
+            q: this.parseCondition(sections.q),
+            with: withQueryResolver.resolve((sections === null || sections === void 0 ? void 0 : sections.with) || ""),
         };
-        this._addRelationColumns(query.with);
+        this.addRelationColumns(query.with);
         return query;
     }
-    _parsePage(content) {
+    parsePage(content) {
         const value = parseInt(content);
         if (isNaN(value)) {
             return 1;
@@ -201,14 +189,14 @@ class QueryService {
         }
         return value;
     }
-    _parsePerPage(content) {
+    parsePerPage(content) {
         const value = parseInt(content);
         if (isNaN(value) || value <= 1 || value > 10000) {
             return 10;
         }
         return value;
     }
-    _parseFields(content) {
+    parseFields(content) {
         if (!content) {
             return [];
         }
@@ -219,11 +207,11 @@ class QueryService {
         }
         const fields = strContent.split(",");
         fields.forEach((field) => {
-            this._shouldBeAcceptableColumn(field);
+            this.shouldBeAcceptableColumn(field);
         });
         return fields;
     }
-    _parseSortingOptions(content) {
+    parseSortingOptions(content) {
         // If there is not any sorting options, we don't have to return any value
         if (!content) {
             return [];
@@ -239,7 +227,7 @@ class QueryService {
             if (field.indexOf("+") === 0) {
                 field = field.substr(1);
             }
-            this._shouldBeAcceptableColumn(field);
+            this.shouldBeAcceptableColumn(field);
             result.push({
                 name: field,
                 type,
@@ -247,28 +235,28 @@ class QueryService {
         }
         return result;
     }
-    _parseConditions(conditions) {
+    parseConditions(conditions) {
         if (!Array.isArray(conditions)) {
             throw new Error("An array should be sent to parseConditions() method.");
         }
         return conditions.map((condition) => {
-            return this._parseCondition(condition);
+            return this.parseCondition(condition);
         });
     }
-    _parseCondition(content) {
+    parseCondition(content) {
         if (Array.isArray(content)) {
-            return this._parseConditions(content);
+            return this.parseConditions(content);
         }
         if (!content) {
             return [];
         }
         const wheres = [];
         for (const key in content) {
-            wheres.push(this._parseConditionObject(content, key));
+            wheres.push(this.parseConditionObject(content, key));
         }
         return wheres;
     }
-    _parseConditionObject(content, key) {
+    parseConditionObject(content, key) {
         const where = {
             prefix: null,
             model: this.model,
@@ -290,7 +278,7 @@ class QueryService {
         // If there is not any value, it means that we should check nullable values
         if (where.value === null) {
             // If the client wants to see not nullable values
-            if (this._hasSpecialStructure(where.field, ".$not")) {
+            if (this.hasSpecialStructure(where.field, ".$not")) {
                 where.field = where.field.replace(".$not", "");
                 where.condition = Enums_1.ConditionTypes.NotNull;
             }
@@ -301,17 +289,17 @@ class QueryService {
         }
         else {
             // If there is value, we should check it
-            this._applySpecialCondition(where, "$not", Enums_1.ConditionTypes["<>"]);
-            this._applySpecialCondition(where, "$gt", Enums_1.ConditionTypes[">"]);
-            this._applySpecialCondition(where, "$gte", Enums_1.ConditionTypes[">="]);
-            this._applySpecialCondition(where, "$lt", Enums_1.ConditionTypes["<"]);
-            this._applySpecialCondition(where, "$lte", Enums_1.ConditionTypes["<="]);
-            this._applySpecialCondition(where, "$like", Enums_1.ConditionTypes.LIKE);
-            this._applySpecialCondition(where, "$notLike", Enums_1.ConditionTypes["NOT LIKE"]);
-            this._applySpecialCondition(where, "$in", Enums_1.ConditionTypes.In);
-            this._applySpecialCondition(where, "$notIn", Enums_1.ConditionTypes.NotIn);
-            this._applySpecialCondition(where, "$between", Enums_1.ConditionTypes.Between);
-            this._applySpecialCondition(where, "$notBetween", Enums_1.ConditionTypes.NotBetween);
+            this.applySpecialCondition(where, "$not", Enums_1.ConditionTypes["<>"]);
+            this.applySpecialCondition(where, "$gt", Enums_1.ConditionTypes[">"]);
+            this.applySpecialCondition(where, "$gte", Enums_1.ConditionTypes[">="]);
+            this.applySpecialCondition(where, "$lt", Enums_1.ConditionTypes["<"]);
+            this.applySpecialCondition(where, "$lte", Enums_1.ConditionTypes["<="]);
+            this.applySpecialCondition(where, "$like", Enums_1.ConditionTypes.LIKE);
+            this.applySpecialCondition(where, "$notLike", Enums_1.ConditionTypes["NOT LIKE"]);
+            this.applySpecialCondition(where, "$in", Enums_1.ConditionTypes.In);
+            this.applySpecialCondition(where, "$notIn", Enums_1.ConditionTypes.NotIn);
+            this.applySpecialCondition(where, "$between", Enums_1.ConditionTypes.Between);
+            this.applySpecialCondition(where, "$notBetween", Enums_1.ConditionTypes.NotBetween);
         }
         if (where.condition === "In" || where.condition === "NotIn") {
             where.value = where.value.split(",");
@@ -338,94 +326,33 @@ class QueryService {
             where.relation = relation;
             where.field = field;
         }
-        this._shouldBeAcceptableColumn(where.field);
+        this.shouldBeAcceptableColumn(where.field);
         this.usedConditionColumns.push(`${where.table}.${where.field}`);
         return where;
     }
-    _parseWithSections(content) {
-        if (!content) {
-            return [];
-        }
-        const stringContent = content;
-        return stringContent.split(",");
-    }
-    _parseWith(items) {
-        const result = [];
-        for (const item of items) {
-            let relationship = item;
-            let fields = [];
-            let children = [];
-            const columnIndex = relationship.indexOf("{");
-            if (columnIndex > -1) {
-                fields = this._splitWithRecursive(relationship.substr(columnIndex + 1, relationship.length - columnIndex - 2));
-                relationship = relationship.substr(0, columnIndex);
-            }
-            // We are checking there is any children
-            children = fields.filter((field) => field.indexOf("{") > -1 || field.indexOf(".") > -1);
-            // Field list shouldn't have any related table
-            fields = fields.filter((field) => field.indexOf("{") === -1 && field.indexOf(".") === -1);
-            // We should validate fields are correct.
-            fields.forEach((field) => {
-                this._shouldBeAcceptableColumn(field);
-            });
-            // We should calculate recursivly all of childre
-            children = this._parseWith(children);
-            const relationModel = this.models.find((item) => item.name.toLowerCase() === relationship.toLowerCase());
-            if (!relationModel) {
-                throw new ApiError_1.default(`Undefined relationship: ${relationship}`);
-            }
-            result.push({
-                relationship,
-                relationModel,
-                fields,
-                children,
-            });
-        }
-        return result;
-    }
-    _splitWithRecursive(content) {
-        const result = [];
-        let startAt = 0;
-        let subcounter = 0;
-        for (let position = 0; position < content.length; position++) {
-            const current = content[position];
-            if (current === "{") {
-                subcounter++;
-            }
-            if (current === "}") {
-                subcounter--;
-            }
-            if (current === "|" && subcounter === 0) {
-                result.push(content.substr(startAt, position - startAt));
-                startAt = position + 1;
-            }
-        }
-        result.push(content.substr(startAt));
-        return result;
-    }
-    _applySpecialCondition(where, structure, condition) {
+    applySpecialCondition(where, structure, condition) {
         structure = `.${structure}`;
-        if (this._hasSpecialStructure(where.field, structure)) {
+        if (this.hasSpecialStructure(where.field, structure)) {
             where.field = where.field.replace(structure, "");
             where.condition = condition;
         }
     }
-    _addRelationColumns(withs) {
+    addRelationColumns(withs) {
         withs.forEach((item) => {
-            const relation = this.model.relations.find((i) => i.model.toLowerCase() === item.relationship.toLowerCase());
+            const relation = this.model.relations.find((i) => i.name === item.relationship);
             if (!relation) {
                 throw new ApiError_1.default(`Undefined relation: ${item.relationship}`);
             }
             this.relationColumns.push(`${this.model.instance.table}.${relation.foreignKey}`);
         });
     }
-    _getConditionMethodName(ruleSet) {
+    getConditionMethodName(ruleSet) {
         if (ruleSet.prefix === "or") {
             return "orWhere";
         }
         return "where";
     }
-    _hasSpecialStructure(field, structure) {
+    hasSpecialStructure(field, structure) {
         if (field.indexOf(structure) === -1) {
             return false;
         }
@@ -434,7 +361,7 @@ class QueryService {
         }
         return false;
     }
-    _shouldBeAcceptableColumn(field) {
+    shouldBeAcceptableColumn(field) {
         const regex = /^[0-9,a-z,A-Z_.]+$/;
         if (!field.match(regex)) {
             throw new ApiError_1.default(`Unacceptable field name: ${field}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "0.20.0-rc2",
+  "version": "0.20.0-rc21",
   "description": "AXE API is a simple tool which has been created based on Express and Knex.js to create Rest APIs quickly.",
   "main": "build/index.js",
   "types": "build/index.d.ts",
@@ -25,9 +25,11 @@
     "test:integration:postgres": "cd ./tests/integrations && node index.js postgres"
   },
   "dependencies": {
+    "@types/express": "^4.17.13",
     "change-case": "^4.1.2",
     "dotenv": "^14.2.0",
     "express": "^4.17.2",
+    "http-status-codes": "^2.2.0",
     "knex": "^1.0.1",
     "knex-paginate": "^3.0.0",
     "knex-schema-inspector": "^1.7.1",
@@ -39,8 +41,10 @@
     "@babel/core": "^7.16.10",
     "@babel/node": "^7.16.8",
     "@babel/preset-env": "^7.16.11",
+    "@babel/preset-typescript": "^7.18.6",
     "@babel/runtime": "^7.16.7",
-    "babel-jest": "^27.4.6",
+    "@types/pluralize": "^0.0.29",
+    "babel-jest": "^29.0.3",
     "babel-loader": "^8.2.3",
     "babel-plugin-module-resolver": "^4.1.0",
     "babel-preset-minify": "^0.5.1",
@@ -52,11 +56,11 @@
     "eslint-plugin-standard": "^5.0.0",
     "eslint-plugin-unicorn": "^33.0.1",
     "eslint-watch": "^7.0.0",
-    "jest": "^27.4.7",
     "mysql": "^2.18.1",
     "nodemon": "^2.0.15",
     "pg": "^8.7.1",
     "set-value": ">=4.1.0",
-    "sqlite3": "^5.0.2"
+    "sqlite3": "^5.0.2",
+    "ts-jest": "^29.0.1"
   }
 }