@autofleet/sheilta 1.3.2-2 → 1.3.2-5

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[];
@@ -11,7 +13,20 @@ declare const formatPayload: ({ order, page, perPage, include, query, attributes
     query?: {};
     attributes?: any;
     searchTerm?: any;
-}, model?: any) => {
+}, model?: any, options?: any) => {
+    attributes: {
+        include: any[];
+    };
+    query: {};
+    order: SequelizeOrder[];
+    page: any;
+    perPage: any;
+    include: any;
+    scopes: (string | {
+        method: any[];
+    })[];
+} | {
+    attributes?: undefined;
     query: {};
     order: SequelizeOrder[];
     page: any;

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,15 @@ 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 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 allAttributes = [...filteredLiteralAttributes, ...(attributes || [])];
+    const formattedAttribute = allAttributes.length ? { include: allAttributes } : null;
     const formattedInclude = formatInclude(include, model === null || model === void 0 ? void 0 : model.associations);
     const formattedPage = formatPage(page);
     const formattedPerPage = formatPerPage(perPage);
@@ -89,13 +102,7 @@ const formatPayload = ({ order = [], page = utils_1.PAGE_DEFAULT, perPage = util
             ],
         };
     }
-    return {
-        query: formattedQuery,
-        order: formattedOrder,
-        page: formattedPage,
-        perPage: formattedPerPage,
-        include: formattedInclude,
-        scopes: result.formattedScopes,
-    };
+    const selectedAttributes = formattedAttribute ? { attributes: formattedAttribute } : {};
+    return Object.assign({ query: formattedQuery, order: filteredFormattedOrder, page: formattedPage, perPage: formattedPerPage, include: formattedInclude, scopes: result.formattedScopes }, selectedAttributes);
 };
 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({ include: [[`${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({ include: [[`${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(undefined));
+        });
     });
     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 = {
-    literalAttributes?: 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,7 +21,7 @@ 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.literalAttributes) === 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);
     }

package/lib/validations/index.test.js

@@ -181,8 +181,19 @@ 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: '',
+                },
+            }, {
+                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: '',
                 },
@@ -192,12 +203,13 @@ describe('validations test', () => {
             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: ['not'] });
+                }, { literalAttributes: [literalAttribute] });
             }
             catch (error) {
                 expect(error.statusCode).toBe(400);

package/package.json

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