@autofleet/sheilta 1.3.0 → 1.3.2-1

package/lib/formatter/index.js

@@ -39,7 +39,8 @@ const formatQuery = (query, associationModels) => {
             if (!formattedScopeMap.has(CUSTOM_FIELDS_FILTER_SCOPE)) {
                 formattedScopeMap.set(CUSTOM_FIELDS_FILTER_SCOPE, {});
             }
-            formattedScopeMap.get(CUSTOM_FIELDS_FILTER_SCOPE)[queryItemKey] = queryItemValue;
+            const scopeKey = queryItemKey.split(CUSTOM_FIELDS_QUERY_PREFIX)[1];
+            formattedScopeMap.get(CUSTOM_FIELDS_FILTER_SCOPE)[scopeKey] = queryItemValue;
             return;
         }
         const key = utils_1.isAttributeByAssociation(queryItemKey, associationModels) ?

package/lib/index.d.ts

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

package/lib/interface.d.ts

@@ -0,0 +1,3 @@
+export declare type MiddlewareValidationOption = {
+    literalAttribute?: string[];
+};

package/lib/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/middleware/index.d.ts

@@ -1,5 +1,6 @@
 import { FormatPayloadOptions } from '../formatter';
-export declare const newQueryValidationMiddleware: (inner?: string) => (model: any) => (req: any, res: any, next: any) => Promise<void>;
+import { MiddlewareValidationOption } from '../interface';
+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) => (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>;

package/lib/middleware/index.js

@@ -26,7 +26,7 @@ const querySchema = joi_1.object({
     include: joi_1.array().items(joi_1.any()),
     searchTerm: joi_1.string(),
 });
-exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, next) => __awaiter(void 0, void 0, void 0, function* () {
+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]);
@@ -40,7 +40,7 @@ exports.newQueryValidationMiddleware = (inner = 'body') => model => (req, res, n
             page,
             perPage,
             include,
-        }, model);
+        }, model, options);
         return next();
     }
     catch (error) {

package/lib/validations/index.d.ts

@@ -1,3 +1,4 @@
+import { MiddlewareValidationOption } from '../interface';
 export declare const validatePayload: ({ query, order, attributes, include, page, perPage, }: {
     query?: {};
     order?: any[];
@@ -5,4 +6,4 @@ export declare const validatePayload: ({ query, order, attributes, include, page
     include?: any[];
     page?: number;
     perPage?: number;
-}, model?: any) => boolean;
+}, 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;
     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,10 +21,11 @@ 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 = (_a = options === null || options === void 0 ? void 0 : options.literalAttribute) === null || _a === void 0 ? void 0 : _a.includes(orderStringWithoutDesc);
     if (!isOrderAssociation && formattedOrderString.includes(utils_1.ASSOCIATION_PREFIX)) {
         [formattedOrderString] = formattedOrderString.split(utils_1.ASSOCIATION_PREFIX);
     }
-    if (!(rawAttributes.includes(formattedOrderString) || isOrderAssociation)) {
+    if (!(rawAttributes.includes(formattedOrderString) || isOrderAssociation || isLiteralAttribute)) {
         utils_1.throwBadRequestError(`${currentOrder} is invalid`);
     }
 };
@@ -32,8 +34,8 @@ 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));
@@ -91,7 +93,7 @@ const validateIncludePayload = (include, associations) => {
         }
     });
 };
-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, }, 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) {
@@ -101,7 +103,7 @@ 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 && typeof include === 'object') {
         validateIncludePayload(include, model === null || model === void 0 ? void 0 : model.associations);

package/lib/validations/index.test.js

@@ -180,5 +180,28 @@ describe('validations test', () => {
                 expect(error.statusCode).toBe(400);
             }
         });
+        it('try order by literal field that exist', () => {
+            const literalAttribute = 'genericField';
+            const payload = _1.validatePayload({ order: [literalAttribute] }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
+                },
+            }, {
+                literalAttribute: [literalAttribute],
+            });
+            expect(payload).toBe(true);
+        });
+        it('try order by literal field that doesnt exist', () => {
+            try {
+                _1.validatePayload({ order: ['here'] }, {
+                    rawAttributes: {
+                        startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
+                    },
+                }, { literalAttribute: ['not'] });
+            }
+            catch (error) {
+                expect(error.statusCode).toBe(400);
+            }
+        });
     });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sheilta",
-  "version": "1.3.0",
+  "version": "1.3.2-1",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -48,4 +48,4 @@
   "files": [
     "lib/**/*"
   ]
-}
+}