axe-api 0.20.0-rc17 → 0.20.0-rc19

package/build/src/Builders/RouterBuilder.js

@@ -43,16 +43,17 @@ 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 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.");
         });

package/build/src/Handlers/Helpers.js

@@ -146,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}`);
         }
@@ -191,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";
@@ -52,8 +52,8 @@ 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[];

package/build/src/Resolvers/ModelResolver.js

@@ -39,7 +39,9 @@ class ModelResolver {
                     if (typeof relationFunction !== "function") {
                         throw new Error(`Model relation definition should be a function: ${model.name}.${relationMethod}`);
                     }
-                    model.relations.push(relationFunction.call(model.instance));
+                    const definition = relationFunction.call(model.instance);
+                    definition.name = relationMethod;
+                    model.relations.push(definition);
                 }
             }
         });

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,113 @@
+"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) {
+            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

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

package/build/src/Resolvers/index.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TransactionResolver = exports.ModelResolver = exports.ModelMiddlewareResolver = exports.GeneralHookResolver = exports.FolderResolver = exports.FileResolver = void 0;
+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"));
@@ -16,3 +16,5 @@ 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;
@@ -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-rc17",
+  "version": "0.20.0-rc19",
   "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",
@@ -41,9 +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",
     "@types/pluralize": "^0.0.29",
-    "babel-jest": "^27.4.6",
+    "babel-jest": "^29.0.3",
     "babel-loader": "^8.2.3",
     "babel-plugin-module-resolver": "^4.1.0",
     "babel-preset-minify": "^0.5.1",
@@ -55,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"
   }
 }