@autofleet/sheilta 1.0.0-aaron-error-fix → 1.0.0-beta-test-2

package/lib/formatter/index.d.ts

@@ -1,18 +1,48 @@
+import type { LiteralAttribute } from '../middleware';
 declare type OrderItem = string | [string, string];
 declare type SequelizeOrder = string | OrderItem[];
+export declare type FormatPayloadOptions = {
+    includeRawPayload?: boolean;
+    literalAttributes?: LiteralAttribute[];
+    DBFormatter?: any;
+    skipSearchTermFormat?: boolean;
+};
+declare type ConditionWithOperator = {
+    operator: string;
+    value: string;
+};
+export declare 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;
+    order?: any[];
     page?: number;
     perPage?: number;
     include?: any[];
     query?: {};
     attributes?: any;
     searchTerm?: any;
-}, model?: any) => {
+}, model?: any, options?: any) => {
+    attributes: any[] | {
+        include: any[];
+    };
     query: {};
     order: SequelizeOrder[];
     page: any;
     perPage: any;
     include: any;
+    scopes: any[];
 };
 export default formatPayload;

package/lib/formatter/index.js

@@ -3,11 +3,114 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateOrderReplacements = exports.generateFilterReplacements = void 0;
 const lodash_1 = __importDefault(require("lodash"));
