@autofleet/sheilta 1.4.8-beta-1 → 1.4.8-beta-3

package/lib/formatter/index.d.ts

@@ -0,0 +1,55 @@
+import type { LiteralAttribute } from '../middleware';
+type OrderItem = string | [string, string];
+type SequelizeOrder = string | OrderItem[];
+export type FormatPayloadOptions = {
+    includeRawPayload?: boolean;
+    literalAttributes?: LiteralAttribute[];
+    DBFormatter?: any;
+    skipSearchTermFormat?: boolean;
+    additionalAllowedAttributes?: string[];
+};
+type ConditionWithOperator = {
+    operator: string;
+    value: string;
+};
+export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
+/**
+ * Generates replacements for the given conditions.
+ *
+ * @param conditions - The conditions to generate replacements for.
+ * @returns The replacements object.
+ */
+export declare const generateFilterReplacements: (conditions: Record<string, ConditionValue>) => Record<string, string>;
+/**
+ * Generates replacements for the given order array.
+ *
+ * @param order - The order array to generate replacements for.
+ * @returns The replacements object.
+ */
+export declare const generateOrderReplacements: (order: string[]) => Record<string, string>;
+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, options?: FormatPayloadOptions) => {
+    externalQueryValues: Record<string, unknown>;
+    attributes: any[] | {
+        include: any[];
+    };
+    query: Record<string, unknown>;
+    order: SequelizeOrder[];
+    page: number;
+    perPage: number;
+    include: any;
+    scopes: (string | {
+        method: (string | {
+            replacementsMap: Record<string, string>;
+            scopeValue: any;
+        })[];
+    })[];
+};
+export default formatPayload;

