axe-api 0.20.1 → 0.20.2

package/build/src/Services/QueryService.js

@@ -0,0 +1,377 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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;
+        this.models = models;
+        this.createdJoins = [];
+        this.relationColumns = [];
+        this.usedConditionColumns = [];
+    }
+    applyFields(query, fields) {
+        // Users should be able to select some fields to show.
+        if (fields.length === 0 || (fields.length === 1 && fields[0] === "*")) {
+            query.select(`${this.model.instance.table}.*`);
+        }
+        else {
+            const fullPathFields = fields.map((field) => {
+                if (field.includes(".") === false) {
+                    return `${this.model.instance.table}.${field}`;
+                }
+                return field;
+            });
+            query.select([...fullPathFields, ...this.relationColumns]);
+        }
+    }
+    applySorting(query, sort) {
+        if (sort.length === 0) {
+            return;
+        }
+        sort.forEach((item) => {
+            query.orderBy(item.name, item.type);
+        });
+    }
+    applyWheresInsideGroup(sub, ruleSet) {
+        // If there is not any query, we don't have to filter the data.
+        if (!ruleSet) {
+            return;
+        }
+        if (Array.isArray(ruleSet)) {
+            for (const item of ruleSet) {
+                // 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);
+                }
+                else {
+                    // If the item is an array, we should create the query recursively.
+                    const firstItem = item[0];
+                    if (firstItem.prefix === "or") {
+                        sub.orWhere((sub) => {
+                            this.applyWheresInsideGroup(sub, item);
+                        });
+                    }
+                    else {
+                        sub.where((sub) => {
+                            this.applyWheresInsideGroup(sub, item);
+                        });
+                    }
+                }
+            }
+        }
+        else {
+            const condition = ruleSet;
+            this.applyConditionRule(sub, condition);
+        }
+    }
+    applyWheres(query, ruleSet) {
+        query.where((sub) => {
+            this.applyWheresInsideGroup(sub, ruleSet);
+        });
+        this.applyRelatedQueryJoins(query, ruleSet);
+    }
+    get(query) {
+        const conditions = this.parseSections(query);
+        const usedColumns = this.getUsedColumns(conditions);
+        const undefinedColumns = usedColumns.filter((columnName) => {
+            let currentModel = this.model;
+            let realColumName = columnName;
+            if (columnName.includes(".")) {
+                const [table, splittedColumnName] = columnName.split(".");
+                currentModel = this.models.find((model) => model.instance.table === table);
+                realColumName = splittedColumnName;
+            }
+            return !currentModel || !currentModel.columnNames.includes(realColumName);
+        });
+        if (undefinedColumns.length > 0) {
+            throw new ApiError_1.default(`Undefined column names: ${undefinedColumns.join(",")}`);
+        }
+        return conditions;
+    }
+    getUsedColumns(conditions) {
+        return [
+            ...conditions.fields,
+            ...conditions.sort.map((item) => item.name),
+            ...Array.from(this.usedConditionColumns),
+        ];
+    }
+    applyConditionRule(sub, ruleSet) {
+        const method = this.getConditionMethodName(ruleSet);
+        const zeroArguments = ["Null", "NotNull"];
+        const oneArguments = ["In", "NotIn", "Between", "NotBetween"];
+        const fullFieldPath = `${ruleSet.table}.${ruleSet.field}`;
+        if (zeroArguments.indexOf(ruleSet.condition) > -1) {
+            const methodName = `${method}${ruleSet.condition}`;
+            return sub[methodName](fullFieldPath);
+        }
+        if (oneArguments.indexOf(ruleSet.condition) > -1) {
+            const methodName = `${method}${ruleSet.condition}`;
+            return sub[methodName](fullFieldPath, ruleSet.value);
+        }
+        return sub[method](fullFieldPath, ruleSet.condition, ruleSet.value);
+    }
+    applyRelatedQueryJoins(query, ruleSet) {
+        if (!ruleSet) {
+            return;
+        }
+        if (Array.isArray(ruleSet)) {
+            for (const item of ruleSet) {
+                // 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);
+                }
+                else {
+                    this.applyRelatedQueryJoins(query, item);
+                }
+            }
+        }
+        else {
+            this.applyJoinIfNecessary(query, ruleSet);
+        }
+    }
+    applyJoinIfNecessary(query, ruleSet) {
+        if (ruleSet.table !== this.model.instance.table) {
+            this.addJoinOnce(query, ruleSet);
+        }
+    }
+    addJoinOnce(query, ruleSet) {
+        const { model, relation } = ruleSet;
+        if (!relation) {
+            return;
+        }
+        if (this.createdJoins.includes(relation.name)) {
+            return;
+        }
+        const tableName = model.instance.table;
+        const primaryKey = `${model.instance.table}.${relation.primaryKey}`;
+        const foreignKey = `${this.model.instance.table}.${relation.foreignKey}`;
+        query.leftJoin(tableName, primaryKey, foreignKey);
+        this.createdJoins.push(relation.name);
+    }
+    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
+            // send unacceptable structure because of security reasons.
+            try {
+                sections.q = JSON.parse(queryContent);
+            }
+            catch (err) {
+                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: withQueryResolver.resolve((sections === null || sections === void 0 ? void 0 : sections.with) || ""),
+        };
+        this.addRelationColumns(query.with);
+        return query;
+    }
+    parsePage(content) {
+        const value = parseInt(content);
+        if (isNaN(value)) {
+            return 1;
+        }
+        if (value <= 0) {
+            return 1;
+        }
+        return value;
+    }
+    parsePerPage(content) {
+        const value = parseInt(content);
+        if (isNaN(value) || value <= 1 || value > 10000) {
+            return 10;
+        }
+        return value;
+    }
+    parseFields(content) {
+        if (!content) {
+            return [];
+        }
+        const strContent = content;
+        // User should be able to select "all" fields.
+        if (strContent.trim() === "*") {
+            return ["*"];
+        }
+        const fields = strContent.split(",");
+        fields.forEach((field) => {
+            this.shouldBeAcceptableColumn(field);
+        });
+        return fields;
+    }
+    parseSortingOptions(content) {
+        // If there is not any sorting options, we don't have to return any value
+        if (!content) {
+            return [];
+        }
+        const result = [];
+        const strContent = content;
+        for (let field of strContent.split(",")) {
+            let type = Enums_1.SortTypes.ASC;
+            if (field.indexOf("-") === 0) {
+                type = Enums_1.SortTypes.DESC;
+                field = field.substr(1);
+            }
+            if (field.indexOf("+") === 0) {
+                field = field.substr(1);
+            }
+            this.shouldBeAcceptableColumn(field);
+            result.push({
+                name: field,
+                type,
+            });
+        }
+        return result;
+    }
+    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);
+        });
+    }
+    parseCondition(content) {
+        if (Array.isArray(content)) {
+            return this.parseConditions(content);
+        }
+        if (!content) {
+            return [];
+        }
+        const wheres = [];
+        for (const key in content) {
+            wheres.push(this.parseConditionObject(content, key));
+        }
+        return wheres;
+    }
+    parseConditionObject(content, key) {
+        const where = {
+            prefix: null,
+            model: this.model,
+            table: this.model.instance.table,
+            field: key,
+            condition: Enums_1.ConditionTypes["="],
+            value: content[key],
+            relation: null,
+        };
+        // Sometimes we can have basic OR operations for queries
+        if (where.field.indexOf("$or.") === 0) {
+            where.prefix = "or";
+            where.field = where.field.replace("$or.", "");
+        }
+        if (where.field.indexOf("$and.") === 0) {
+            where.prefix = "and";
+            where.field = where.field.replace("$and.", "");
+        }
+        // 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")) {
+                where.field = where.field.replace(".$not", "");
+                where.condition = Enums_1.ConditionTypes.NotNull;
+            }
+            else {
+                // So, it means that the clients wants to see null valus
+                where.condition = Enums_1.ConditionTypes.Null;
+            }
+        }
+        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);
+        }
+        if (where.condition === Enums_1.ConditionTypes.In ||
+            where.condition === Enums_1.ConditionTypes.NotIn) {
+            where.value = where.value.split(",");
+        }
+        if (where.condition === Enums_1.ConditionTypes.Between ||
+            where.condition === Enums_1.ConditionTypes.NotBetween) {
+            where.value = where.value.split(":");
+        }
+        if (where.condition === Enums_1.ConditionTypes.LIKE ||
+            where.condition === Enums_1.ConditionTypes["NOT LIKE"]) {
+            where.value = where.value.replace(/\*/g, "%");
+        }
+        // This means that the condition is related with another table
+        if (where.field.includes(".")) {
+            const [relationName, field] = where.field.split(".");
+            const relation = this.model.relations.find((item) => item.name === relationName && item.type === Enums_1.Relationships.HAS_ONE);
+            if (!relation) {
+                throw new ApiError_1.default(`Unacceptable query field: ${relationName}.${field}`);
+            }
+            const relatedModel = this.models.find((item) => item.name === relation.model);
+            if (!relatedModel) {
+                throw new ApiError_1.default(`Undefined model name: ${relation.model}`);
+            }
+            where.model = relatedModel;
+            where.table = relatedModel.instance.table;
+            where.relation = relation;
+            where.field = field;
+        }
+        this.shouldBeAcceptableColumn(where.field);
+        this.usedConditionColumns.push(`${where.table}.${where.field}`);
+        return where;
+    }
+    applySpecialCondition(where, structure, condition) {
+        structure = `.${structure}`;
+        if (this.hasSpecialStructure(where.field, structure)) {
+            where.field = where.field.replace(structure, "");
+            where.condition = condition;
+        }
+    }
+    addRelationColumns(withs) {
+        withs.forEach((item) => {
+            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) {
+        if (ruleSet.prefix === "or") {
+            return "orWhere";
+        }
+        return "where";
+    }
+    hasSpecialStructure(field, structure) {
+        if (field.indexOf(structure) === -1) {
+            return false;
+        }
+        if (field.indexOf(structure) === field.length - structure.length) {
+            return true;
+        }
+        return false;
+    }
+    shouldBeAcceptableColumn(field) {
+        const regex = /^[0-9,a-z,A-Z_.]+$/;
+        if (!field.match(regex)) {
+            throw new ApiError_1.default(`Unacceptable field name: ${field}`);
+        }
+        if (field.indexOf(".") === 0 || field.indexOf(".") === field.length - 1) {
+            throw new ApiError_1.default(`You have to define the column specefically: ${field}`);
+        }
+    }
+}
+exports.default = QueryService;

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

@@ -0,0 +1,12 @@
+declare class SchemaValidatorService {
+    validate(): Promise<void>;
+    private checkModelColumnsOrFail;
+    private getModelFillableColumns;
+    private getModelFormValidationColumns;
+    private getModelHiddenColumns;
+    private getTimestampsColumns;
+    private checkRelationColumnsOrFail;
+    private checkHasManyRelation;
+    private checkHasOneRelation;
+}
+export default SchemaValidatorService;

package/build/src/Services/SchemaValidatorService.js

@@ -0,0 +1,114 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Enums_1 = require("../Enums");
+const Services_1 = require("../Services");
+class SchemaValidatorService {
+    constructor() {
+        this.getModelFillableColumns = (model) => {
+            const fillable = model.instance.fillable;
+            if (!fillable) {
+                return [];
+            }
+            if (Array.isArray(fillable)) {
+                return fillable;
+            }
+            const config = fillable;
+            return [
+                ...(config.POST || []),
+                ...(config.PUT || []),
+                ...(config.PATCH || []),
+            ];
+        };
+        this.getModelFormValidationColumns = (model) => {
+            const validations = model.instance.validations;
+            if (!validations) {
+                return [];
+            }
+            const objValidations = validations;
+            if (!objValidations.POST && !objValidations.PUT) {
+                return Object.keys(objValidations);
+            }
+            const config = validations;
+            return [
+                ...Object.keys(config.POST ? config.POST : {}),
+                ...Object.keys(config.PUT ? config.PUT : {}),
+            ];
+        };
+        this.getModelHiddenColumns = (model) => {
+            if (!model.instance.hiddens) {
+                return [];
+            }
+            return model.instance.hiddens;
+        };
+        this.getTimestampsColumns = (model) => {
+            const columns = [];
+            if (model.instance.createdAtColumn) {
+                columns.push(model.instance.createdAtColumn);
+            }
+            if (model.instance.updatedAtColumn) {
+                columns.push(model.instance.updatedAtColumn);
+            }
+            return columns;
+        };
+        this.checkHasManyRelation = (modelList, model, relation) => {
+            this.checkModelColumnsOrFail(model, [relation.primaryKey]);
+            const relatedModel = modelList.find(relation.model);
+            if (!relatedModel) {
+                throw new Error(`Undefined related model: ${relation.model}`);
+            }
+            this.checkModelColumnsOrFail(relatedModel, [relation.foreignKey]);
+        };
+    }
+    validate() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const logger = yield Services_1.IoCService.useByType("LogService");
+            const modelList = yield Services_1.IoCService.useByType("ModelListService");
+            modelList.get().forEach((model) => {
+                this.checkModelColumnsOrFail(model, this.getModelFillableColumns(model));
+                this.checkModelColumnsOrFail(model, this.getModelFormValidationColumns(model));
+                this.checkModelColumnsOrFail(model, this.getModelHiddenColumns(model));
+                this.checkModelColumnsOrFail(model, this.getTimestampsColumns(model));
+                this.checkModelColumnsOrFail(model, [model.instance.primaryKey]);
+                this.checkRelationColumnsOrFail(modelList, model);
+            });
+            logger.info("Database schema has been validated.");
+        });
+    }
+    checkModelColumnsOrFail(model, modelColumns) {
+        const undefinedColumns = modelColumns.filter((modelColumn) => !model.columnNames.includes(modelColumn));
+        if (undefinedColumns.length > 0) {
+            throw new Error(`${model.name} model doesn't have the following columns on the database; "${model.instance.table}.${undefinedColumns.join(",")}"`);
+        }
+    }
+    checkRelationColumnsOrFail(modelList, model) {
+        for (const relation of model.relations) {
+            if (relation.type === Enums_1.Relationships.HAS_MANY) {
+                this.checkHasManyRelation(modelList, model, relation);
+            }
+            else if (relation.type === Enums_1.Relationships.HAS_ONE) {
+                this.checkHasOneRelation(modelList, model, relation);
+            }
+            else {
+                throw new Error(`Undefined relation type: ${relation.type}`);
+            }
+        }
+    }
+    checkHasOneRelation(modelList, model, relation) {
+        this.checkModelColumnsOrFail(model, [relation.foreignKey]);
+        const relatedModel = modelList.find(relation.model);
+        if (!relatedModel) {
+            throw new Error(`Undefined related model: ${relation.model}`);
+        }
+        this.checkModelColumnsOrFail(relatedModel, [relation.primaryKey]);
+    }
+}
+exports.default = SchemaValidatorService;

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

