@autofleet/sheilta 1.0.6-aaron-test → 1.0.6

package/lib/formatter/index.d.ts

@@ -1,18 +1,12 @@
 declare type OrderItem = string | [string, string];
 declare type SequelizeOrder = string | OrderItem[];
-declare const formatPayload: ({ order, page, perPage, include, query, attributes, searchTerm, }: {
+declare const formatPayload: ({ order, page, perPage, }: {
     order: any;
     page?: number;
     perPage?: number;
-    include?: any[];
-    query?: {};
-    attributes?: any;
-    searchTerm?: any;
-}, model?: any) => {
-    query: {};
+}) => {
     order: SequelizeOrder[];
     page: any;
     perPage: any;
-    include: any;
 };
 export default formatPayload;

package/lib/formatter/index.js

@@ -1,70 +1,29 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = __importDefault(require("lodash"));
 const utils_1 = require("../utils");
 const DESCENDING_KEY = 'DESC';
-const formatOrder = ({ order = [], associationModels = [], }) => (order.length === 0 ? undefined :
+const formatOrder = ({ order = [], }) => (order.length === 0 ? undefined :
     order.map((o) => {
-        const formattedOrder = [utils_1.extractAttributeNameFromOrder(o, associationModels)];
         const isOrderDescOrder = utils_1.isOrderDesc(o);
-        const isOrderAssociation = utils_1.isAttributeByAssociation(isOrderDescOrder
-            ? o.split(utils_1.ORDER_PREFIX)[1]
-            : o, associationModels);
-        if (isOrderAssociation) {
-            formattedOrder.push(utils_1.extractAssociatedAttributeNameFromOrder(o));
-        }
+        let column = o;
         if (isOrderDescOrder) {
-            formattedOrder.push(DESCENDING_KEY);
+            column = utils_1.extractAttributeNameFromOrder(o);
+            return [column, DESCENDING_KEY];
         }
-        return formattedOrder;
+        return [column];
     }));
 const formatPage = page => page || utils_1.PAGE_DEFAULT;
 const formatPerPage = perPage => perPage || utils_1.PER_PAGE_DEFAULT;
-const formatInclude = (include, associationsMap = {}) => {
-    let formattedInclude = include.map(i => (Object.assign(Object.assign({}, i), { association: associationsMap[i.association || i.model], required: i.required !== 'false' })));
-    formattedInclude = formattedInclude.map(i => lodash_1.default.omit(i, ['model']));
-    return formattedInclude;
-};
-const formatQuery = (query, associationModels) => Object.keys(query).reduce((acc, queryItemKey) => (Object.assign(Object.assign({}, acc), { [utils_1.isAttributeByAssociation(queryItemKey, associationModels)
-        ? utils_1.wrapAttributeWithOperator(queryItemKey) : queryItemKey]: query[queryItemKey] })), {});
-const formatSearchTerm = (searchTerm, attributesToSend, rawAttributes) => ({
-    $and: searchTerm.split(' ').map(term => ({
-        $or: attributesToSend.filter(attrKey => rawAttributes[attrKey].type.key === 'STRING').map(attr => ({
-            [attr]: {
-                $iLike: `%${term}%`,
-            },
-        })),
-    })),
-});
-const formatPayload = ({ order, page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, include = [], query = {}, attributes = null, searchTerm = null, }, model) => {
-    const associationModels = Object.keys((model === null || model === void 0 ? void 0 : model.associations) || {});
+const formatPayload = ({ order, page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, }) => {
     const formattedOrder = formatOrder({
         order,
-        associationModels,
     });
-    const formattedInclude = formatInclude(include, model === null || model === void 0 ? void 0 : model.associations);
     const formattedPage = formatPage(page);
     const formattedPerPage = formatPerPage(perPage);
-    let formattedQuery = formatQuery(query, associationModels);
-    if (searchTerm) {
-        const attributesToSend = (attributes === null || attributes === void 0 ? void 0 : attributes.length) ? attributes : Object.keys(model.rawAttributes);
-        const queryWithSearchTerm = formatSearchTerm(searchTerm, attributesToSend, model.rawAttributes);
-        formattedQuery = lodash_1.default.isEmpty(formattedQuery) ? queryWithSearchTerm : {
-            $and: [
-                formattedQuery,
-                queryWithSearchTerm,
-            ],
-        };
-    }
     return {
-        query: formattedQuery,
         order: formattedOrder,
         page: formattedPage,
         perPage: formattedPerPage,
-        include: formattedInclude,
     };
 };
 exports.default = formatPayload;

package/lib/formatter/index.test.js

@@ -5,189 +5,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const _1 = __importDefault(require("."));
 describe('formatting test', () => {
-    describe('query formatting', () => {
-        it('query json field', () => {
-            const { query } = _1.default({
-                order: [],
-                query: {
-                    'json.field': {
-                        $gt: 4,
-                    },
-                },
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', json: '',
-                },
-            });
-            expect(JSON.stringify(query)).toBe(JSON.stringify({ 'json.field': { $gt: 4 } }));
-        });
-        it('query included model field', () => {
-            const { query } = _1.default({
-                order: [],
-                query: {
-                    'status.field': {
-                        $gt: 4,
-                    },
-                },
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-                associations: {
-                    status: {},
-                },
-            });
-            expect(JSON.stringify(query)).toBe(JSON.stringify({ '$status.field$': { $gt: 4 } }));
-        });
-        it('query with searchTerm', () => {
-            const searchTerm = 'aviv';
-            const { query } = _1.default({
-                order: [],
-                query: {
-                    'json.field': {
-                        $gt: 4,
-                    },
-                },
-                searchTerm,
-            }, {
-                rawAttributes: {
-                    startTime: {
-                        type: {
-                            key: 'STRING',
-                        },
-                    },
-                    endTime: {
-                        type: {
-                            key: 'NUMBER',
-                        },
-                    },
-                },
-            });
-            expect(JSON.stringify(query)).toBe(JSON.stringify({
-                $and: [{ 'json.field': { $gt: 4 } }, {
-                        $and: [{
-                                $or: [
-                                    {
-                                        startTime: {
-                                            $iLike: `%${searchTerm}%`,
-                                        },
-                                    },
-                                ],
-                            }],
-                    }],
-            }));
-        });
-        it('query with searchTerm with spaces', () => {
-            const searchTerm = 'aviv good guy';
-            const splitSearch = searchTerm.split(' ');
-            const { query } = _1.default({
-                order: [],
-                query: {
-                    'json.field': {
-                        $gt: 4,
-                    },
-                },
-                searchTerm,
-            }, {
-                rawAttributes: {
-                    startTime: {
-                        type: {
-                            key: 'STRING',
-                        },
-                    },
-                    endTime: {
-                        type: {
-                            key: 'NUMBER',
-                        },
-                    },
-                },
-            });
-            expect(JSON.stringify(query)).toBe(JSON.stringify({
-                $and: [{ 'json.field': { $gt: 4 } }, {
-                        $and: [{
-                                $or: [
-                                    {
-                                        startTime: {
-                                            $iLike: `%${splitSearch[0]}%`,
-                                        },
-                                    }
-                                ],
-                            }, {
-                                $or: [{
-                                        startTime: {
-                                            $iLike: `%${splitSearch[1]}%`,
-                                        },
-                                    }],
-                            },
-                            {
-                                $or: [{
-                                        startTime: {
-                                            $iLike: `%${splitSearch[2]}%`,
-                                        },
-                                    }],
-                            }],
-                    }],
-            }));
+    it('check order formatting', () => {
+        const { order } = _1.default({
+            order: ['startTime', '-endTime'],
         });
+        expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime', 'DESC']]));
     });
-    describe('order formatting', () => {
-        it('simple check', () => {
-            const { order } = _1.default({
-                order: ['startTime', '-endTime'],
-            });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime', 'DESC']]));
-        });
-        it('simple check asc', () => {
-            const { order } = _1.default({
-                order: ['startTime', 'endTime'],
-            });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime']]));
-        });
-        it('by included model', () => {
-            const { order } = _1.default({
-                order: ['status.name'],
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-                associations: {
-                    status: {},
-                },
-            });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name']]));
-        });
-        it('by included model descending', () => {
-            const { order } = _1.default({
-                order: ['-status.name'],
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-                associations: {
-                    status: {},
-                },
-            });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name', 'DESC']]));
-        });
-        it('by json field', () => {
-            const { order } = _1.default({
-                order: ['status.name'],
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', json: '',
-                },
-            });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name']]));
-        });
-        it('by json field descending', () => {
-            const { order } = _1.default({
-                order: ['-status.name'],
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', json: '',
-                },
-            });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name', 'DESC']]));
+    it('check order formatting', () => {
+        const { order } = _1.default({
+            order: ['startTime', 'endTime'],
         });
+        expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime']]));
     });
 });

package/lib/middleware/index.d.ts

@@ -1,4 +1,2 @@
-export declare const newQueryValidationMiddleware: (inner?: string) => (model: any) => (req: any, res: any, next: any) => Promise<any>;
-export declare const newQueryFormatMiddleware: (inner?: string) => (model: any) => (req: any, res: any, next: any) => Promise<any>;
 export declare const queryValidationMiddleware: (model: any) => (req: any, res: any, next: any) => Promise<any>;
-export declare const queryFormatMiddleware: (model: any) => (req: any, res: any, next: any) => Promise<any>;
+export declare const queryFormatMiddleware: () => (req: any, res: any, next: any) => Promise<any>;

package/lib/middleware/index.js

@@ -12,33 +12,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryFormatMiddleware = exports.queryValidationMiddleware = exports.newQueryFormatMiddleware = exports.newQueryValidationMiddleware = void 0;
+exports.queryFormatMiddleware = exports.queryValidationMiddleware = void 0;
 const errors_1 = require("@autofleet/errors");
-const joi_1 = require("joi");
 const formatter_1 = __importDefault(require("../formatter"));
 const validations_1 = require("../validations");
-const querySchema = joi_1.object({
-    query: joi_1.object(),
-    attributes: joi_1.array().items(joi_1.string()),
-    order: joi_1.array().items(joi_1.string()),
-    page: joi_1.number(),
-    perPage: joi_1.number(),
-    include: joi_1.array().items(joi_1.any()),
-});
-exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
-    const { query, attributes, order, page, perPage, include, } = req[inner];
+exports.queryValidationMiddleware = model => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const { query, attributes, order, page, perPage, } = req.body;
     try {
-        const result = querySchema.validate(req[inner]);
-        if (result.error) {
-            throw new errors_1.BadRequest([result.error], null);
-        }
         validations_1.validatePayload({
             query,
             attributes,
             order,
             page,
             perPage,
-            include,
         }, model);
         return next();
     }
@@ -54,23 +40,15 @@ exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, n
         });
     }
 });
-exports.newQueryFormatMiddleware = (inner = 'body') => model => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
-    const { order, page, perPage, include, query, attributes, searchTerm, } = req[inner];
-    const { query: formattedQuery, order: formattedOrder, page: formattedPage, perPage: formattedPerPage, include: formattedInclude, } = formatter_1.default({
-        query,
+exports.queryFormatMiddleware = () => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+    const { order, page, perPage, } = req.body;
+    const { order: formattedOrder, page: formattedPage, perPage: formattedPerPage, } = formatter_1.default({
         order,
         page,
         perPage,
-        include,
-        attributes,
-        searchTerm,
-    }, model);
-    req[inner].query = formattedQuery;
-    req[inner].order = formattedOrder;
-    req[inner].page = formattedPage;
-    req[inner].perPage = formattedPerPage;
-    req[inner].include = formattedInclude;
+    });
+    req.body.order = formattedOrder;
+    req.body.page = formattedPage;
+    req.body.perPage = formattedPerPage;
     return next();
 });
-exports.queryValidationMiddleware = exports.newQueryValidationMiddleware();
-exports.queryFormatMiddleware = exports.newQueryFormatMiddleware();

package/lib/operators/index.js

@@ -13,13 +13,10 @@ exports.OPERATORS = [
     'notIn',
     'is',
     'like',
-    'iLike',
     'notLike',
     'between',
     'and',
     'or',
-    'overlap',
-    'contains',
 ];
 exports.OPERATOR_PREFIX = '$';
 exports.formatOperators = (Sequelize) => {

package/lib/utils.d.ts

@@ -1,13 +1,9 @@
 export declare const ORDER_PREFIX = "-";
-export declare const ASSOCIATION_PREFIX = ".";
 export declare const PER_PAGE_DEFAULT = 20;
 export declare const PAGE_DEFAULT = 1;
 export declare const PER_PAGE_MAX_LIMIT = 100;
 export declare const PER_PAGE_MIN_LIMIT = 1;
 export declare const PAGE_MIN = 1;
-export declare const wrapAttributeWithOperator: (attribute: any) => string;
-export declare const isAttributeByAssociation: (attributeName: any, associatedModels: any) => boolean;
-export declare const extractAttributeNameFromOrder: (order: any, associationModels: any) => string;
+export declare const extractAttributeNameFromOrder: (order: any) => string;
 export declare const isOrderDesc: (order: any) => boolean;
 export declare const throwBadRequestError: (message: string) => never;
-export declare const extractAssociatedAttributeNameFromOrder: (order: any) => string;

package/lib/utils.js

@@ -1,31 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractAssociatedAttributeNameFromOrder = exports.throwBadRequestError = exports.isOrderDesc = exports.extractAttributeNameFromOrder = exports.isAttributeByAssociation = exports.wrapAttributeWithOperator = exports.PAGE_MIN = exports.PER_PAGE_MIN_LIMIT = exports.PER_PAGE_MAX_LIMIT = exports.PAGE_DEFAULT = exports.PER_PAGE_DEFAULT = exports.ASSOCIATION_PREFIX = exports.ORDER_PREFIX = void 0;
+exports.throwBadRequestError = exports.isOrderDesc = exports.extractAttributeNameFromOrder = exports.PAGE_MIN = exports.PER_PAGE_MIN_LIMIT = exports.PER_PAGE_MAX_LIMIT = exports.PAGE_DEFAULT = exports.PER_PAGE_DEFAULT = exports.ORDER_PREFIX = void 0;
 const errors_1 = require("@autofleet/errors");
-const operators_1 = require("./operators");
 exports.ORDER_PREFIX = '-';
-exports.ASSOCIATION_PREFIX = '.';
 exports.PER_PAGE_DEFAULT = 20;
 exports.PAGE_DEFAULT = 1;
 exports.PER_PAGE_MAX_LIMIT = 100;
 exports.PER_PAGE_MIN_LIMIT = 1;
 exports.PAGE_MIN = 1;
-exports.wrapAttributeWithOperator = attribute => `${operators_1.OPERATOR_PREFIX}${attribute}${operators_1.OPERATOR_PREFIX}`;
-exports.isAttributeByAssociation = (attributeName, associatedModels) => attributeName.includes(exports.ASSOCIATION_PREFIX)
-    && associatedModels.includes(attributeName.split(exports.ASSOCIATION_PREFIX)[0]);
-exports.extractAttributeNameFromOrder = (order, associationModels) => {
-    let formattedOrder = order;
-    if (order.includes(exports.ORDER_PREFIX)) {
-        // eslint-disable-next-line prefer-destructuring
-        formattedOrder = formattedOrder.split(exports.ORDER_PREFIX)[1];
-    }
-    if (exports.isAttributeByAssociation(formattedOrder, associationModels)) {
-        [formattedOrder] = formattedOrder.split(exports.ASSOCIATION_PREFIX);
-    }
-    return formattedOrder;
-};
+exports.extractAttributeNameFromOrder = (order) => order.split(exports.ORDER_PREFIX)[1];
 exports.isOrderDesc = (order) => order.includes(exports.ORDER_PREFIX);
-exports.throwBadRequestError = (message) => {
-    throw new errors_1.BadRequest([{ message }], null);
-};
-exports.extractAssociatedAttributeNameFromOrder = (order) => order.split(exports.ASSOCIATION_PREFIX)[1];
+exports.throwBadRequestError = (message) => { throw new errors_1.BadRequest(message, null); };

package/lib/validations/index.d.ts

@@ -1,8 +1,7 @@
-export declare const validatePayload: ({ query, order, attributes, include, page, perPage, }: {
+export declare const validatePayload: ({ query, order, attributes, page, perPage, }: {
     query?: {};
     order?: any[];
     attributes?: any[];
-    include?: any[];
     page?: number;
     perPage?: number;
-}, model?: any) => boolean;
+}, model: any) => boolean;

package/lib/validations/index.js

@@ -8,22 +8,16 @@ const lodash_1 = __importDefault(require("lodash"));
 const utils_1 = require("../utils");
 const operators_1 = require("../operators");
 const validateOperator = (operator) => operators_1.OPERATORS.includes(operator.split(operators_1.OPERATOR_PREFIX)[1]);
-const validateQueryAttribute = (attribute, modelAttributes = [], associationModels = []) => [...modelAttributes, ...associationModels]
-    .includes(attribute.includes(utils_1.ASSOCIATION_PREFIX)
-    ? attribute.split(utils_1.ASSOCIATION_PREFIX)[0] : attribute);
-const validateSingleOrder = (currentOrder, rawAttributes, associationModels) => {
+const validateQueryAttribute = (attribute, modelAttributes) => modelAttributes.includes(attribute);
+const validateSingleOrder = (currentOrder, rawAttributes) => {
     const isOrderDescOrder = utils_1.isOrderDesc(currentOrder);
     if (isOrderDescOrder && currentOrder[0] !== utils_1.ORDER_PREFIX) {
         utils_1.throwBadRequestError(`${utils_1.ORDER_PREFIX} must be only at the beginning of the word`);
     }
-    const orderStringWithoutDesc = isOrderDescOrder ?
-        currentOrder.split(utils_1.ORDER_PREFIX)[1] : currentOrder;
-    const isOrderAssociation = utils_1.isAttributeByAssociation(orderStringWithoutDesc, associationModels);
-    let formattedOrderString = utils_1.extractAttributeNameFromOrder(currentOrder, associationModels);
-    if (!isOrderAssociation && formattedOrderString.includes(utils_1.ASSOCIATION_PREFIX)) {
-        [formattedOrderString] = formattedOrderString.split(utils_1.ASSOCIATION_PREFIX);
-    }
-    if (!(rawAttributes.includes(formattedOrderString) || isOrderAssociation)) {
+    const formattedOrderString = isOrderDescOrder ?
+        utils_1.extractAttributeNameFromOrder(currentOrder) :
+        currentOrder;
+    if (!rawAttributes.includes(formattedOrderString)) {
         utils_1.throwBadRequestError(`${currentOrder} is invalid`);
     }
 };
@@ -32,23 +26,22 @@ const validateSingleAttribute = (currentAttribute, rawAttributes) => {
         utils_1.throwBadRequestError(`${currentAttribute} is invalid`);
     }
 };
-const validateOrderAttributes = (order, rawAttributes, associationModels = []) => {
-    order.map(o => validateSingleOrder(o, rawAttributes, associationModels));
+const validateOrderAttributes = (order, rawAttributes) => {
+    order.map(o => validateSingleOrder(o, rawAttributes));
 };
 const validateAttributes = (attributes, rawAttributes) => {
     attributes.map(a => validateSingleAttribute(a, rawAttributes));
 };
-const validateQueryPayload = (query, rawAttributes, associationModels = []) => {
+const validateQueryPayload = (query, rawAttributes) => {
     // eslint-disable-next-line array-callback-return
     Object.keys(query).map((key) => {
         const value = query[key];
         if (lodash_1.default.isArray(value)) {
             if (lodash_1.default.isObject(value[0])) {
-                value.map(v => validateQueryPayload(v, rawAttributes, associationModels));
+                value.map(v => validateQueryPayload(v, rawAttributes));
             }
         }
-        else if (validateOperator(key)
-            || validateQueryAttribute(key, rawAttributes, associationModels)) {
+        else if (validateOperator(key) || validateQueryAttribute(key, rawAttributes)) {
             if (lodash_1.default.isObject(value)) {
                 validateQueryPayload(value, rawAttributes);
             }
@@ -62,38 +55,12 @@ const validatePagination = ({ page, perPage, }) => {
     if (page < utils_1.PAGE_MIN) {
         utils_1.throwBadRequestError('Page must be greater than 0');
     }
-    if (perPage > utils_1.PER_PAGE_MAX_LIMIT || perPage < utils_1.PER_PAGE_MIN_LIMIT) {
+    if (perPage >= utils_1.PER_PAGE_MAX_LIMIT || perPage <= utils_1.PER_PAGE_MIN_LIMIT) {
         utils_1.throwBadRequestError(`PerPage must be between ${utils_1.PER_PAGE_MIN_LIMIT} to ${utils_1.PER_PAGE_MAX_LIMIT}`);
     }
 };
-const validateIncludePayload = (include, associations) => {
-    const associationsKeys = Object.keys(associations);
-    include.forEach((i) => {
-        var _a;
-        validateQueryAttribute(i.model, associationsKeys);
-        const target = (_a = associations[i.model]) === null || _a === void 0 ? void 0 : _a.target;
-        if (!target) {
-            utils_1.throwBadRequestError('model not found in associations');
-        }
-        const { rawAttributes } = target;
-        if (include.where) {
-            validateQueryPayload(i.where, rawAttributes);
-        }
-        if (include.order) {
-            validateOrderAttributes(i.order, rawAttributes);
-        }
-        if (include.attributes) {
-            validateAttributes(i.attributes, rawAttributes);
-        }
-        if (!lodash_1.default.isNil(include.required) && !lodash_1.default.isBoolean(include.required)) {
-            utils_1.throwBadRequestError('include.required must be a boolean');
-        }
-    });
-    console.log('loopend');
-};
-exports.validatePayload = ({ query = {}, order = [], attributes = [], include = [], page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, }, model) => {
+exports.validatePayload = ({ query = {}, order = [], attributes = [], page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, }, model) => {
     const rawAttributes = Object.keys(model.rawAttributes);
-    const associationModels = Object.keys((model === null || model === void 0 ? void 0 : model.associations) || {});
     if (!attributes || attributes.length === 0) {
         // eslint-disable-next-line no-param-reassign
         attributes = rawAttributes;
@@ -101,15 +68,8 @@ exports.validatePayload = ({ query = {}, order = [], attributes = [], include =
     else {
         validateAttributes(attributes, rawAttributes);
     }
-    validateOrderAttributes(order, rawAttributes, associationModels);
-    validateQueryPayload(query, rawAttributes, associationModels);
-    if (include.length && typeof include === 'object') {
-        validateIncludePayload(include, model === null || model === void 0 ? void 0 : model.associations);
-    }
-    else if (include && typeof include !== 'object') {
-        utils_1.throwBadRequestError('include must be an array');
-    }
-    console.log('validatePagination');
+    validateOrderAttributes(order, rawAttributes);
+    validateQueryPayload(query, rawAttributes);
     validatePagination({
         page,
         perPage,

package/lib/validations/index.test.js

@@ -38,147 +38,44 @@ const query = {
 };
 const order = ['startTime', '-endTime'];
 describe('validations test', () => {
-    describe('query validation', () => {
-        it('check query validation', () => {
-            const payload = _1.validatePayload({ query }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('check query by json property field', () => {
-            const payload = _1.validatePayload({
-                query: {
-                    'jsonField.exampleField': {
-                        $eq: 'a',
-                    },
-                },
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', jsonField: {},
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('check query by included model field', () => {
-            const payload = _1.validatePayload({
-                query: {
-                    'status.name': {
-                        $eq: 'a',
-                    },
-                },
-            }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-                associations: {
-                    status: {},
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('check query by non existent field', () => {
-            try {
-                _1.validatePayload({
-                    query: {
-                        nonExistent: {
-                            $eq: 'a',
-                        },
-                    },
-                }, {
-                    rawAttributes: {
-                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                    },
-                });
-            }
-            catch (error) {
-                expect(error.statusCode).toBe(400);
-            }
+    it('check query validation', () => {
+        const payload = _1.validatePayload({ query }, {
+            rawAttributes: {
+                startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+            },
         });
+        expect(payload).toBe(true);
     });
-    describe('order validation', () => {
-        it('check order validation', () => {
-            const payload = _1.validatePayload({ order }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('order does not exist', () => {
-            try {
-                _1.validatePayload({ order: ['aviv'] }, {
-                    rawAttributes: {
-                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                    },
-                });
-            }
-            catch (error) {
-                expect(error.statusCode).toBe(400);
-            }
-        });
-        it('prefix in the wrong place', () => {
-            try {
-                _1.validatePayload({ order: ['startTime-', 'currencySymbol'] }, {
-                    rawAttributes: {
-                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                    },
-                });
-            }
-            catch (error) {
-                expect(error.statusCode).toBe(400);
-            }
+    it('check order validation', () => {
+        const payload = _1.validatePayload({ order }, {
+            rawAttributes: {
+                startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+            },
         });
-        it('order by included model', () => {
-            const payload = _1.validatePayload({ order: ['status.title'] }, {
+        expect(payload).toBe(true);
+    });
+    it('check order validation - order does not exist', () => {
+        try {
+            _1.validatePayload({ order: ['aviv'] }, {
                 rawAttributes: {
                     startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
                 },
-                associations: {
-                    status: {},
-                },
             });
-            expect(payload).toBe(true);
-        });
-        it('order by included model descending', () => {
-            const payload = _1.validatePayload({ order: ['-status.title'] }, {
+        }
+        catch (error) {
+            expect(error.statusCode).toBe(400);
+        }
+    });
+    it('check order validation - prefix in the wrong place', () => {
+        try {
+            _1.validatePayload({ order: ['startTime-', 'currencySymbol'] }, {
                 rawAttributes: {
                     startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
                 },
-                associations: {
-                    status: {},
-                },
             });
-            expect(payload).toBe(true);
-        });
-        it('order by json field', () => {
-            const payload = _1.validatePayload({ order: ['status.title'] }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('order by json field desc', () => {
-            const payload = _1.validatePayload({ order: ['-status.title'] }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('try order by json field that doesnt exist', () => {
-            try {
-                _1.validatePayload({ order: ['-stas.title'] }, {
-                    rawAttributes: {
-                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                    },
-                });
-            }
-            catch (error) {
-                expect(error.statusCode).toBe(400);
-            }
-        });
+        }
+        catch (error) {
+            expect(error.statusCode).toBe(400);
+        }
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sheilta",
-  "version": "1.0.6-aaron-test",
+  "version": "1.0.6",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -29,20 +29,19 @@
   "dependencies": {
     "@autofleet/errors": "^1.0.10",
     "@types/node": "^14.14.20",
-    "joi": "^17.9.2",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "@types/jest": "^24.9.0",
-    "@typescript-eslint/eslint-plugin": "^2.34.0",
-    "@typescript-eslint/parser": "^2.23.0",
+    "typescript": "^3.9.5",
     "eslint": "^6.8.0",
     "eslint-config-airbnb": "^16.1.0",
     "eslint-plugin-import": "^2.20.1",
-    "jest": "^25.1.0",
+    "@typescript-eslint/eslint-plugin": "^2.34.0",
+    "@typescript-eslint/parser": "^2.23.0",
+    "typescript-eslint": "0.0.1-alpha.0",
     "ts-jest": "^25.0.0",
-    "typescript": "^3.9.5",
-    "typescript-eslint": "0.0.1-alpha.0"
+    "jest": "^25.1.0",
+    "@types/jest": "^24.9.0"
   },
   "files": [
     "lib/**/*"