@autofleet/sheilta 1.4.8-beta-5 → 2.0.0

package/lib/formatter/index.d.ts

@@ -1,55 +0,0 @@
-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[] | number | number[] | boolean | boolean[];
-/**
- * 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, ConditionValue>;
-/**
- * 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, ConditionValue>;
-            scopeValue: any;
-        })[];
-    })[];
-};
-export default formatPayload;

package/lib/formatter/index.js

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

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

package/lib/formatter/index.test.js

@@ -1,267 +0,0 @@
-"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/middleware/index.d.ts

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

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