@autofleet/sheilta 1.3.2-1 → 1.3.2-4

package/lib/formatter/index.d.ts

@@ -1,7 +1,9 @@
+import type { Attribute } from '../interface';
 declare type OrderItem = string | [string, string];
 declare type SequelizeOrder = string | OrderItem[];
 export declare type FormatPayloadOptions = {
     includeRawPayload?: boolean;
+    literalAttributes?: Attribute[];
 };
 declare const formatPayload: ({ order, page, perPage, include, query, attributes, searchTerm, }: {
     order?: any[];
@@ -9,9 +11,9 @@ declare const formatPayload: ({ order, page, perPage, include, query, attributes
     perPage?: number;
     include?: any[];
     query?: {};
-    attributes?: any;
+    attributes?: any[];
     searchTerm?: any;
-}, model?: any) => {
+}, model?: any, options?: any) => {
     query: {};
     order: SequelizeOrder[];
     page: any;
@@ -20,5 +22,6 @@ declare const formatPayload: ({ order, page, perPage, include, query, attributes
     scopes: (string | {
         method: any[];
     })[];
+    attributes: any[];
 };
 export default formatPayload;

package/lib/formatter/index.js

@@ -8,8 +8,18 @@ const common_types_1 = require("@autofleet/common-types");
 const utils_1 = require("../utils");
 const DEFAULT_ORDER = 'id';
 const DESCENDING_KEY = 'DESC';
+const ASCENDING_KEY = 'ASC';
 const CUSTOM_FIELDS_QUERY_PREFIX = 'customFields.';
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+const getAttributeFromOrder = (order, literalAttributes) => {
+    const [formattedOrder, attributes] = order.reduce((acc, o) => {
+        const [item, itemOrder = ASCENDING_KEY] = Array.isArray(o) ? o : [o];
+        const found = literalAttributes === null || literalAttributes === void 0 ? void 0 : literalAttributes.find(obj => obj.attribute === item);
+        (found ? acc[1] : acc[0]).push(found ? `${found.literal} ${itemOrder}` : o);
+        return acc;
+    }, [[], []]);
+    return [formattedOrder, attributes];
+};
 const formatOrder = ({ order, associationModels = [], }) => order.map((o) => {
     const formattedOrder = [utils_1.extractAttributeNameFromOrder(o, associationModels)];
     const isOrderDescOrder = utils_1.isOrderDesc(o);
@@ -68,12 +78,14 @@ 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 = [], searchTerm = null, }, model, options) => {
     const associationModels = Object.keys((model === null || model === void 0 ? void 0 : model.associations) || {});
     const formattedOrder = formatOrder({
         order: [...order, DEFAULT_ORDER],
         associationModels,
     });
+    const [filteredFormattedOrder, filteredLiteralAttributes] = getAttributeFromOrder(formattedOrder, options === null || options === void 0 ? void 0 : options.literalAttributes);
+    const formattedAttribute = [...filteredLiteralAttributes, ...attributes];
     const formattedInclude = formatInclude(include, model === null || model === void 0 ? void 0 : model.associations);
     const formattedPage = formatPage(page);
     const formattedPerPage = formatPerPage(perPage);
@@ -91,11 +103,12 @@ const formatPayload = ({ order = [], page = utils_1.PAGE_DEFAULT, perPage = util
     }
     return {
         query: formattedQuery,
-        order: formattedOrder,
+        order: filteredFormattedOrder,
         page: formattedPage,
         perPage: formattedPerPage,
         include: formattedInclude,
         scopes: result.formattedScopes,
+        attributes: formattedAttribute,
     };
 };
 exports.default = formatPayload;

package/lib/formatter/index.test.js

@@ -189,6 +189,48 @@ describe('formatting test', () => {
             });
             expect(JSON.stringify(order)).toBe(JSON.stringify([['status.name', 'DESC'], ['id']]));
         });
+        it('by literal field ascending', () => {
+            const literalAttribute = { attribute: 'genericField', literal: 'void' };
+            const { order, attributes } = _1.default({
+                order: [literalAttribute.attribute],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+                },
+            }, {
+                literalAttributes: [literalAttribute],
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['id']]));
+            expect(JSON.stringify(attributes)).toBe(JSON.stringify([`${literalAttribute.literal} ASC`]));
+        });
+        it('by literal field descending', () => {
+            const literalAttribute = { attribute: 'genericField', literal: 'void' };
+            const { order, attributes } = _1.default({
+                order: [`-${literalAttribute.attribute}`, 'currencySymbol'],
+            }, {
+                rawAttributes: {
+                    startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '',
+                },
+            }, {
+                literalAttributes: [literalAttribute],
+            });
+            expect(JSON.stringify(order)).toBe(JSON.stringify([['currencySymbol'], ['id']]));
+            expect(JSON.stringify(attributes)).toBe(JSON.stringify([`${literalAttribute.literal} DESC`]));
+        });
+        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([]));
+        });
     });
     describe('include formatting', () => {
         it('include required should be true', () => {

package/lib/interface.d.ts

@@ -1,3 +1,7 @@
+export declare type Attribute = {
+    attribute: string;
+    literal: any;
+};
 export declare type MiddlewareValidationOption = {
-    literalAttribute?: string[];
+    literalAttributes?: Attribute[];
 };

package/lib/middleware/index.js

@@ -57,7 +57,7 @@ exports.newQueryValidationMiddleware = (inner = 'body') => (model, options = {})
 });
 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, scopes: formattedScopes, } = formatter_1.default({
+    const { query: formattedQuery, order: formattedOrder, page: formattedPage, perPage: formattedPerPage, include: formattedInclude, scopes: formattedScopes, attributes: formattedAttribute, } = formatter_1.default({
         query,
         order,
         page,
@@ -65,9 +65,10 @@ exports.newQueryFormatMiddleware = (inner = 'body') => (model, options = {}) =>
         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;

package/lib/validations/index.js

@@ -12,7 +12,7 @@ const validateQueryAttribute = (attribute, modelAttributes = [], associationMode
     .includes(attribute.includes(utils_1.ASSOCIATION_PREFIX)
     ? attribute.split(utils_1.ASSOCIATION_PREFIX)[0] : attribute);
 const validateSingleOrder = (currentOrder, rawAttributes, associationModels, options = {}) => {
-    var _a;
+    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`);
@@ -21,12 +21,12 @@ const validateSingleOrder = (currentOrder, rawAttributes, associationModels, opt
         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);
+    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 || isLiteralAttribute)) {
-        utils_1.throwBadRequestError(`${currentOrder} is invalid`);
+        utils_1.throwBadRequestError(`${currentOrder} is invalid isLiteralAttribute: ${isLiteralAttribute}`);
     }
 };
 const validateSingleAttribute = (currentAttribute, rawAttributes) => {

package/lib/validations/index.test.js

@@ -181,23 +181,35 @@ describe('validations test', () => {
             }
         });
         it('try order by literal field that exist', () => {
-            const literalAttribute = 'genericField';
-            const payload = _1.validatePayload({ order: [literalAttribute] }, {
+            const literalAttribute = { attribute: 'genericField', literal: 'void' };
+            const payload = _1.validatePayload({ order: [literalAttribute.attribute] }, {
                 rawAttributes: {
                     startTime: '', endTime: '', currencySymbol: '', currencyCode: '', startStationId: '', status: '',
                 },
             }, {
-                literalAttribute: [literalAttribute],
+                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: '',
                     },
-                }, { literalAttribute: ['not'] });
+                }, { literalAttributes: [literalAttribute] });
             }
             catch (error) {
                 expect(error.statusCode).toBe(400);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sheilta",
-  "version": "1.3.2-1",
+  "version": "1.3.2-4",
   "description": "manage cache",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",