package/lib/formatter/index.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOrderReplacements = exports.generateFilterReplacements = void 0;
+const common_types_1 = require("@autofleet/common-types");
+const utils_1 = require("../utils");
+const operators_1 = require("../operators");
+const DEFAULT_ORDER = 'id';
+const DESCENDING_KEY = 'DESC';
+const ASCENDING_KEY = 'ASC';
+const CUSTOM_FIELDS_QUERY_PREFIX = 'customFields.';
+const { CUSTOM_FIELDS_FILTER_SCOPE, CUSTOM_FIELDS_SORT_SCOPE } = common_types_1.customFields;
+const parseCustomFieldScopeQueryValue = (value) => {
+    if (['string', 'number'].includes(typeof value) || Array.isArray(value)) {
+        return value;
+    }
+    return Object.entries(value).map(([operator, conditionValue]) => ({
+        operator: operators_1.OPERATORS_TO_SQL[operator],
+        value: conditionValue,
+    }));
+};
+const getAttributeFromOrder = (order, options = {}) => {
+    const { literalAttributes = [], DBFormatter = undefined } = options;
+    const [formattedOrder, attributes] = order.reduce((acc, o) => {
+        const [item, orderStyle = 'ASC'] = Array.isArray(o) ? o : [o];
+        const found = literalAttributes?.find((obj) => obj.attribute === item);
+        if (found) {
+            acc[1].push(found.literal);
+            acc[0].push([DBFormatter ? DBFormatter(`"${found.attribute}" ${orderStyle}`) : `${found.attribute} ${orderStyle}`]);
+        }
+        else {
+            acc[0].push(o);
+        }
+        return acc;
+    }, [[], []]);
+    return [formattedOrder, attributes];
+};
+/**
+ * Generates replacements for the given conditions.
+ *
+ * @param conditions - The conditions to generate replacements for.
+ * @returns The replacements object.
+ */
+const generateFilterReplacements = (conditions) => {
+    const replacements = {};
+    Object.entries(conditions).forEach(([key, condition]) => {
+        const replacementKey = (0, utils_1.generateRandomString)();
+        // eslint-disable-next-line prefer-destructuring
+        replacements[replacementKey] = key.split(CUSTOM_FIELDS_QUERY_PREFIX)[1];
+        if (Array.isArray(condition)) {
+            condition.forEach((value) => {
+                const valueKey = (0, utils_1.generateRandomString)();
+                replacements[valueKey] = typeof value === 'string' ? value : value.value;
+            });
+        }
+        else if (typeof condition === 'string' || typeof condition === 'number' || typeof condition === 'boolean') {
+            const conditionKey = (0, utils_1.generateRandomString)();
+            replacements[conditionKey] = condition;
+        }
+        else if (condition?.operator) {
+            const operatorKey = (0, utils_1.generateRandomString)();
+            replacements[operatorKey] = condition.value;
+        }
+    });
+    return replacements;
+};
+exports.generateFilterReplacements = generateFilterReplacements;
+/**
+ * Generates replacements for the given order array.
+ *
+ * @param order - The order array to generate replacements for.
+ * @returns The replacements object.
+ */
+const generateOrderReplacements = (order) => {
+    const replacementMap = {};
+    order.forEach((o) => {
+        if (o.startsWith(CUSTOM_FIELDS_QUERY_PREFIX)) {
+            const rand = (0, utils_1.generateRandomString)();
+            // eslint-disable-next-line prefer-destructuring
+            replacementMap[rand] = o.split(CUSTOM_FIELDS_QUERY_PREFIX)[1];
+        }
+        else if (o.substring(1).startsWith(CUSTOM_FIELDS_QUERY_PREFIX)) {
+            const rand = (0, utils_1.generateRandomString)();
+            // eslint-disable-next-line prefer-destructuring
+            replacementMap[rand] = o.substring(1).split(CUSTOM_FIELDS_QUERY_PREFIX)[1];
+        }
+    });
+    return replacementMap;
+};
+exports.generateOrderReplacements = generateOrderReplacements;
+/**
+ * Creates a combined replacement map from order and query.
+ *
+ * @param order - The order array.
+ * @param query - The query object.
+ * @returns The combined replacements object.
+ */
+const createReplacementMap = (order, query) => ({
+    ...(0, exports.generateOrderReplacements)(order),
+    ...(0, exports.generateFilterReplacements)(query),
+});
+const formatOrder = ({ order, associationModels = [], replacementsMap = {}, }) => {
+    const formattedOrders = [];
+    const orderScopesMap = new Map();
+    order.forEach((o) => {
+        if ([o, o.substring(1)].some((t) => t.startsWith(CUSTOM_FIELDS_QUERY_PREFIX))) {
+            if (!orderScopesMap.has(CUSTOM_FIELDS_SORT_SCOPE)) {
+                orderScopesMap.set(CUSTOM_FIELDS_SORT_SCOPE, {});
+            }
+            const scopeKey = o.split(CUSTOM_FIELDS_QUERY_PREFIX)[1];
+            orderScopesMap.get(CUSTOM_FIELDS_SORT_SCOPE)[scopeKey] = ((0, utils_1.isOrderDesc)(o) ? DESCENDING_KEY : ASCENDING_KEY);
+            return;
+        }
+        const formattedOrder = [(0, utils_1.extractAttributeNameFromOrder)(o, associationModels)];
+        const isOrderDescOrder = (0, utils_1.isOrderDesc)(o);
+        const isOrderAssociation = (0, utils_1.isAttributeByAssociation)(isOrderDescOrder
+            ? o.split(utils_1.ORDER_PREFIX)[1]
+            : o, associationModels);
+        if (isOrderAssociation) {
+            formattedOrder.push((0, utils_1.extractAssociatedAttributeNameFromOrder)(o));
+        }
+        if (isOrderDescOrder) {
+            formattedOrder.push(DESCENDING_KEY);
+        }
+        formattedOrders.push(formattedOrder);
+    });
+    return {
+        formattedOrders,
+        replacementsMap,
+        orderScopes: Array.from(orderScopesMap.entries()).map(([scopeName, scopeValue]) => {
+            if (!scopeValue) {
+                return scopeName;
+            }
+            return {
+                method: [scopeName, {
+                        replacementsMap,
+                        scopeValue,
+                    }],
+            };
+        }),
+    };
+};
+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) => {
+        const includedAssociation = associationsMap[typeof i === 'string' ? i : (i.association || i.model)];
+        return {
+            ...(typeof i !== 'string' && i),
+            association: includedAssociation,
+            required: typeof i === 'string' || i.required !== false,
+            ...(typeof i !== 'string' && i.include && {
+                include: formatInclude(i.include, includedAssociation?.target?.associations),
+            }),
+        };
+    });
+    formattedInclude = formattedInclude.map(({ model: _model, ...i }) => i);
+    return formattedInclude;
+};
+const formatQuery = (query, associationModels, replacementsMap, additionalAllowedAttributes = []) => {
+    const formattedQuery = {};
+    const externalQueryValues = {};
+    const formattedScopeMap = new Map();
+    Object.entries(query).forEach(([queryItemKey, queryItemValue]) => {
+        if (queryItemKey.startsWith(CUSTOM_FIELDS_QUERY_PREFIX)) {
+            if (!formattedScopeMap.has(CUSTOM_FIELDS_FILTER_SCOPE)) {
+                formattedScopeMap.set(CUSTOM_FIELDS_FILTER_SCOPE, {});
+            }
+            const scopeKey = queryItemKey.split(CUSTOM_FIELDS_QUERY_PREFIX)[1];
+            formattedScopeMap.get(CUSTOM_FIELDS_FILTER_SCOPE)[scopeKey] = parseCustomFieldScopeQueryValue(queryItemValue);
+            return;
+        }
+        if (additionalAllowedAttributes.includes(queryItemKey)) {
+            externalQueryValues[queryItemKey] = queryItemValue;
+            return;
+        }
+        const key = (0, utils_1.isAttributeByAssociation)(queryItemKey, associationModels)
+            ? (0, utils_1.wrapAttributeWithOperator)(queryItemKey)
+            : queryItemKey;
+        formattedQuery[key] = queryItemValue;
+    });
+    const formattedScopes = Array.from(formattedScopeMap.entries()).map(([scopeName, scopeValue]) => {
+        if (!scopeValue) {
+            return scopeName;
+        }
+        return {
+            method: [scopeName, {
+                    replacementsMap,
+                    scopeValue,
+                }],
+        };
+    });
+    return {
+        formattedQuery,
+        externalQueryValues,
+        formattedScopes,
+    };
+};
+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, options) => {
+    const replacementsMap = createReplacementMap(order, query);
+    const associationModels = Object.keys(model?.associations || {});
+    const { formattedOrders, orderScopes } = formatOrder({
+        order: [...order, DEFAULT_ORDER],
+        associationModels,
+        replacementsMap,
+    });
+    const [filteredFormattedOrder, filteredLiteralAttributes] = getAttributeFromOrder(formattedOrders, options);
+    const allAttributes = [...filteredLiteralAttributes, ...(attributes || [])];
+    const formattedAttribute = attributes?.length ? allAttributes : { include: allAttributes };
+    const formattedInclude = formatInclude(include, model?.associations);
+    const formattedPage = formatPage(page);
+    const formattedPerPage = formatPerPage(perPage);
+    const result = formatQuery(query, associationModels, replacementsMap, options?.additionalAllowedAttributes);
+    const { formattedScopes: queryScopes, externalQueryValues } = result;
+    let { formattedQuery } = result;
+    if (searchTerm && !options?.skipSearchTermFormat) {
+        const attributesToSend = attributes?.length ? attributes : Object.keys(model.rawAttributes);
+        const queryWithSearchTerm = formatSearchTerm(searchTerm, attributesToSend, model.rawAttributes);
+        formattedQuery = !formattedQuery || Object.keys(formattedQuery).length === 0 ? queryWithSearchTerm : {
+            $and: [
+                formattedQuery,
+                queryWithSearchTerm,
+            ],
+        };
+    }
+    return {
+        query: formattedQuery,
+        order: filteredFormattedOrder,
+        page: formattedPage,
+        perPage: formattedPerPage,
+        include: formattedInclude,
+        scopes: [...queryScopes, ...orderScopes],
+        ...(formattedAttribute && { attributes: formattedAttribute }),
+        ...(Object.keys(externalQueryValues).length > 0 && { externalQueryValues }),
+    };
+};
+exports.default = formatPayload;

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

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