@@ -0,0 +1,8 @@
+import DocumentationService from "./DocumentationService";
+import IoCService from "./IoCService";
+import LogService from "./LogService";
+import ModelListService from "./ModelListService";
+import ModelService from "./ModelService";
+import QueryService from "./QueryService";
+import SchemaValidatorService from "./SchemaValidatorService";
+export { DocumentationService, IoCService, LogService, ModelListService, ModelService, QueryService, SchemaValidatorService, };

package/build/src/Services/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaValidatorService = exports.QueryService = exports.ModelService = exports.ModelListService = exports.LogService = exports.IoCService = exports.DocumentationService = void 0;
+const DocumentationService_1 = __importDefault(require("./DocumentationService"));
+exports.DocumentationService = DocumentationService_1.default;
+const IoCService_1 = __importDefault(require("./IoCService"));
+exports.IoCService = IoCService_1.default;
+const LogService_1 = __importDefault(require("./LogService"));
+exports.LogService = LogService_1.default;
+const ModelListService_1 = __importDefault(require("./ModelListService"));
+exports.ModelListService = ModelListService_1.default;
+const ModelService_1 = __importDefault(require("./ModelService"));
+exports.ModelService = ModelService_1.default;
+const QueryService_1 = __importDefault(require("./QueryService"));
+exports.QueryService = QueryService_1.default;
+const SchemaValidatorService_1 = __importDefault(require("./SchemaValidatorService"));
+exports.SchemaValidatorService = SchemaValidatorService_1.default;

