@autofleet/sheilta 1.4.8-beta-5 → 2.0.1

package/lib/operators/index.d.ts

@@ -1,20 +0,0 @@
-export declare const OPERATORS: string[];
-export declare const OPERATOR_PREFIX = "$";
-export declare const OPERATORS_TO_SQL: {
-    $eq: string;
-    $ne: string;
-    $gte: string;
-    $gt: string;
-    $lte: string;
-    $lt: string;
-    $not: string;
-    $in: string;
-    $notIn: string;
-    $is: string;
-    $like: string;
-    $iLike: string;
-    $notLike: string;
-    $and: string;
-    $or: string;
-};
-export declare const formatOperators: (Sequelize: any) => {};

package/lib/operators/index.js

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatOperators = exports.OPERATORS_TO_SQL = 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.OPERATORS_TO_SQL = {
-    $eq: '=',
-    $ne: '!=',
-    $gte: '>=',
-    $gt: '>',
-    $lte: '<=',
-    $lt: '<',
-    $not: 'NOT',
-    $in: 'IN',
-    $notIn: 'NOT IN',
-    $is: 'IS',
-    $like: 'LIKE',
-    $iLike: 'ILIKE',
-    $notLike: 'NOT LIKE',
-    $and: 'AND',
-    $or: 'OR',
-};
-const 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;
-    }, {});
-};
-exports.formatOperators = formatOperators;

package/lib/utils.d.ts

@@ -1,14 +0,0 @@
-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;
-export declare const generateRandomString: (length?: number) => string;

package/lib/utils.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRandomString = 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");
-const randomInt = max => Math.floor(Math.random() * Math.floor(max));
-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;
-const wrapAttributeWithOperator = attribute => `${operators_1.OPERATOR_PREFIX}${attribute}${operators_1.OPERATOR_PREFIX}`;
-exports.wrapAttributeWithOperator = wrapAttributeWithOperator;
-const isAttributeByAssociation = (attributeName, associatedModels) => attributeName.includes(exports.ASSOCIATION_PREFIX)
-    && associatedModels.includes(attributeName.split(exports.ASSOCIATION_PREFIX)[0]);
-exports.isAttributeByAssociation = isAttributeByAssociation;
-const 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 ((0, exports.isAttributeByAssociation)(formattedOrder, associationModels)) {
-        [formattedOrder] = formattedOrder.split(exports.ASSOCIATION_PREFIX);
-    }
-    return formattedOrder;
-};
-exports.extractAttributeNameFromOrder = extractAttributeNameFromOrder;
-const isOrderDesc = (order) => order.includes(exports.ORDER_PREFIX);
-exports.isOrderDesc = isOrderDesc;
-const throwBadRequestError = (message) => {
-    throw new errors_1.BadRequest([new Error(message)], null);
-};
-exports.throwBadRequestError = throwBadRequestError;
-const extractAssociatedAttributeNameFromOrder = (order) => order.split(exports.ASSOCIATION_PREFIX)[1];
-exports.extractAssociatedAttributeNameFromOrder = extractAssociatedAttributeNameFromOrder;
-const generateRandomString = (length = 5) => {
-    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
-    return Array.from({ length }, () => characters.charAt(randomInt(characters.length))).join('');
-};
-exports.generateRandomString = generateRandomString;

package/lib/validations/index.d.ts

@@ -1,11 +0,0 @@
-import type { MiddlewareValidationOption } from '../middleware';
-export declare const validatePayload: ({ query, order, attributes, include, page, perPage, enrichments, group, }: {
-    query?: {};
-    order?: any[];
-    attributes?: any[];
-    include?: any[];
-    page?: number;
-    perPage?: number;
-    enrichments?: any[];
-    group?: any[];
-}, model?: any, options?: MiddlewareValidationOption) => boolean;