+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 formatOrder = ({ order = [], associationModels = [], }) => (order.length === 0 ? undefined :
-    order.map((o) => {
+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 === null || literalAttributes === void 0 ? void 0 : 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.
+ */
+exports.generateFilterReplacements = (conditions) => {
+    const replacements = {};
+    Object.entries(conditions).forEach(([key, condition]) => {
+        const replacementKey = 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 = utils_1.generateRandomString();
+                replacements[valueKey] = typeof value === 'string' ? value : value.value;
+            });
+        }
+        else if (typeof condition === 'string' || typeof condition === 'number') {
+            const conditionKey = utils_1.generateRandomString();
+            replacements[conditionKey] = condition;
+        }
+        else if (condition === null || condition === void 0 ? void 0 : condition.operator) {
+            const operatorKey = utils_1.generateRandomString();
+            replacements[operatorKey] = condition.value;
+        }
+    });
+    return replacements;
+};
+/**
+ * Generates replacements for the given order array.
+ *
+ * @param order - The order array to generate replacements for.
+ * @returns The replacements object.
+ */
+exports.generateOrderReplacements = (order) => {
+    const replacementMap = {};
+    order.forEach((o) => {
+        if (o.startsWith(CUSTOM_FIELDS_QUERY_PREFIX)) {
+            const rand = 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 = utils_1.generateRandomString();
+            // eslint-disable-next-line prefer-destructuring
+            replacementMap[rand] = o.substring(1).split(CUSTOM_FIELDS_QUERY_PREFIX)[1];
+        }
+    });
+    return replacementMap;
+};
+/**
+ * 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) => (Object.assign(Object.assign({}, exports.generateOrderReplacements(order)), 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] = (utils_1.isOrderDesc(o) ?
+                DESCENDING_KEY :
+                ASCENDING_KEY);
+            return;
+        }
         const formattedOrder = [utils_1.extractAttributeNameFromOrder(o, associationModels)];
         const isOrderDescOrder = utils_1.isOrderDesc(o);
         const isOrderAssociation = utils_1.isAttributeByAssociation(isOrderDescOrder
@@ -19,17 +122,71 @@ const formatOrder = ({ order = [], associationModels = [], }) => (order.length =
         if (isOrderDescOrder) {
             formattedOrder.push(DESCENDING_KEY);
         }
-        return formattedOrder;
-    }));
+        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 => (Object.assign(Object.assign({}, i), { association: associationsMap[i.association || i.model], required: i.required !== 'false' })));
+    let formattedInclude = include.map((i) => {
+        var _a;
+        const includedAssociation = associationsMap[typeof i === 'string' ? i : (i.association || i.model)];
+        return Object.assign(Object.assign(Object.assign({}, i), { association: includedAssociation, required: i.required !== false }), (i.include && {
+            include: formatInclude(i.include, (_a = includedAssociation === null || includedAssociation === void 0 ? void 0 : includedAssociation.target) === null || _a === void 0 ? void 0 : _a.associations),
+        }));
+    });
     formattedInclude = formattedInclude.map(i => lodash_1.default.omit(i, ['model']));
     return formattedInclude;
 };
-const formatQuery = (query, associationModels) => Object.keys(query).reduce((acc, queryItemKey) => (Object.assign(Object.assign({}, acc), { [utils_1.isAttributeByAssociation(queryItemKey, associationModels)
-        ? utils_1.wrapAttributeWithOperator(queryItemKey) : queryItemKey]: query[queryItemKey] })), {});
+const formatQuery = (query, associationModels, replacementsMap) => {
+    const formattedQuery = {};
+    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;
+        }
+        const key = utils_1.isAttributeByAssociation(queryItemKey, associationModels)
+            ? 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,
+        formattedScopes,
+    };
+};
 const formatSearchTerm = (searchTerm, attributesToSend, rawAttributes) => ({
     $and: searchTerm.split(' ').map(term => ({
         $or: attributesToSend.filter(attrKey => rawAttributes[attrKey].type.key === 'STRING').map(attr => ({
@@ -39,17 +196,24 @@ const formatSearchTerm = (searchTerm, attributesToSend, rawAttributes) => ({
         })),
     })),
 });
-const formatPayload = ({ order, page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, include = [], query = {}, attributes = null, searchTerm = null, }, model) => {
+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 === null || model === void 0 ? void 0 : model.associations) || {});
-    const formattedOrder = formatOrder({
-        order,
+    const { formattedOrders, orderScopes } = formatOrder({
+        order: [...order, DEFAULT_ORDER],
         associationModels,
+        replacementsMap,
     });
+    const [filteredFormattedOrder, filteredLiteralAttributes] = getAttributeFromOrder(formattedOrders, options);
+    const allAttributes = [...filteredLiteralAttributes, ...(attributes || [])];
+    const formattedAttribute = (attributes === null || attributes === void 0 ? void 0 : attributes.length) ? allAttributes : { include: allAttributes };
     const formattedInclude = formatInclude(include, model === null || model === void 0 ? void 0 : model.associations);
     const formattedPage = formatPage(page);
     const formattedPerPage = formatPerPage(perPage);
-    let formattedQuery = formatQuery(query, associationModels);
-    if (searchTerm) {
+    const result = formatQuery(query, associationModels, replacementsMap);
+    const queryScopes = result.formattedScopes;
+    let { formattedQuery } = result;
+    if (searchTerm && !(options === null || options === void 0 ? void 0 : options.skipSearchTermFormat)) {
         const attributesToSend = (attributes === null || attributes === void 0 ? void 0 : attributes.length) ? attributes : Object.keys(model.rawAttributes);
         const queryWithSearchTerm = formatSearchTerm(searchTerm, attributesToSend, model.rawAttributes);
         formattedQuery = lodash_1.default.isEmpty(formattedQuery) ? queryWithSearchTerm : {
@@ -59,12 +223,6 @@ const formatPayload = ({ order, page = utils_1.PAGE_DEFAULT, perPage = utils_1.P
             ],
         };
     }
-    return {
-        query: formattedQuery,
-        order: formattedOrder,
-        page: formattedPage,
-        perPage: formattedPerPage,
-        include: formattedInclude,
-    };
+    return Object.assign({ query: formattedQuery, order: filteredFormattedOrder, page: formattedPage, perPage: formattedPerPage, include: formattedInclude, scopes: [...queryScopes, ...orderScopes] }, (formattedAttribute && { attributes: formattedAttribute }));
 };
 exports.default = formatPayload;

package/lib/formatter/index.test.js

@@ -135,13 +135,13 @@ describe('formatting test', () => {
             const { order } = _1.default({
                 order: ['startTime', '-endTime'],
             });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime', 'DESC']]));
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime', 'DESC'], ['id']]));
         });
         it('simple check asc', () => {
             const { order } = _1.default({
                 order: ['startTime', 'endTime'],
             });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime']]));
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['startTime'], ['endTime'], ['id']]));
         });
         it('by included model', () => {
             const { order } = _1.default({
@@ -154,7 +154,7 @@ describe('formatting test', () => {
                     status: {},
                 },
             });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name']]));
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name'], ['id']]));
         });
         it('by included model descending', () => {
             const { order } = _1.default({
@@ -167,7 +167,7 @@ describe('formatting test', () => {
                     status: {},
                 },
             });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name', 'DESC']]));
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['status', 'name', 'DESC'], ['id']]));
         });
         it('by json field', () => {
             const { order } = _1.default({
@@ -177,7 +177,7 @@ describe('formatting test', () => {
                     startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', json: '',
                 },
             });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name']]));
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name'], ['id']]));
         });
         it('by json field descending', () => {
             const { order } = _1.default({
@@ -187,7 +187,81 @@ describe('formatting test', () => {
                     startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', json: '',
                 },
             });
-            expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name', 'DESC']]));
+            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 } = _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 } = _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 } = _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 } = _1.default({
+                order: [],
+                include: [{
+                        model: 'status',
+                    }],
+            }, {
+                associations: {
+                    status: {},
+                },
+            });
+            expect(include[0].required).toBe(true);
+        });
+        it('include required should be false', () => {
+            const { include } = _1.default({
+                order: [],
+                include: [{
+                        model: 'status',
+                        required: false,
+                    }],
+            }, {
+                associations: {
+                    status: {},
+                },
+            });
+            expect(include[0].required).toBe(false);
         });
     });
 });

package/lib/index.d.ts

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

package/lib/middleware/index.d.ts

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

@@ -14,11 +14,26 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryFormatMiddleware = exports.queryValidationMiddleware = exports.newQueryFormatMiddleware = exports.newQueryValidationMiddleware = void 0;
 const errors_1 = require("@autofleet/errors");
+const joi_1 = require("joi");
 const formatter_1 = __importDefault(require("../formatter"));
 const validations_1 = require("../validations");
-exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+const querySchema = joi_1.object({
+    query: joi_1.object(),
+    attributes: joi_1.array().items(joi_1.string()),
+    order: joi_1.array().items(joi_1.string()),
+    page: joi_1.number(),
+    perPage: joi_1.number(),
+    include: joi_1.array().items(joi_1.any()),
+    searchTerm: joi_1.string(),
+    enrichmentAttributes: joi_1.array().items(joi_1.string()),
+});
+exports.newQueryValidationMiddleware = (inner = 'body') => (model, options = {}) => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     const { query, attributes, order, page, perPage, include, } = req[inner];
     try {
+        const result = querySchema.validate(req[inner]);
+        if (result.error) {
+            throw new errors_1.BadRequest([result.error], null);
+        }
         validations_1.validatePayload({
             query,
             attributes,
@@ -26,7 +41,7 @@ exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, n
             page,
             perPage,
             include,
-        }, model);
+        }, model, options);
         return next();
     }
     catch (error) {
@@ -41,9 +56,9 @@ exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, n
         });
     }
 });
-exports.newQueryFormatMiddleware = (inner = 'body') => model => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+exports.newQueryFormatMiddleware = (inner = 'body') => (model, options = {}) => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
     const { order, page, perPage, include, query, attributes, searchTerm, } = req[inner];
-    const { query: formattedQuery, order: formattedOrder, page: formattedPage, perPage: formattedPerPage, include: formattedInclude, } = formatter_1.default({
+    const { query: formattedQuery, order: formattedOrder, page: formattedPage, perPage: formattedPerPage, include: formattedInclude, scopes: formattedScopes, attributes: formattedAttribute, } = formatter_1.default({
         query,
         order,
         page,
@@ -51,12 +66,25 @@ exports.newQueryFormatMiddleware = (inner = 'body') => model => (req, res, next)
         include,
         attributes,
         searchTerm,
-    }, model);
+    }, model, options);
     req[inner].query = formattedQuery;
     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.queryValidationMiddleware = exports.newQueryValidationMiddleware();

package/lib/operators/index.d.ts

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatOperators = exports.OPERATOR_PREFIX = exports.OPERATORS = void 0;
+exports.formatOperators = exports.OPERATORS_TO_SQL = exports.OPERATOR_PREFIX = exports.OPERATORS = void 0;
 exports.OPERATORS = [
     'eq',
     'ne',
@@ -22,6 +22,23 @@ exports.OPERATORS = [
     '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',
+};
 exports.formatOperators = (Sequelize) => {
     const { Op } = Sequelize;
     return exports.OPERATORS.reduce((map, o) => {

package/lib/utils.d.ts

@@ -11,3 +11,4 @@ export declare const extractAttributeNameFromOrder: (order: any, associationMode
 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,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractAssociatedAttributeNameFromOrder = exports.throwBadRequestError = exports.isOrderDesc = exports.extractAttributeNameFromOrder = exports.isAttributeByAssociation = exports.wrapAttributeWithOperator = exports.PAGE_MIN = exports.PER_PAGE_MIN_LIMIT = exports.PER_PAGE_MAX_LIMIT = exports.PAGE_DEFAULT = exports.PER_PAGE_DEFAULT = exports.ASSOCIATION_PREFIX = exports.ORDER_PREFIX = void 0;
+exports.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;
@@ -29,3 +30,7 @@ exports.throwBadRequestError = (message) => {
     throw new errors_1.BadRequest([{ message }], null);
 };
 exports.extractAssociatedAttributeNameFromOrder = (order) => order.split(exports.ASSOCIATION_PREFIX)[1];
+exports.generateRandomString = (length = 5) => {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    return Array.from({ length }, () => characters.charAt(randomInt(characters.length))).join('');
+};

package/lib/validations/index.d.ts

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

package/lib/validations/index.js

@@ -11,7 +11,8 @@ const validateOperator = (operator) => operators_1.OPERATORS.includes(operator.s
 const validateQueryAttribute = (attribute, modelAttributes = [], associationModels = []) => [...modelAttributes, ...associationModels]
     .includes(attribute.includes(utils_1.ASSOCIATION_PREFIX)
     ? attribute.split(utils_1.ASSOCIATION_PREFIX)[0] : attribute);
-const validateSingleOrder = (currentOrder, rawAttributes, associationModels) => {
+const validateSingleOrder = (currentOrder, rawAttributes, associationModels, options = {}) => {
+    var _a, _b;
     const isOrderDescOrder = utils_1.isOrderDesc(currentOrder);
     if (isOrderDescOrder && currentOrder[0] !== utils_1.ORDER_PREFIX) {
         utils_1.throwBadRequestError(`${utils_1.ORDER_PREFIX} must be only at the beginning of the word`);
@@ -20,11 +21,12 @@ const validateSingleOrder = (currentOrder, rawAttributes, associationModels) =>
         currentOrder.split(utils_1.ORDER_PREFIX)[1] : currentOrder;
     const isOrderAssociation = utils_1.isAttributeByAssociation(orderStringWithoutDesc, associationModels);
     let formattedOrderString = utils_1.extractAttributeNameFromOrder(currentOrder, associationModels);
+    const isLiteralAttribute = (_b = (_a = options === null || options === void 0 ? void 0 : options.literalAttributes) === null || _a === void 0 ? void 0 : _a.map(la => la.attribute)) === null || _b === void 0 ? void 0 : _b.includes(orderStringWithoutDesc);
     if (!isOrderAssociation && formattedOrderString.includes(utils_1.ASSOCIATION_PREFIX)) {
         [formattedOrderString] = formattedOrderString.split(utils_1.ASSOCIATION_PREFIX);
     }
-    if (!(rawAttributes.includes(formattedOrderString) || isOrderAssociation)) {
-        utils_1.throwBadRequestError(`${currentOrder} is invalid`);
+    if (!(rawAttributes.includes(formattedOrderString) || isOrderAssociation || isLiteralAttribute)) {
+        utils_1.throwBadRequestError(`${currentOrder} is invalid. isLiteralAttribute: ${isLiteralAttribute}`);
     }
 };
 const validateSingleAttribute = (currentAttribute, rawAttributes) => {
@@ -32,17 +34,27 @@ const validateSingleAttribute = (currentAttribute, rawAttributes) => {
         utils_1.throwBadRequestError(`${currentAttribute} is invalid`);
     }
 };
-const validateOrderAttributes = (order, rawAttributes, associationModels = []) => {
-    order.map(o => validateSingleOrder(o, rawAttributes, associationModels));
+const validateOrderAttributes = (order, rawAttributes, associationModels = [], options = {}) => {
+    order.map(o => validateSingleOrder(o, rawAttributes, associationModels, options));
 };
 const validateAttributes = (attributes, rawAttributes) => {
     attributes.map(a => validateSingleAttribute(a, rawAttributes));
 };
+const validateEnrichments = (enrichments, options) => {
+    if (!(enrichments === null || enrichments === void 0 ? void 0 : enrichments.length)) {
+        return;
+    }
+    const invalidEnrichment = enrichments
+        .find(enrichment => { var _a; return !((_a = options === null || options === void 0 ? void 0 : options.enrichmentAttributes) === null || _a === void 0 ? void 0 : _a.includes(enrichment)); });
+    if (invalidEnrichment) {
+        utils_1.throwBadRequestError(`enrichment attribute ${enrichments} is invalid`);
+    }
+};
 const validateQueryPayload = (query, rawAttributes, associationModels = []) => {
     // eslint-disable-next-line array-callback-return
     Object.keys(query).map((key) => {
         const value = query[key];
-        if (lodash_1.default.isArray(value)) {
+        if (Array.isArray(value)) {
             if (lodash_1.default.isObject(value[0])) {
                 value.map(v => validateQueryPayload(v, rawAttributes, associationModels));
             }
@@ -76,21 +88,22 @@ const validateIncludePayload = (include, associations) => {
             utils_1.throwBadRequestError('model not found in associations');
         }
         const { rawAttributes } = target;
-        if (include.where) {
-            validateQueryPayload(i.where, rawAttributes);
+        const attributeKeys = Object.keys(rawAttributes);
+        if (i.where) {
+            validateQueryPayload(i.where, attributeKeys);
         }
-        if (include.order) {
-            validateOrderAttributes(i.order, rawAttributes);
+        if (i.order) {
+            validateOrderAttributes(i.order, attributeKeys);
         }
-        if (include.attributes) {
-            validateAttributes(i.attributes, rawAttributes);
+        if (i.attributes) {
+            validateAttributes(i.attributes, attributeKeys);
         }
-        if (!lodash_1.default.isNil(include.required) && !lodash_1.default.isBoolean(include.required)) {
+        if (!lodash_1.default.isNil(i.required) && !lodash_1.default.isBoolean(i.required)) {
             utils_1.throwBadRequestError('include.required must be a boolean');
         }
     });
 };
-exports.validatePayload = ({ query = {}, order = [], attributes = [], include = [], page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, }, model) => {
+exports.validatePayload = ({ query = {}, order = [], attributes = [], include = [], page = utils_1.PAGE_DEFAULT, perPage = utils_1.PER_PAGE_DEFAULT, enrichments = [], }, model, options = {}) => {
     const rawAttributes = Object.keys(model.rawAttributes);
     const associationModels = Object.keys((model === null || model === void 0 ? void 0 : model.associations) || {});
     if (!attributes || attributes.length === 0) {
@@ -100,11 +113,15 @@ exports.validatePayload = ({ query = {}, order = [], attributes = [], include =
     else {
         validateAttributes(attributes, rawAttributes);
     }
-    validateOrderAttributes(order, rawAttributes, associationModels);
+    validateOrderAttributes(order, rawAttributes, associationModels, options);
     validateQueryPayload(query, rawAttributes, associationModels);
-    if (include.length) {
+    validateEnrichments(enrichments, options);
+    if (include.length && typeof include === 'object') {
         validateIncludePayload(include, model === null || model === void 0 ? void 0 : model.associations);
     }
+    else if (include && typeof include !== 'object') {
+        utils_1.throwBadRequestError('include must be an array');
+    }
     validatePagination({
         page,
         perPage,

package/lib/validations/index.test.js

@@ -180,5 +180,40 @@ describe('validations test', () => {
                 expect(error.statusCode).toBe(400);
             }
         });
+        it('try order by literal field that exist', () => {
+            const literalAttribute = { attribute: 'genericField', literal: 'void' };
+            const payload = _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 = _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 {
+                _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.0.0-aaron-error-fix",
+  "version": "1.0.0-beta-test-2",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -10,7 +10,24 @@
     "coverage": "jest --coverage --forceExit --runInBand",
     "test": "jest --forceExit --runInBand",
     "test-auto": "jest --watch --runInBand",
-    "linter": "./node_modules/.bin/eslint src/**/*.ts"
+    "linter": "./node_modules/.bin/eslint src/**/*.ts",
+    "build-to-local-repo": "npm run build && cp -r lib/* ../$REPO/node_modules/$npm_package_name/lib",
+    "watch": "npm-watch build-to-local-repo"
+  },
+  "watch": {
+    "build-to-local-repo": {
+      "extensions": [
+        "js",
+        "jsx",
+        "ts",
+        "tsx",
+        "css"
+      ],
+      "patterns": [
+        "src"
+      ],
+      "quiet": false
+    }
   },
   "jest": {
     "setupTestFrameworkScriptFile": "jest-extended",
@@ -27,21 +44,24 @@
   },
   "homepage": "https://github.com/Autofleet/sheilta",
   "dependencies": {
+    "@autofleet/common-types": "^1.7.42",
     "@autofleet/errors": "^1.0.10",
-    "@types/node": "^14.14.20",
+    "joi": "^17.9.2",
     "lodash": "^4.17.21"
   },
   "devDependencies": {
-    "typescript": "^3.9.5",
+    "@types/jest": "^24.9.0",
+    "@types/node": "^16.11.68",
+    "@typescript-eslint/eslint-plugin": "^2.34.0",
+    "@typescript-eslint/parser": "^2.23.0",
     "eslint": "^6.8.0",
     "eslint-config-airbnb": "^16.1.0",
     "eslint-plugin-import": "^2.20.1",
-    "@typescript-eslint/eslint-plugin": "^2.34.0",
-    "@typescript-eslint/parser": "^2.23.0",
-    "typescript-eslint": "0.0.1-alpha.0",
-    "ts-jest": "^25.0.0",
     "jest": "^25.1.0",
-    "@types/jest": "^24.9.0"
+    "ts-jest": "^25.0.0",
+    "typescript": "^3.9.5",
+    "typescript-eslint": "0.0.1-alpha.0",
+    "npm-watch": "^0.13.0"
   },
   "files": [
     "lib/**/*"