package/lib/formatter/index.test.js

@@ -0,0 +1,267 @@
+"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 } = (0, _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 } = (0, _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 } = (0, _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 } = (0, _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 } = (0, _1.default)({
+                order: ['startTime', '-endTime'],
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime', 'DESC'], ['id']]));
+        });
+        it('simple check asc', () => {
+            const { order } = (0, _1.default)({
+                order: ['startTime', 'endTime'],
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime'], ['id']]));
+        });
+        it('by included model', () => {
+            const { order } = (0, _1.default)({
+                order: ['status.name'],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+                },
+                associations: {
+                    status: {},
+                },
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name'], ['id']]));
+        });
+        it('by included model descending', () => {
+            const { order } = (0, _1.default)({
+                order: ['-status.name'],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+                },
+                associations: {
+                    status: {},
+                },
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name', 'DESC'], ['id']]));
+        });
+        it('by json field', () => {
+            const { order } = (0, _1.default)({
+                order: ['status.name'],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', json: '',
+                },
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name'], ['id']]));
+        });
+        it('by json field descending', () => {
+            const { order } = (0, _1.default)({
+                order: ['-status.name'],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', json: '',
+                },
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name', 'DESC'], ['id']]));
+        });
+        it('by literal field ascending', () => {
+            const literalAttribute = { attribute: 'genericField', literal: [{ 0: (e) => `${e}0` }] };
+            const { order, attributes } = (0, _1.default)({
+                order: [literalAttribute.attribute],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+                },
+            }, {
+                literalAttributes: [literalAttribute],
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([[`${literalAttribute.attribute} ASC`], ['id']]));
+            expect(JSON.stringify(attributes))
+                .toBe(JSON.stringify({ include: [literalAttribute.literal] }));
+        });
+        it('by literal field descending', () => {
+            const literalAttribute = { attribute: 'genericField', literal: ['void', 'field'] };
+            const { order, attributes } = (0, _1.default)({
+                order: [`-${literalAttribute.attribute}`, 'currencySymbol'],
+                attributes: ['endTime'],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+                },
+            }, {
+                literalAttributes: [literalAttribute],
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([[`${literalAttribute.attribute} DESC`], ['currencySymbol'], ['id']]));
+            expect(JSON.stringify(attributes))
+                .toBe(JSON.stringify([[literalAttribute.literal[0], literalAttribute.literal[1]], 'endTime']));
+        });
+        it('by literal field - not found', () => {
+            const literalAttribute = { attribute: 'genericField', literal: 'void' };
+            const { order, attributes } = (0, _1.default)({
+                order: [`-O${literalAttribute.attribute}`],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+                },
+            }, {
+                literalAttributes: [literalAttribute],
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([[`O${literalAttribute.attribute}`, 'DESC'], ['id']]));
+            expect(JSON.stringify(attributes)).toBe(JSON.stringify({ include: [] }));
+        });
+    });
+    describe('include formatting', () => {
+        it('include required should be true', () => {
+            const { include } = (0, _1.default)({
+                order: [],
+                include: [{
+                        model: 'status',
+                    }],
+            }, {
+                associations: {
+                    status: {},
+                },
+            });
+            expect(include[0].required).toBe(true);
+        });
+        it('include required should be false', () => {
+            const { include } = (0, _1.default)({
+                order: [],
+                include: [{
+                        model: 'status',
+                        required: false,
+                    }],
+            }, {
+                associations: {
+                    status: {},
+                },
+            });
+            expect(include[0].required).toBe(false);
+        });
+    });
+});

package/lib/index.d.ts

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

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,17 @@
+import { FormatPayloadOptions } from '../formatter';
+type literal = any;
+type LiteralQuery = (literal | string)[] | literal;
+export type LiteralAttribute = {
+    attribute: string;
+    literal: LiteralQuery;
+};
+export type MiddlewareValidationOption = {
+    literalAttributes?: LiteralAttribute[];
+    enrichmentAttributes?: string[];
+    additionalAllowedAttributes?: string[];
+};
+export declare const newQueryValidationMiddleware: (inner?: string) => (model: any, options?: MiddlewareValidationOption) => (req: any, res: any, next: any) => Promise<void>;
+export declare const newQueryFormatMiddleware: (inner?: string) => (model: any, options?: FormatPayloadOptions) => (req: any, res: any, next: any) => Promise<void>;
+export declare const queryValidationMiddleware: (model: any, options?: MiddlewareValidationOption) => (req: any, res: any, next: any) => Promise<void>;
+export declare const queryFormatMiddleware: (model: any, options?: FormatPayloadOptions) => (req: any, res: any, next: any) => Promise<void>;
+export {};

package/lib/middleware/index.js

@@ -0,0 +1,92 @@
+"use strict";
+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 logger_1 = __importDefault(require("@autofleet/logger"));
+const errors_1 = require("@autofleet/errors");
+const joi_1 = __importDefault(require("joi"));
+const formatter_1 = __importDefault(require("../formatter"));
+const validations_1 = require("../validations");
+const { object, string, number, any, array, alternatives, } = joi_1.default.types();
+const logger = (0, logger_1.default)();
+const querySchema = object.keys({
+    query: object,
+    attributes: array.items(string),
+    order: array.items(string),
+    page: number,
+    perPage: number,
+    include: array.items(any),
+    searchTerm: string,
+    group: array.items(string),
+    enrichments: alternatives.try(array.items(string), object.pattern(string, { exclude: array.items(string) })),
+});
+const newQueryValidationMiddleware = (inner = 'body') => (model, options = {}) => async (req, res, next) => {
+    const { query, attributes, order, page, perPage, include, group, enrichments, } = req[inner];
+    try {
+        const result = querySchema.validate(req[inner]);
+        if (result.error) {
+            throw new errors_1.BadRequest([result.error], null);
+        }
+        (0, validations_1.validatePayload)({
+            query,
+            attributes,
+            order,
+            page,
+            perPage,
+            include,
+            enrichments,
+            group,
+        }, model, options);
+        return next();
+    }
+    catch (error) {
+        return (0, errors_1.handleError)(error, res, {
+            logger,
+            message: 'error in query middleware',
+            payload: {
+                error,
+                query,
+                attributes,
+                order,
+            },
+        });
+    }
+};
+exports.newQueryValidationMiddleware = newQueryValidationMiddleware;
+const newQueryFormatMiddleware = (inner = 'body') => (model, options = {}) => async (req, res, next) => {
+    const { order, page, perPage, include, query, attributes, searchTerm, } = req[inner];
+    const { query: formattedQuery, externalQueryValues, order: formattedOrder, page: formattedPage, perPage: formattedPerPage, include: formattedInclude, scopes: formattedScopes, attributes: formattedAttribute, } = (0, formatter_1.default)({
+        query,
+        order,
+        page,
+        perPage,
+        include,
+        attributes,
+        searchTerm,
+    }, model, options);
+    req[inner].query = formattedQuery;
+    req[inner].externalQueryValues = externalQueryValues;
+    req[inner].order = formattedOrder;
+    req[inner].attributes = formattedAttribute;
+    req[inner].page = formattedPage;
+    req[inner].perPage = formattedPerPage;
+    req[inner].include = formattedInclude;
+    req[inner].scopes = formattedScopes;
+    if (options.includeRawPayload) {
+        req[inner].rawPayload = {
+            order,
+            page,
+            perPage,
+            include,
+            query,
+            attributes,
+            searchTerm,
+        };
+    }
+    return next();
+};
+exports.newQueryFormatMiddleware = newQueryFormatMiddleware;
+exports.queryValidationMiddleware = (0, exports.newQueryValidationMiddleware)();
+exports.queryFormatMiddleware = (0, exports.newQueryFormatMiddleware)();

package/lib/operators/index.d.ts

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

@@ -0,0 +1,50 @@
+"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

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

@@ -0,0 +1,43 @@
+"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

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

@@ -0,0 +1,123 @@
+"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

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

package/lib/validations/index.test.js

@@ -0,0 +1,219 @@
+"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);
+            }
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sheilta",
-  "version": "1.4.8-beta-1",
+  "version": "1.4.8-beta-3",
   "description": "Middlewares for validation and parsing of endpoints meant for data querying.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",