package/lib/validations/index.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatePayload = void 0;
-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 = [], additionalAllowedAttributes = []) => ([...modelAttributes, ...associationModels].includes(attribute.includes(utils_1.ASSOCIATION_PREFIX) ? attribute.split(utils_1.ASSOCIATION_PREFIX)[0] : attribute)
-    || additionalAllowedAttributes.includes(attribute));
-const validateSingleOrder = (currentOrder, rawAttributes, associationModels, options = {}) => {
-    const isOrderDescOrder = (0, utils_1.isOrderDesc)(currentOrder);
-    if (isOrderDescOrder && currentOrder[0] !== utils_1.ORDER_PREFIX) {
-        (0, 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 = (0, utils_1.isAttributeByAssociation)(orderStringWithoutDesc, associationModels);
-    let formattedOrderString = (0, utils_1.extractAttributeNameFromOrder)(currentOrder, associationModels);
-    const isLiteralAttribute = options?.literalAttributes?.map((la) => la.attribute)?.includes(orderStringWithoutDesc);
-    if (!isOrderAssociation && formattedOrderString.includes(utils_1.ASSOCIATION_PREFIX)) {
-        [formattedOrderString] = formattedOrderString.split(utils_1.ASSOCIATION_PREFIX);
-    }
-    if (!(rawAttributes.includes(formattedOrderString) || isOrderAssociation || isLiteralAttribute)) {
-        (0, utils_1.throwBadRequestError)(`${currentOrder} is invalid. isLiteralAttribute: ${isLiteralAttribute}`);
-    }
-};
-const validateSingleAttribute = (currentAttribute, rawAttributes) => {
-    if (!rawAttributes.includes(currentAttribute)) {
-        (0, utils_1.throwBadRequestError)(`${currentAttribute} is invalid`);
-    }
-};
-const validateOrderAttributes = (order, rawAttributes, associationModels = [], options = {}) => {
-    order.forEach((o) => validateSingleOrder(o, rawAttributes, associationModels, options));
-};
-const validateAttributes = (attributes, rawAttributes) => {
-    attributes.forEach((a) => validateSingleAttribute(a, rawAttributes));
-};
-const validateEnrichments = (enrichments, options) => {
-    const enrichmentKeys = Array.isArray(enrichments) ? enrichments : Object.keys(enrichments);
-    if (!enrichmentKeys?.length) {
-        return;
-    }
-    const invalidEnrichment = enrichmentKeys.find((enrichment) => !options?.enrichmentAttributes?.includes(enrichment));
-    if (invalidEnrichment) {
-        (0, utils_1.throwBadRequestError)(`enrichment attribute ${invalidEnrichment} is invalid`);
-    }
-};
-const validateQueryPayload = (query, rawAttributes, associationModels = [], additionalAllowedAttributes = []) => {
-    Object.entries(query).forEach(([key, value]) => {
-        if (Array.isArray(value)) {
-            if (value[0] && typeof value[0] === 'object') {
-                value.map((v) => validateQueryPayload(v, rawAttributes, associationModels, additionalAllowedAttributes));
-            }
-        }
-        else if (validateOperator(key) || validateQueryAttribute(key, rawAttributes, associationModels, additionalAllowedAttributes)) {
-            if (value && typeof value === 'object') {
-                validateQueryPayload(value, rawAttributes, [], additionalAllowedAttributes);
-            }
-        }
-        else {
-            (0, utils_1.throwBadRequestError)(`invalid key: ${key}`);
-        }
-    });
-};
-const validatePagination = ({ page, perPage, }) => {
-    if (page < utils_1.PAGE_MIN) {
-        (0, utils_1.throwBadRequestError)('Page must be greater than 0');
-    }
-    if (perPage > utils_1.PER_PAGE_MAX_LIMIT || perPage < utils_1.PER_PAGE_MIN_LIMIT) {
-        (0, 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) => {
-        validateQueryAttribute(i.model, associationsKeys);
-        const target = associations[i.model]?.target;
-        if (!target) {
-            (0, utils_1.throwBadRequestError)('model not found in associations');
-        }
-        const { rawAttributes } = target;
-        const attributeKeys = Object.keys(rawAttributes);
-        if (i.where) {
-            validateQueryPayload(i.where, attributeKeys);
-        }
-        if (i.order) {
-            validateOrderAttributes(i.order, attributeKeys);
-        }
-        if (i.attributes) {
-            validateAttributes(i.attributes, attributeKeys);
-        }
-        if (![null, undefined, true, false].includes(i.required)) {
-            (0, utils_1.throwBadRequestError)('include.required must be a boolean');
-        }
-    });
-};
-const validatePayload = ({ query = {}, order = [], attributes = [], include = [], page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, enrichments = [], group = [], }, model, options = {}) => {
-    const rawAttributes = Object.keys(model.rawAttributes);
-    const associationModels = Object.keys(model?.associations || {});
-    if (!attributes || attributes.length === 0) {
-        // eslint-disable-next-line no-param-reassign
-        attributes = rawAttributes;
-    }
-    else {
-        validateAttributes(attributes, rawAttributes);
-    }
-    validateOrderAttributes(order, rawAttributes, associationModels, options);
-    validateQueryPayload(query, rawAttributes, associationModels, options.additionalAllowedAttributes);
-    validateEnrichments(enrichments, options);
-    if (!Array.isArray(group)) {
-        (0, utils_1.throwBadRequestError)('group must be an array');
-    }
-    if (include.length && typeof include === 'object') {
-        validateIncludePayload(include, model?.associations);
-    }
-    else if (include && typeof include !== 'object') {
-        (0, utils_1.throwBadRequestError)('include must be an array');
-    }
-    validatePagination({
-        page,
-        perPage,
-    });
-    return true;
-};
-exports.validatePayload = validatePayload;

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

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

package/lib/validations/index.test.js

@@ -1,219 +0,0 @@
-"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 = (0, _1.validatePayload)({ query }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('check query by json property field', () => {
-            const payload = (0, _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 = (0, _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 {
-                (0, _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 = (0, _1.validatePayload)({ order }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('order does not exist', () => {
-            try {
-                (0, _1.validatePayload)({ order: ['aviv'] }, {
-                    rawAttributes: {
-                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                    },
-                });
-            }
-            catch (error) {
-                expect(error.statusCode).toBe(400);
-            }
-        });
-        it('prefix in the wrong place', () => {
-            try {
-                (0, _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 = (0, _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 = (0, _1.validatePayload)({ order: ['-status.title'] }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
-                },
-                associations: {
-                    status: {},
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('order by json field', () => {
-            const payload = (0, _1.validatePayload)({ order: ['status.title'] }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                },
-            });
-            expect(payload).toBe(true);
-        });
-        it('order by json field desc', () => {
-            const payload = (0, _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 {
-                (0, _1.validatePayload)({ order: ['-stas.title'] }, {
-                    rawAttributes: {
-                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                    },
-                });
-            }
-            catch (error) {
-                expect(error.statusCode).toBe(400);
-            }
-        });
-        it('try order by literal field that exist', () => {
-            const literalAttribute = { attribute: 'genericField', literal: 'void' };
-            const payload = (0, _1.validatePayload)({ order: [literalAttribute.attribute] }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                },
-            }, {
-                literalAttributes: [literalAttribute],
-            });
-            expect(payload).toBe(true);
-        });
-        it('try order by literal field that exist - desc', () => {
-            const literalAttribute = { attribute: 'genericField', literal: 'void' };
-            const payload = (0, _1.validatePayload)({ order: [`-${literalAttribute.attribute}`] }, {
-                rawAttributes: {
-                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                },
-            }, {
-                literalAttributes: [literalAttribute],
-            });
-            expect(payload).toBe(true);
-        });
-        it('try order by literal field that doesnt exist', () => {
-            const literalAttribute = { attribute: 'genericField', literal: 'void' };
-            try {
-                (0, _1.validatePayload)({ order: ['here'] }, {
-                    rawAttributes: {
-                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
-                    },
-                }, { literalAttributes: [literalAttribute] });
-            }
-            catch (error) {
-                expect(error.statusCode).toBe(400);
-            }
-        });
-    });
-});