@autofleet/sheilta 1.4.5 → 1.4.6

package/lib/formatter/index.d.ts

@@ -6,6 +6,7 @@ export type FormatPayloadOptions = {
     literalAttributes?: LiteralAttribute[];
     DBFormatter?: any;
     skipSearchTermFormat?: boolean;
+    additionalAllowedAttributes?: string[];
 };
 type ConditionWithOperator = {
     operator: string;
@@ -34,15 +35,21 @@ declare const formatPayload: ({ order, page, perPage, include, query, attributes
     query?: {};
     attributes?: any;
     searchTerm?: any;
-}, model?: any, options?: any) => {
+}, model?: any, options?: FormatPayloadOptions) => {
+    externalQueryValues: Record<string, unknown>;
     attributes: any[] | {
         include: any[];
     };
-    query: {};
+    query: Record<string, unknown>;
     order: SequelizeOrder[];
-    page: any;
-    perPage: any;
+    page: number;
+    perPage: number;
     include: any;
-    scopes: any[];
+    scopes: (string | {
+        method: (string | {
+            replacementsMap: Record<string, string>;
+            scopeValue: any;
+        })[];
+    })[];
 };
 export default formatPayload;

package/lib/formatter/index.js

@@ -145,10 +145,10 @@ const formatInclude = (include, associationsMap = {}) => {
     let formattedInclude = include.map((i) => {
         const includedAssociation = associationsMap[typeof i === 'string' ? i : (i.association || i.model)];
         return {
-            ...i,
+            ...(typeof i !== 'string' && i),
             association: includedAssociation,
-            required: i.required !== false,
-            ...(i.include && {
+            required: typeof i === 'string' || i.required !== false,
+            ...(typeof i !== 'string' && i.include && {
                 include: formatInclude(i.include, includedAssociation?.target?.associations),
             }),
         };
@@ -156,8 +156,9 @@ const formatInclude = (include, associationsMap = {}) => {
     formattedInclude = formattedInclude.map(({ model: _model, ...i }) => i);
     return formattedInclude;
 };
-const formatQuery = (query, associationModels, replacementsMap) => {
+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)) {
@@ -168,6 +169,9 @@ const formatQuery = (query, associationModels, replacementsMap) => {
             formattedScopeMap.get(CUSTOM_FIELDS_FILTER_SCOPE)[scopeKey] = parseCustomFieldScopeQueryValue(queryItemValue);
             return;
         }
+        if (additionalAllowedAttributes.includes(queryItemKey)) {
+            externalQueryValues[queryItemKey] = queryItemValue;
+        }
         const key = (0, utils_1.isAttributeByAssociation)(queryItemKey, associationModels)
             ? (0, utils_1.wrapAttributeWithOperator)(queryItemKey)
             : queryItemKey;
@@ -186,6 +190,7 @@ const formatQuery = (query, associationModels, replacementsMap) => {
     });
     return {
         formattedQuery,
+        externalQueryValues,
         formattedScopes,
     };
 };
@@ -212,8 +217,8 @@ const formatPayload = ({ order = [], page = utils_1.PAGE_DEFAULT, perPage = util
     const formattedInclude = formatInclude(include, model?.associations);
     const formattedPage = formatPage(page);
     const formattedPerPage = formatPerPage(perPage);
-    const result = formatQuery(query, associationModels, replacementsMap);
-    const queryScopes = result.formattedScopes;
+    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);
@@ -232,8 +237,8 @@ const formatPayload = ({ order = [], page = utils_1.PAGE_DEFAULT, perPage = util
         perPage: formattedPerPage,
         include: formattedInclude,
         scopes: [...queryScopes, ...orderScopes],
-        // ...((allAttributes.length > 0) && { attributes: allAttributes }),
         ...(formattedAttribute && { attributes: formattedAttribute }),
+        ...(Object.keys(externalQueryValues).length > 0 && { externalQueryValues }),
     };
 };
 exports.default = formatPayload;

package/lib/middleware/index.d.ts

@@ -8,6 +8,7 @@ export type LiteralAttribute = {
 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>;

package/lib/middleware/index.js

@@ -20,7 +20,7 @@ const querySchema = object.keys({
     include: array.items(any),
     searchTerm: string,
     group: array.items(string),
-    enrichments: alternatives.try(array.items(string), object.pattern(string, { exclude: array.items(string), include: 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];

package/lib/validations/index.js

@@ -4,7 +4,8 @@ exports.validatePayload = void 0;
 const utils_1 = require("../utils");
 const operators_1 = require("../operators");
 const validateOperator = (operator) => operators_1.OPERATORS.includes(operator.split(operators_1.OPERATOR_PREFIX)[1]);
-const validateQueryAttribute = (attribute, modelAttributes = [], associationModels = []) => [...modelAttributes, ...associationModels].includes(attribute.includes(utils_1.ASSOCIATION_PREFIX) ? attribute.split(utils_1.ASSOCIATION_PREFIX)[0] : attribute);
+const validateQueryAttribute = (attribute, modelAttributes = [], associationModels = [], additionalAllowedAttributes = []) => ([...modelAttributes, ...associationModels].includes(attribute.includes(utils_1.ASSOCIATION_PREFIX) ? attribute.split(utils_1.ASSOCIATION_PREFIX)[0] : attribute)
+    || additionalAllowedAttributes.includes(attribute));
 const validateSingleOrder = (currentOrder, rawAttributes, associationModels, options = {}) => {
     const isOrderDescOrder = (0, utils_1.isOrderDesc)(currentOrder);
     if (isOrderDescOrder && currentOrder[0] !== utils_1.ORDER_PREFIX) {
@@ -42,18 +43,16 @@ const validateEnrichments = (enrichments, options) => {
         (0, utils_1.throwBadRequestError)(`enrichment attribute ${invalidEnrichment} is invalid`);
     }
 };
-const validateQueryPayload = (query, rawAttributes, associationModels = []) => {
-    // eslint-disable-next-line array-callback-return
-    Object.keys(query).map((key) => {
-        const value = query[key];
+const validateQueryPayload = (query, rawAttributes, associationModels = [], additionalAllowedAttributes = []) => {
+    Object.entries(query).forEach(([key, value]) => {
         if (Array.isArray(value)) {
             if (value[0] && typeof value[0] === 'object') {
-                value.map((v) => validateQueryPayload(v, rawAttributes, associationModels));
+                value.map((v) => validateQueryPayload(v, rawAttributes, associationModels, additionalAllowedAttributes));
             }
         }
-        else if (validateOperator(key) || validateQueryAttribute(key, rawAttributes, associationModels)) {
+        else if (validateOperator(key) || validateQueryAttribute(key, rawAttributes, associationModels, additionalAllowedAttributes)) {
             if (value && typeof value === 'object') {
-                validateQueryPayload(value, rawAttributes);
+                validateQueryPayload(value, rawAttributes, [], additionalAllowedAttributes);
             }
         }
         else {
@@ -104,7 +103,7 @@ const validatePayload = ({ query = {}, order = [], attributes = [], include = []
         validateAttributes(attributes, rawAttributes);
     }
     validateOrderAttributes(order, rawAttributes, associationModels, options);
-    validateQueryPayload(query, rawAttributes, associationModels);
+    validateQueryPayload(query, rawAttributes, associationModels, options.additionalAllowedAttributes);
     validateEnrichments(enrichments, options);
     if (!Array.isArray(group)) {
         (0, utils_1.throwBadRequestError)('group must be an array');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sheilta",
-  "version": "1.4.5",
+  "version": "1.4.6",
   "description": "Middlewares for validation and parsing of endpoints meant for data querying.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",