package/build/src/constants.d.ts

@@ -0,0 +1,23 @@
+import { HandlerTypes } from "./Enums";
+export declare const LOG_COLORS: {
+    fgBlack: string;
+    fgRed: string;
+    fgGreen: string;
+    fgYellow: string;
+    fgBlue: string;
+    fgMagenta: string;
+    fgCyan: string;
+    fgWhite: string;
+    fgReset: string;
+};
+export declare const DEFAULT_HANDLERS: HandlerTypes[];
+export declare const DEFAULT_METHODS_OF_MODELS: string[];
+export declare const API_ROUTE_TEMPLATES: {
+    store: (prefix: string, parentUrl: string, resource: string) => string;
+    paginate: (prefix: string, parentUrl: string, resource: string) => string;
+    all: (prefix: string, parentUrl: string, resource: string) => string;
+    show: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
+    update: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
+    patch: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
+    destroy: (prefix: string, parentUrl: string, resource: string, primaryKey: string) => string;
+};

package/build/src/constants.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.API_ROUTE_TEMPLATES = exports.DEFAULT_METHODS_OF_MODELS = exports.DEFAULT_HANDLERS = exports.LOG_COLORS = void 0;
+const Enums_1 = require("./Enums");
+exports.LOG_COLORS = {
+    fgBlack: "\x1b[30m",
+    fgRed: "\x1b[31m",
+    fgGreen: "\x1b[32m",
+    fgYellow: "\x1b[33m",
+    fgBlue: "\x1b[34m",
+    fgMagenta: "\x1b[35m",
+    fgCyan: "\x1b[36m",
+    fgWhite: "\x1b[37m",
+    fgReset: "\x1b[0m",
+};
+exports.DEFAULT_HANDLERS = [
+    Enums_1.HandlerTypes.INSERT,
+    Enums_1.HandlerTypes.PAGINATE,
+    Enums_1.HandlerTypes.SHOW,
+    Enums_1.HandlerTypes.UPDATE,
+    Enums_1.HandlerTypes.PATCH,
+    Enums_1.HandlerTypes.DELETE,
+];
+exports.DEFAULT_METHODS_OF_MODELS = [
+    "constructor",
+    "hasMany",
+    "hasOne",
+    "belongsTo",
+    "serialize",
+    "__defineGetter__",
+    "__defineSetter__",
+    "hasOwnProperty",
+    "__lookupGetter__",
+    "__lookupSetter__",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+    "toString",
+    "valueOf",
+    "toLocaleString",
+    "primaryKey",
+    "table",
+    "fillable",
+    "validations",
+    "handlers",
+    "middlewares",
+    "hiddens",
+    "createdAtColumn",
+    "updatedAtColumn",
+    "transaction",
+    "ignore",
+    "getFillableFields",
+    "getValidationRules",
+];
+exports.API_ROUTE_TEMPLATES = {
+    [Enums_1.HandlerTypes.INSERT]: (prefix, parentUrl, resource) => `/${prefix}/${parentUrl}${resource}`,
+    [Enums_1.HandlerTypes.PAGINATE]: (prefix, parentUrl, resource) => `/${prefix}/${parentUrl}${resource}`,
+    [Enums_1.HandlerTypes.ALL]: (prefix, parentUrl, resource) => `/${prefix}/${parentUrl}${resource}/all`,
+    [Enums_1.HandlerTypes.SHOW]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
+    [Enums_1.HandlerTypes.UPDATE]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
+    [Enums_1.HandlerTypes.PATCH]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
+    [Enums_1.HandlerTypes.DELETE]: (prefix, parentUrl, resource, primaryKey) => `/${prefix}/${parentUrl}${resource}/:${primaryKey}`,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "axe-api",
-  "version": "0.20.1",
+  "version": "0.20.2",
   "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",