@autofleet/sheilta 1.0.0-aaron-error-fix

package/README.md

@@ -0,0 +1 @@
+# sheilta

package/lib/formatter/index.d.ts

@@ -0,0 +1,18 @@
+declare type OrderItem = string | [string, string];
+declare type SequelizeOrder = string | OrderItem[];
+declare const formatPayload: ({ order, page, perPage, include, query, attributes, searchTerm, }: {
+    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

@@ -0,0 +1,70 @@
+"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 :
+    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));
+        }
+        if (isOrderDescOrder) {
+            formattedOrder.push(DESCENDING_KEY);
+        }
+        return formattedOrder;
+    }));
+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 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.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/formatter/index.test.js

@@ -0,0 +1,193 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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]}%`,
+                                        },
+                                    }],
+                            }],
+                    }],
+            }));
+        });
+    });
+    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']]));
+        });
+    });
+});

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+import { formatOperators } from './operators';
+import { queryFormatMiddleware, queryValidationMiddleware } from './middleware';
+export { formatOperators, queryFormatMiddleware, queryValidationMiddleware, };

package/lib/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryValidationMiddleware = exports.queryFormatMiddleware = exports.formatOperators = void 0;
+const operators_1 = require("./operators");
+Object.defineProperty(exports, "formatOperators", { enumerable: true, get: function () { return operators_1.formatOperators; } });
+const middleware_1 = require("./middleware");
+Object.defineProperty(exports, "queryFormatMiddleware", { enumerable: true, get: function () { return middleware_1.queryFormatMiddleware; } });
+Object.defineProperty(exports, "queryValidationMiddleware", { enumerable: true, get: function () { return middleware_1.queryValidationMiddleware; } });

package/lib/middleware/index.d.ts

@@ -0,0 +1,4 @@
+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>;

package/lib/middleware/index.js

@@ -0,0 +1,63 @@
+"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 });
+exports.queryFormatMiddleware = exports.queryValidationMiddleware = exports.newQueryFormatMiddleware = exports.newQueryValidationMiddleware = void 0;
+const errors_1 = require("@autofleet/errors");
+const formatter_1 = __importDefault(require("../formatter"));
+const validations_1 = require("../validations");
+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];
+    try {
+        validations_1.validatePayload({
+            query,
+            attributes,
+            order,
+            page,
+            perPage,
+            include,
+        }, model);
+        return next();
+    }
+    catch (error) {
+        return errors_1.handleError(error, res, {
+            message: 'error in query middleware',
+            payload: {
+                error,
+                query,
+                attributes,
+                order,
+            },
+        });
+    }
+});
+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,
+        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;
+    return next();
+});
+exports.queryValidationMiddleware = exports.newQueryValidationMiddleware();
+exports.queryFormatMiddleware = exports.newQueryFormatMiddleware();

package/lib/operators/index.d.ts

@@ -0,0 +1,3 @@
+export declare const OPERATORS: string[];
+export declare const OPERATOR_PREFIX = "$";
+export declare const formatOperators: (Sequelize: any) => {};

package/lib/operators/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatOperators = exports.OPERATOR_PREFIX = exports.OPERATORS = void 0;
+exports.OPERATORS = [
+    'eq',
+    'ne',
+    'gte',
+    'gt',
+    'lte',
+    'lt',
+    'not',
+    'in',
+    'notIn',
+    'is',
+    'like',
+    'iLike',
+    'notLike',
+    'between',
+    'and',
+    'or',
+    'overlap',
+    'contains',
+];
+exports.OPERATOR_PREFIX = '$';
+exports.formatOperators = (Sequelize) => {
+    const { Op } = Sequelize;
+    return exports.OPERATORS.reduce((map, o) => {
+        // eslint-disable-next-line no-param-reassign
+        map[`${exports.OPERATOR_PREFIX + o}`] = Op[o];
+        return map;
+    }, {});
+};

package/lib/utils.d.ts

@@ -0,0 +1,13 @@
+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 isOrderDesc: (order: any) => boolean;
+export declare const throwBadRequestError: (message: string) => never;
+export declare const extractAssociatedAttributeNameFromOrder: (order: any) => string;

package/lib/utils.js

@@ -0,0 +1,31 @@
+"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;
+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.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];

package/lib/validations/index.d.ts

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

package/lib/validations/index.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 });
+exports.validatePayload = void 0;
+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 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)) {
+        utils_1.throwBadRequestError(`${currentOrder} is invalid`);
+    }
+};
+const validateSingleAttribute = (currentAttribute, rawAttributes) => {
+    if (!rawAttributes.includes(currentAttribute)) {
+        utils_1.throwBadRequestError(`${currentAttribute} is invalid`);
+    }
+};
+const validateOrderAttributes = (order, rawAttributes, associationModels = []) => {
+    order.map(o => validateSingleOrder(o, rawAttributes, associationModels));
+};
+const validateAttributes = (attributes, rawAttributes) => {
+    attributes.map(a => validateSingleAttribute(a, rawAttributes));
+};
+const validateQueryPayload = (query, rawAttributes, associationModels = []) => {
+    // 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));
+            }
+        }
+        else if (validateOperator(key)
+            || validateQueryAttribute(key, rawAttributes, associationModels)) {
+            if (lodash_1.default.isObject(value)) {
+                validateQueryPayload(value, rawAttributes);
+            }
+        }
+        else {
+            utils_1.throwBadRequestError(`invalid key: ${key}`);
+        }
+    });
+};
+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) {
+        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');
+        }
+    });
+};
+exports.validatePayload = ({ query = {}, order = [], attributes = [], include = [], 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;
+    }
+    else {
+        validateAttributes(attributes, rawAttributes);
+    }
+    validateOrderAttributes(order, rawAttributes, associationModels);
+    validateQueryPayload(query, rawAttributes, associationModels);
+    if (include.length) {
+        validateIncludePayload(include, model === null || model === void 0 ? void 0 : model.associations);
+    }
+    validatePagination({
+        page,
+        perPage,
+    });
+    return true;
+};

package/lib/validations/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/validations/index.test.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const query = {
+    $and: [
+        {
+            startTime: {
+                $gte: '2019-09-10 12:00:00',
+            },
+        },
+        {
+            endTime: {
+                $lt: '2019-09-07 12:00:00',
+            },
+        },
+    ],
+    $or: [
+        {
+            $and: [
+                {
+                    currencySymbol: {
+                        $eq: ['€', 'f'],
+                    },
+                },
+                {
+                    currencyCode: {
+                        $eq: 'EUR',
+                    },
+                },
+            ],
+        },
+        {
+            startStationId: {
+                $eq: '1',
+            },
+        },
+    ],
+};
+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);
+            }
+        });
+    });
+    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('order by included model', () => {
+            const payload = _1.validatePayload({ order: ['status.title'] }, {
+                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'] }, {
+                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);
+            }
+        });
+    });
+});

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@autofleet/sheilta",
+  "version": "1.0.0-aaron-error-fix",
+  "description": "manage cache",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "rm -rf lib && tsc",
+    "prepublish": "npm run build",
+    "coverage": "jest --coverage --forceExit --runInBand",
+    "test": "jest --forceExit --runInBand",
+    "test-auto": "jest --watch --runInBand",
+    "linter": "./node_modules/.bin/eslint src/**/*.ts"
+  },
+  "jest": {
+    "setupTestFrameworkScriptFile": "jest-extended",
+    "testURL": "http://localhost:8085/"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@gitlab.com/AutoFleet/sheilta.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/Autofleet/sheilta/issues"
+  },
+  "homepage": "https://github.com/Autofleet/sheilta",
+  "dependencies": {
+    "@autofleet/errors": "^1.0.10",
+    "@types/node": "^14.14.20",
+    "lodash": "^4.17.21"
+  },
+  "devDependencies": {
+    "typescript": "^3.9.5",
+    "eslint": "^6.8.0",
+    "eslint-config-airbnb": "^16.1.0",
+    "eslint-plugin-import": "^2.20.1",
+    "@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",
+    "jest": "^25.1.0",
+    "@types/jest": "^24.9.0"
+  },
+  "files": [
+    "lib/**/*"
+  ]
+}