@strapi/utils 4.3.2 → 4.3.5

package/README.md

@@ -1,10 +1,7 @@
 # strapi-utils
 
-[![npm version](https://img.shields.io/npm/v/strapi-utils.svg)](https://www.npmjs.org/package/strapi-utils)
-[![npm downloads](https://img.shields.io/npm/dm/strapi-utils.svg)](https://www.npmjs.org/package/strapi-utils)
-[![npm dependencies](https://david-dm.org/strapi/strapi-utils.svg)](https://david-dm.org/strapi/strapi-utils)
-[![Build status](https://travis-ci.org/strapi/strapi-utils.svg?branch=master)](https://travis-ci.org/strapi/strapi-utils)
-[![Slack status](https://slack.strapi.io/badge.svg)](https://slack.strapi.io)
+[![npm version](https://img.shields.io/npm/v/@strapi/utils.svg)](https://www.npmjs.org/package/@strapi/utils)
+[![npm downloads](https://img.shields.io/npm/dm/@strapi/utils.svg)](https://www.npmjs.org/package/@strapi/utils)
 
 Shared utilities between Strapi packages.
 

package/lib/build-query.js

@@ -1,6 +1,6 @@
 'use strict';
 
-//TODO: move to dbal
+// TODO: move to dbal
 
 const _ = require('lodash');
 const parseType = require('./parse-type');
@@ -25,7 +25,7 @@ const getAssociationFromFieldKey = ({ model, field }) => {
     const part = fieldParts[i];
     attribute = part;
 
-    const assoc = tmpModel.associations.find(ast => ast.alias === part);
+    const assoc = tmpModel.associations.find((ast) => ast.alias === part);
 
     if (assoc) {
       association = assoc;
@@ -59,7 +59,7 @@ const getAssociationFromFieldKey = ({ model, field }) => {
  */
 const castInput = ({ type, value, operator }) => {
   return Array.isArray(value)
-    ? value.map(val => castValue({ type, operator, value: val }))
+    ? value.map((val) => castValue({ type, operator, value: val }))
     : castValue({ type, operator, value });
 };
 
@@ -84,9 +84,7 @@ const castValue = ({ type, value, operator }) => {
 const normalizeFieldName = ({ model, field }) => {
   const fieldPath = field.split('.');
   return _.last(fieldPath) === 'id'
-    ? _.initial(fieldPath)
-        .concat(model.primaryKey)
-        .join('.')
+    ? _.initial(fieldPath).concat(model.primaryKey).join('.')
     : fieldPath.join('.');
 };
 
@@ -100,7 +98,7 @@ const hasDeepFilters = ({ where = [], sort = [] }, { minDepth = 1 } = {}) => {
 
   const hasDeepWhereClauses = where.some(({ field, operator, value }) => {
     if (BOOLEAN_OPERATORS.includes(operator)) {
-      return value.some(clauses => hasDeepFilters({ where: clauses }));
+      return value.some((clauses) => hasDeepFilters({ where: clauses }));
     }
 
     return field.split('.').length > minDepth;
@@ -114,7 +112,8 @@ const normalizeWhereClauses = (whereClauses, { model }) => {
     .filter(({ field, value }) => {
       if (_.isNull(value)) {
         return false;
-      } else if (_.isUndefined(value)) {
+      }
+      if (_.isUndefined(value)) {
         strapi.log.warn(`The value of field: '${field}', in your where filter, is undefined.`);
         return false;
       }
@@ -125,7 +124,7 @@ const normalizeWhereClauses = (whereClauses, { model }) => {
         return {
           field,
           operator,
-          value: value.map(clauses => normalizeWhereClauses(clauses, { model })),
+          value: value.map((clauses) => normalizeWhereClauses(clauses, { model })),
         };
       }
 

package/lib/code-generator.js

@@ -2,7 +2,7 @@
 
 // Using timestamp (milliseconds) to be sure it is unique
 // + converting timestamp to base 36 for better readibility
-const generateTimestampCode = date => {
+const generateTimestampCode = (date) => {
   const referDate = date || new Date();
 
   return referDate.getTime().toString(36);

package/lib/config.js

@@ -62,22 +62,24 @@ const getConfigUrls = (config, forAdminBuild = false) => {
   };
 };
 
-const getAbsoluteUrl = adminOrServer => (config, forAdminBuild = false) => {
-  const { serverUrl, adminUrl } = getConfigUrls(config, forAdminBuild);
-  let url = adminOrServer === 'server' ? serverUrl : adminUrl;
+const getAbsoluteUrl =
+  (adminOrServer) =>
+  (config, forAdminBuild = false) => {
+    const { serverUrl, adminUrl } = getConfigUrls(config, forAdminBuild);
+    const url = adminOrServer === 'server' ? serverUrl : adminUrl;
 
-  if (url.startsWith('http')) {
-    return url;
-  }
+    if (url.startsWith('http')) {
+      return url;
+    }
 
-  let hostname =
-    config.get('environment') === 'development' &&
-    ['127.0.0.1', '0.0.0.0'].includes(config.get('server.host'))
-      ? 'localhost'
-      : config.get('server.host');
+    const hostname =
+      config.get('environment') === 'development' &&
+      ['127.0.0.1', '0.0.0.0'].includes(config.get('server.host'))
+        ? 'localhost'
+        : config.get('server.host');
 
-  return `http://${hostname}:${config.get('server.port')}${url}`;
-};
+    return `http://${hostname}:${config.get('server.port')}${url}`;
+  };
 
 module.exports = {
   getConfigUrls,

package/lib/content-types.js

@@ -32,7 +32,7 @@ const constants = {
   COLLECTION_TYPE,
 };
 
-const getTimestamps = model => {
+const getTimestamps = (model) => {
   const attributes = [];
 
   if (has(CREATED_AT_ATTRIBUTE, model.attributes)) {
@@ -64,7 +64,7 @@ const isWritableAttribute = (model, attributeName) => {
   return getWritableAttributes(model).includes(attributeName);
 };
 
-const getNonVisibleAttributes = model => {
+const getNonVisibleAttributes = (model) => {
   const nonVisibleAttributes = _.reduce(
     model.attributes,
     (acc, attr, attrName) => (attr.visible === false ? acc.concat(attrName) : acc),
@@ -74,7 +74,7 @@ const getNonVisibleAttributes = model => {
   return _.uniq([ID_ATTRIBUTE, ...getTimestamps(model), ...nonVisibleAttributes]);
 };
 
-const getVisibleAttributes = model => {
+const getVisibleAttributes = (model) => {
   return _.difference(_.keys(model.attributes), getNonVisibleAttributes(model));
 };
 
@@ -82,20 +82,20 @@ const isVisibleAttribute = (model, attributeName) => {
   return getVisibleAttributes(model).includes(attributeName);
 };
 
-const hasDraftAndPublish = model => _.get(model, 'options.draftAndPublish', false) === true;
+const hasDraftAndPublish = (model) => _.get(model, 'options.draftAndPublish', false) === true;
 
 const isDraft = (data, model) =>
   hasDraftAndPublish(model) && _.get(data, PUBLISHED_AT_ATTRIBUTE) === null;
 
 const isSingleType = ({ kind = COLLECTION_TYPE }) => kind === SINGLE_TYPE;
 const isCollectionType = ({ kind = COLLECTION_TYPE }) => kind === COLLECTION_TYPE;
-const isKind = kind => model => model.kind === kind;
+const isKind = (kind) => (model) => model.kind === kind;
 
 const getPrivateAttributes = (model = {}) => {
   return _.union(
     strapi.config.get('api.responses.privateAttributes', []),
     _.get(model, 'options.privateAttributes', []),
-    _.keys(_.pickBy(model.attributes, attr => !!attr.private))
+    _.keys(_.pickBy(model.attributes, (attr) => !!attr.private))
   );
 };
 
@@ -103,11 +103,11 @@ const isPrivateAttribute = (model = {}, attributeName) => {
   return model && model.privateAttributes && model.privateAttributes.includes(attributeName);
 };
 
-const isScalarAttribute = attribute => {
+const isScalarAttribute = (attribute) => {
   return !['media', 'component', 'relation', 'dynamiczone'].includes(attribute.type);
 };
 
-const getScalarAttributes = schema => {
+const getScalarAttributes = (schema) => {
   return _.reduce(
     schema.attributes,
     (acc, attr, attrName) => {
@@ -118,9 +118,9 @@ const getScalarAttributes = schema => {
   );
 };
 
-const isMediaAttribute = attribute => attribute.type === 'media';
-const isRelationalAttribute = attribute => attribute.type === 'relation';
-const isComponentAttribute = attribute => ['component', 'dynamiczone'].includes(attribute.type);
+const isMediaAttribute = (attribute) => attribute.type === 'media';
+const isRelationalAttribute = (attribute) => attribute.type === 'relation';
+const isComponentAttribute = (attribute) => ['component', 'dynamiczone'].includes(attribute.type);
 
 /**
  * Checks if an attribute is of type `type`
@@ -136,7 +136,7 @@ const isTypedAttribute = (attribute, type) => {
  * @param {object} contentType
  * @returns {string}
  */
-const getContentTypeRoutePrefix = contentType => {
+const getContentTypeRoutePrefix = (contentType) => {
   return isSingleType(contentType)
     ? _.kebabCase(contentType.info.singularName)
     : _.kebabCase(contentType.info.pluralName);

package/lib/convert-query-params.js

@@ -1,3 +1,5 @@
+/* eslint-disable max-classes-per-file */
+
 'use strict';
 
 /**
@@ -25,13 +27,13 @@ class InvalidSortError extends Error {
   }
 }
 
-const validateOrder = order => {
+const validateOrder = (order) => {
   if (!['asc', 'desc'].includes(order.toLocaleLowerCase())) {
     throw new InvalidOrderError();
   }
 };
 
-const convertCountQueryParams = countQuery => {
+const convertCountQueryParams = (countQuery) => {
   return parseType({ type: 'boolean', value: countQuery });
 };
 
@@ -39,13 +41,13 @@ const convertCountQueryParams = countQuery => {
  * Sort query parser
  * @param {string} sortQuery - ex: id:asc,price:desc
  */
-const convertSortQueryParams = sortQuery => {
+const convertSortQueryParams = (sortQuery) => {
   if (typeof sortQuery === 'string') {
-    return sortQuery.split(',').map(value => convertSingleSortQueryParam(value));
+    return sortQuery.split(',').map((value) => convertSingleSortQueryParam(value));
   }
 
   if (Array.isArray(sortQuery)) {
-    return sortQuery.flatMap(sortValue => convertSortQueryParams(sortValue));
+    return sortQuery.flatMap((sortValue) => convertSortQueryParams(sortValue));
   }
 
   if (_.isPlainObject(sortQuery)) {
@@ -55,7 +57,7 @@ const convertSortQueryParams = sortQuery => {
   throw new InvalidSortError();
 };
 
-const convertSingleSortQueryParam = sortQuery => {
+const convertSingleSortQueryParam = (sortQuery) => {
   // split field and order param with default order to ascending
   const [field, order = 'asc'] = sortQuery.split(':');
 
@@ -68,9 +70,9 @@ const convertSingleSortQueryParam = sortQuery => {
   return _.set({}, field, order);
 };
 
-const convertNestedSortQueryParam = sortQuery => {
+const convertNestedSortQueryParam = (sortQuery) => {
   const transformedSort = {};
-  for (const field in sortQuery) {
+  for (const field of Object.keys(sortQuery)) {
     const order = sortQuery[field];
 
     // this is a deep sort
@@ -89,7 +91,7 @@ const convertNestedSortQueryParam = sortQuery => {
  * Start query parser
  * @param {string} startQuery
  */
-const convertStartQueryParams = startQuery => {
+const convertStartQueryParams = (startQuery) => {
   const startAsANumber = _.toNumber(startQuery);
 
   if (!_.isInteger(startAsANumber) || startAsANumber < 0) {
@@ -103,7 +105,7 @@ const convertStartQueryParams = startQuery => {
  * Limit query parser
  * @param {string} limitQuery
  */
-const convertLimitQueryParams = limitQuery => {
+const convertLimitQueryParams = (limitQuery) => {
   const limitAsANumber = _.toNumber(limitQuery);
 
   if (!_.isInteger(limitAsANumber) || (limitAsANumber !== -1 && limitAsANumber < 0)) {
@@ -130,18 +132,18 @@ const convertPopulateQueryParams = (populate, schema, depth = 0) => {
   }
 
   if (typeof populate === 'string') {
-    return populate.split(',').map(value => _.trim(value));
+    return populate.split(',').map((value) => _.trim(value));
   }
 
   if (Array.isArray(populate)) {
     // map convert
     return _.uniq(
-      populate.flatMap(value => {
+      populate.flatMap((value) => {
         if (typeof value !== 'string') {
           throw new InvalidPopulateError();
         }
 
-        return value.split(',').map(value => _.trim(value));
+        return value.split(',').map((value) => _.trim(value));
       })
     );
   }
@@ -171,8 +173,8 @@ const convertPopulateObject = (populate, schema) => {
     // fixed when we'll implement a more accurate way to query them
     if (attribute.type === 'dynamiczone') {
       const populates = attribute.components
-        .map(uid => strapi.getModel(uid))
-        .map(schema => convertNestedPopulate(subPopulate, schema));
+        .map((uid) => strapi.getModel(uid))
+        .map((schema) => convertNestedPopulate(subPopulate, schema));
 
       return {
         ...acc,
@@ -255,13 +257,13 @@ const convertFieldsQueryParams = (fields, depth = 0) => {
   }
 
   if (typeof fields === 'string') {
-    const fieldsValues = fields.split(',').map(value => _.trim(value));
+    const fieldsValues = fields.split(',').map((value) => _.trim(value));
     return _.uniq(['id', ...fieldsValues]);
   }
 
   if (Array.isArray(fields)) {
     // map convert
-    const fieldsValues = fields.flatMap(value => convertFieldsQueryParams(value, depth + 1));
+    const fieldsValues = fields.flatMap((value) => convertFieldsQueryParams(value, depth + 1));
     return _.uniq(['id', ...fieldsValues]);
   }
 
@@ -290,13 +292,13 @@ const convertAndSanitizeFilters = (filters, schema) => {
     return (
       filters
         // Sanitize each filter
-        .map(filter => convertAndSanitizeFilters(filter, schema))
+        .map((filter) => convertAndSanitizeFilters(filter, schema))
         // Filter out empty filters
-        .filter(filter => !isObject(filter) || !isEmpty(filter))
+        .filter((filter) => !isObject(filter) || !isEmpty(filter))
     );
   }
 
-  const removeOperator = operator => delete filters[operator];
+  const removeOperator = (operator) => delete filters[operator];
 
   // Here, `key` can either be an operator or an attribute name
   for (const [key, value] of Object.entries(filters)) {
@@ -324,24 +326,23 @@ const convertAndSanitizeFilters = (filters, schema) => {
         removeOperator(key);
       }
 
+      // Password attributes
+      else if (attribute.type === 'password') {
+        // Always remove password attributes from filters object
+        removeOperator(key);
+      }
+
       // Scalar attributes
       else {
-        // Always remove password attributes from filters object
-        if (attribute.type === 'password') {
-          removeOperator(key);
-        } else {
-          filters[key] = convertAndSanitizeFilters(value, schema);
-        }
+        filters[key] = convertAndSanitizeFilters(value, schema);
       }
     }
 
     // Handle operators
-    else {
-      if (['$null', '$notNull'].includes(key)) {
-        filters[key] = parseType({ type: 'boolean', value: filters[key], forceCast: true });
-      } else if (isObject(value)) {
-        filters[key] = convertAndSanitizeFilters(value, schema);
-      }
+    else if (['$null', '$notNull'].includes(key)) {
+      filters[key] = parseType({ type: 'boolean', value: filters[key], forceCast: true });
+    } else if (isObject(value)) {
+      filters[key] = convertAndSanitizeFilters(value, schema);
     }
 
     // Remove empty objects & arrays

package/lib/env-helper.js

@@ -58,7 +58,7 @@ const utils = {
       value = value.substring(1, value.length - 1);
     }
 
-    return value.split(',').map(v => {
+    return value.split(',').map((v) => {
       return _.trim(_.trim(v, ' '), '"');
     });
   },

package/lib/errors.js

@@ -1,3 +1,5 @@
+/* eslint-disable max-classes-per-file */
+
 'use strict';
 
 const { HttpError } = require('http-errors');

package/lib/format-yup-error.js

@@ -2,13 +2,13 @@
 
 const { isEmpty, toPath } = require('lodash/fp');
 
-const formatYupInnerError = yupError => ({
+const formatYupInnerError = (yupError) => ({
   path: toPath(yupError.path),
   message: yupError.message,
   name: yupError.name,
 });
 
-const formatYupErrors = yupError => ({
+const formatYupErrors = (yupError) => ({
   errors: isEmpty(yupError.inner)
     ? [formatYupInnerError(yupError)]
     : yupError.inner.map(formatYupInnerError),

package/lib/hooks.js

@@ -85,7 +85,7 @@ const createAsyncParallelHook = () => ({
   ...createHook(),
 
   async call(context) {
-    const promises = this.getHandlers().map(handler => handler(cloneDeep(context)));
+    const promises = this.getHandlers().map((handler) => handler(cloneDeep(context)));
 
     return Promise.all(promises);
   },

package/lib/object-formatting.js

@@ -2,7 +2,7 @@
 
 const _ = require('lodash');
 
-const removeUndefined = obj => _.pickBy(obj, value => typeof value !== 'undefined');
+const removeUndefined = (obj) => _.pickBy(obj, (value) => typeof value !== 'undefined');
 
 module.exports = {
   removeUndefined,

package/lib/pagination.js

@@ -30,10 +30,12 @@ const ensureMinValues = ({ start, limit }) => ({
   limit: limit === -1 ? limit : Math.max(limit, 1),
 });
 
-const ensureMaxValues = (maxLimit = -1) => ({ start, limit }) => ({
-  start,
-  limit: withMaxLimit(limit, maxLimit),
-});
+const ensureMaxValues =
+  (maxLimit = -1) =>
+  ({ start, limit }) => ({
+    start,
+    limit: withMaxLimit(limit, maxLimit),
+  });
 
 // Apply maxLimit as the limit when limit is -1
 const withNoLimit = (pagination, maxLimit = -1) => ({

package/lib/parse-multipart.js

@@ -2,7 +2,7 @@
 
 const _ = require('lodash');
 
-module.exports = ctx => {
+module.exports = (ctx) => {
   if (!ctx.is('multipart')) {
     return { data: ctx.request.body, files: {} };
   }

package/lib/parse-type.js

@@ -3,9 +3,9 @@
 const _ = require('lodash');
 const dates = require('date-fns');
 
-const timeRegex = new RegExp('^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$');
+const timeRegex = /^(2[0-3]|[01][0-9]):([0-5][0-9]):([0-5][0-9])(.[0-9]{1,3})?$/;
 
-const parseTime = value => {
+const parseTime = (value) => {
   if (dates.isDate(value)) return dates.format(value, 'HH:mm:ss.SSS');
 
   if (typeof value !== 'string') {
@@ -23,10 +23,10 @@ const parseTime = value => {
   return `${hours}:${minutes}:${seconds}.${fractionPart}`;
 };
 
-const parseDate = value => {
+const parseDate = (value) => {
   if (dates.isDate(value)) return dates.format(value, 'yyyy-MM-dd');
   try {
-    let date = dates.parseISO(value);
+    const date = dates.parseISO(value);
 
     if (dates.isValid(date)) return dates.format(date, 'yyyy-MM-dd');
 
@@ -36,7 +36,7 @@ const parseDate = value => {
   }
 };
 
-const parseDateTimeOrTimestamp = value => {
+const parseDateTimeOrTimestamp = (value) => {
   if (dates.isDate(value)) return value;
   try {
     const date = dates.parseISO(value);

package/lib/pipe-async.js

@@ -1,11 +1,13 @@
 'use strict';
 
-module.exports = (...methods) => async data => {
-  let res = data;
+module.exports =
+  (...methods) =>
+  async (data) => {
+    let res = data;
 
-  for (const method of methods) {
-    res = await method(res);
-  }
+    for (const method of methods) {
+      res = await method(res);
+    }
 
-  return res;
-};
+    return res;
+  };

package/lib/policy.js

@@ -1,6 +1,7 @@
 /**
  * Policies util
  */
+
 'use strict';
 
 const _ = require('lodash');
@@ -9,7 +10,7 @@ const { eq } = require('lodash/fp');
 const PLUGIN_PREFIX = 'plugin::';
 const API_PREFIX = 'api::';
 
-const parsePolicy = policy => {
+const parsePolicy = (policy) => {
   if (typeof policy === 'string') {
     return { policyName: policy, config: {} };
   }
@@ -43,7 +44,7 @@ const globalPolicy = ({ method, endpoint, controller, action, plugin }) => {
 };
 
 const resolvePolicies = (config, { pluginName, apiName } = {}) => {
-  return config.map(policyConfig => {
+  return config.map((policyConfig) => {
     return {
       handler: getPolicy(policyConfig, { pluginName, apiName }),
       config: policyConfig.config || {},
@@ -87,10 +88,10 @@ const getPolicy = (policyConfig, { pluginName, apiName } = {}) => {
   return policy.handler;
 };
 
-const createPolicy = options => {
+const createPolicy = (options) => {
   const { name = 'unnamed', validator, handler } = options;
 
-  const wrappedValidator = config => {
+  const wrappedValidator = (config) => {
     if (validator) {
       try {
         validator(config);

package/lib/print-value.js

@@ -3,7 +3,7 @@
 // Code copied from the yup library (https://github.com/jquense/yup)
 // https://github.com/jquense/yup/blob/2778b88bdacd5260d593c6468793da2e77daf21f/src/util/printValue.ts
 
-const toString = Object.prototype.toString;
+const { toString } = Object.prototype;
 const errorToString = Error.prototype.toString;
 const regExpToString = RegExp.prototype.toString;
 const symbolToString = typeof Symbol !== 'undefined' ? Symbol.prototype.toString : () => '';
@@ -13,34 +13,34 @@ const SYMBOL_REGEXP = /^Symbol\((.*)\)(.*)$/;
 function printNumber(val) {
   if (val != +val) return 'NaN';
   const isNegativeZero = val === 0 && 1 / val < 0;
-  return isNegativeZero ? '-0' : '' + val;
+  return isNegativeZero ? '-0' : `${val}`;
 }
 
 function printSimpleValue(val, quoteStrings = false) {
-  if (val == null || val === true || val === false) return '' + val;
+  if (val == null || val === true || val === false) return `${val}`;
 
   const typeOf = typeof val;
   if (typeOf === 'number') return printNumber(val);
   if (typeOf === 'string') return quoteStrings ? `"${val}"` : val;
-  if (typeOf === 'function') return '[Function ' + (val.name || 'anonymous') + ']';
+  if (typeOf === 'function') return `[Function ${val.name || 'anonymous'}]`;
   if (typeOf === 'symbol') return symbolToString.call(val).replace(SYMBOL_REGEXP, 'Symbol($1)');
 
   const tag = toString.call(val).slice(8, -1);
-  if (tag === 'Date') return isNaN(val.getTime()) ? '' + val : val.toISOString(val);
-  if (tag === 'Error' || val instanceof Error) return '[' + errorToString.call(val) + ']';
+  if (tag === 'Date') return Number.isNaN(val.getTime()) ? `${val}` : val.toISOString(val);
+  if (tag === 'Error' || val instanceof Error) return `[${errorToString.call(val)}]`;
   if (tag === 'RegExp') return regExpToString.call(val);
 
   return null;
 }
 
 function printValue(value, quoteStrings) {
-  let result = printSimpleValue(value, quoteStrings);
+  const result = printSimpleValue(value, quoteStrings);
   if (result !== null) return result;
 
   return JSON.stringify(
     value,
-    function(key, value) {
-      let result = printSimpleValue(this[key], quoteStrings);
+    function replacer(key, value) {
+      const result = printSimpleValue(this[key], quoteStrings);
       if (result !== null) return result;
       return value;
     },

package/lib/provider-factory.js

@@ -96,7 +96,7 @@ const providerFactory = (options = {}) => {
         return items;
       }
 
-      return items.filter(item => {
+      return items.filter((item) => {
         return filtersEntries.every(([key, value]) => item[key] === value);
       });
     },

package/lib/relations.js

@@ -2,8 +2,8 @@
 
 const MANY_RELATIONS = ['oneToMany', 'manyToMany'];
 
-const getRelationalFields = contentType => {
-  return Object.keys(contentType.attributes).filter(attributeName => {
+const getRelationalFields = (contentType) => {
+  return Object.keys(contentType.attributes).filter((attributeName) => {
     return contentType.attributes[attributeName].type === 'relation';
   });
 };

package/lib/sanitize/index.js

@@ -13,7 +13,7 @@ module.exports = {
   contentAPI: {
     input(data, schema, { auth } = {}) {
       if (isArray(data)) {
-        return Promise.all(data.map(entry => this.input(entry, schema, { auth })));
+        return Promise.all(data.map((entry) => this.input(entry, schema, { auth })));
       }
 
       const nonWritableAttributes = getNonWritableAttributes(schema);
@@ -31,14 +31,14 @@ module.exports = {
       // Apply sanitizers from registry if exists
       strapi.sanitizers
         .get('content-api.input')
-        .forEach(sanitizer => transforms.push(sanitizer(schema)));
+        .forEach((sanitizer) => transforms.push(sanitizer(schema)));
 
       return pipeAsync(...transforms)(data);
     },
 
     output(data, schema, { auth } = {}) {
       if (isArray(data)) {
-        return Promise.all(data.map(entry => this.output(entry, schema, { auth })));
+        return Promise.all(data.map((entry) => this.output(entry, schema, { auth })));
       }
 
       const transforms = [sanitizers.defaultSanitizeOutput(schema)];
@@ -50,7 +50,7 @@ module.exports = {
       // Apply sanitizers from registry if exists
       strapi.sanitizers
         .get('content-api.output')
-        .forEach(sanitizer => transforms.push(sanitizer(schema)));
+        .forEach((sanitizer) => transforms.push(sanitizer(schema)));
 
       return pipeAsync(...transforms)(data);
     },

package/lib/sanitize/visitors/allowed-fields.js

@@ -2,68 +2,70 @@
 
 const { isArray, toPath } = require('lodash/fp');
 
-module.exports = (allowedFields = null) => ({ key, path }, { remove }) => {
-  // All fields are allowed
-  if (allowedFields === null) {
-    return;
-  }
+module.exports =
+  (allowedFields = null) =>
+  ({ key, path }, { remove }) => {
+    // All fields are allowed
+    if (allowedFields === null) {
+      return;
+    }
 
-  // Ignore invalid formats
-  if (!isArray(allowedFields)) {
-    return;
-  }
+    // Ignore invalid formats
+    if (!isArray(allowedFields)) {
+      return;
+    }
 
-  const containedPaths = getContainedPaths(path);
+    const containedPaths = getContainedPaths(path);
 
-  /**
-   * Tells if the current path should be kept or not based
-   * on the success of the check functions for any of the allowed paths.
-   *
-   * The check functions are defined as follow:
-   *
-   * `containedPaths.includes(p)`
-   * @example
-   * ```js
-   * const path = 'foo.bar.field';
-   * const p = 'foo.bar';
-   * // it should match
-   *
-   * const path = 'foo.bar.field';
-   * const p = 'bar.foo';
-   * // it shouldn't match
-   *
-   * const path = 'foo.bar';
-   * const p = 'foo.bar.field';
-   * // it should match but isn't handled by this check
-   * ```
-   *
-   * `p.startsWith(`${path}.`)`
-   * @example
-   * ```js
-   * const path = 'foo.bar';
-   * const p = 'foo.bar.field';
-   * // it should match
-   *
-   * const path = 'foo.bar.field';
-   * const p = 'bar.foo';
-   * // it shouldn't match
-   *
-   * const path = 'foo.bar.field';
-   * const p = 'foo.bar';
-   * // it should match but isn't handled by this check
-   * ```
-   */
-  const isPathAllowed = allowedFields.some(
-    p => containedPaths.includes(p) || p.startsWith(`${path}.`)
-  );
+    /**
+     * Tells if the current path should be kept or not based
+     * on the success of the check functions for any of the allowed paths.
+     *
+     * The check functions are defined as follow:
+     *
+     * `containedPaths.includes(p)`
+     * @example
+     * ```js
+     * const path = 'foo.bar.field';
+     * const p = 'foo.bar';
+     * // it should match
+     *
+     * const path = 'foo.bar.field';
+     * const p = 'bar.foo';
+     * // it shouldn't match
+     *
+     * const path = 'foo.bar';
+     * const p = 'foo.bar.field';
+     * // it should match but isn't handled by this check
+     * ```
+     *
+     * `p.startsWith(`${path}.`)`
+     * @example
+     * ```js
+     * const path = 'foo.bar';
+     * const p = 'foo.bar.field';
+     * // it should match
+     *
+     * const path = 'foo.bar.field';
+     * const p = 'bar.foo';
+     * // it shouldn't match
+     *
+     * const path = 'foo.bar.field';
+     * const p = 'foo.bar';
+     * // it should match but isn't handled by this check
+     * ```
+     */
+    const isPathAllowed = allowedFields.some(
+      (p) => containedPaths.includes(p) || p.startsWith(`${path}.`)
+    );
 
-  if (isPathAllowed) {
-    return;
-  }
+    if (isPathAllowed) {
+      return;
+    }
 
-  // Remove otherwise
-  remove(key);
-};
+    // Remove otherwise
+    remove(key);
+  };
 
 /**
  * Retrieve the list of allowed paths based on the given path
@@ -83,7 +85,7 @@ module.exports = (allowedFields = null) => ({ key, path }, { remove }) => {
  * // ['foo', 'foo.bar', 'foo.bar.field']
  * ```
  */
-const getContainedPaths = path => {
+const getContainedPaths = (path) => {
   const parts = toPath(path);
 
   return parts.reduce((acc, value, index, list) => {

package/lib/sanitize/visitors/remove-restricted-relations.js

@@ -4,62 +4,64 @@ const ACTIONS_TO_VERIFY = ['find'];
 
 const { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = require('../../content-types').constants;
 
-module.exports = auth => async ({ data, key, attribute, schema }, { remove, set }) => {
-  const isRelation = attribute.type === 'relation';
+module.exports =
+  (auth) =>
+  async ({ data, key, attribute, schema }, { remove, set }) => {
+    const isRelation = attribute.type === 'relation';
 
-  if (!isRelation) {
-    return;
-  }
+    if (!isRelation) {
+      return;
+    }
 
-  const handleMorphRelation = async () => {
-    const newMorphValue = [];
+    const handleMorphRelation = async () => {
+      const newMorphValue = [];
 
-    for (const element of data[key]) {
-      const scopes = ACTIONS_TO_VERIFY.map(action => `${element.__type}.${action}`);
-      const isAllowed = await hasAccessToSomeScopes(scopes, auth);
+      for (const element of data[key]) {
+        const scopes = ACTIONS_TO_VERIFY.map((action) => `${element.__type}.${action}`);
+        const isAllowed = await hasAccessToSomeScopes(scopes, auth);
 
-      if (isAllowed) {
-        newMorphValue.push(element);
+        if (isAllowed) {
+          newMorphValue.push(element);
+        }
       }
-    }
 
-    // If the new value is empty, remove the relation completely
-    if (newMorphValue.length === 0) {
-      remove(key);
-    } else {
-      set(key, newMorphValue);
-    }
-  };
+      // If the new value is empty, remove the relation completely
+      if (newMorphValue.length === 0) {
+        remove(key);
+      } else {
+        set(key, newMorphValue);
+      }
+    };
 
-  const handleRegularRelation = async () => {
-    const scopes = ACTIONS_TO_VERIFY.map(action => `${attribute.target}.${action}`);
+    const handleRegularRelation = async () => {
+      const scopes = ACTIONS_TO_VERIFY.map((action) => `${attribute.target}.${action}`);
 
-    const isAllowed = await hasAccessToSomeScopes(scopes, auth);
+      const isAllowed = await hasAccessToSomeScopes(scopes, auth);
 
-    // If the authenticated user don't have access to any of the scopes, then remove the field
-    if (!isAllowed) {
-      remove(key);
-    }
-  };
+      // If the authenticated user don't have access to any of the scopes, then remove the field
+      if (!isAllowed) {
+        remove(key);
+      }
+    };
 
-  const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
-  const isCreatorRelation = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(key);
+    const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
+    const isCreatorRelation = [CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE].includes(key);
 
-  // Polymorphic relations
-  if (isMorphRelation) {
-    await handleMorphRelation();
-    return;
-  }
+    // Polymorphic relations
+    if (isMorphRelation) {
+      await handleMorphRelation();
+      return;
+    }
 
-  // Creator relations
-  if (isCreatorRelation && schema.options.populateCreatorFields) {
-    // do nothing
-    return;
-  }
+    // Creator relations
+    if (isCreatorRelation && schema.options.populateCreatorFields) {
+      // do nothing
+      return;
+    }
 
-  // Regular relations
-  await handleRegularRelation();
-};
+    // Regular relations
+    await handleRegularRelation();
+  };
 
 const hasAccessToSomeScopes = async (scopes, auth) => {
   for (const scope of scopes) {

package/lib/sanitize/visitors/restricted-fields.js

@@ -2,30 +2,31 @@
 
 const { isArray } = require('lodash/fp');
 
-module.exports = (restrictedFields = null) => ({ key, path }, { remove }) => {
-  // Remove all fields
-  if (restrictedFields === null) {
-    remove(key);
-    return;
-  }
+module.exports =
+  (restrictedFields = null) =>
+  ({ key, path }, { remove }) => {
+    // Remove all fields
+    if (restrictedFields === null) {
+      remove(key);
+      return;
+    }
 
-  // Ignore invalid formats
-  if (!isArray(restrictedFields)) {
-    return;
-  }
+    // Ignore invalid formats
+    if (!isArray(restrictedFields)) {
+      return;
+    }
 
-  // Remove if an exact match was found
-  if (restrictedFields.includes(path)) {
-    remove(key);
-    return;
-  }
+    // Remove if an exact match was found
+    if (restrictedFields.includes(path)) {
+      remove(key);
+      return;
+    }
 
-  // Remove nested matches
-  const isRestrictedNested = restrictedFields.some(allowedPath =>
-    path.startsWith(`${allowedPath}.`)
-  );
-  if (isRestrictedNested) {
-    remove(key);
-    return;
-  }
-};
+    // Remove nested matches
+    const isRestrictedNested = restrictedFields.some((allowedPath) =>
+      path.startsWith(`${allowedPath}.`)
+    );
+    if (isRestrictedNested) {
+      remove(key);
+    }
+  };

package/lib/set-creator-fields.js

@@ -3,13 +3,15 @@
 const { assign, assoc } = require('lodash/fp');
 const { CREATED_BY_ATTRIBUTE, UPDATED_BY_ATTRIBUTE } = require('./content-types').constants;
 
-module.exports = ({ user, isEdition = false }) => data => {
-  if (isEdition) {
-    return assoc(UPDATED_BY_ATTRIBUTE, user.id, data);
-  }
+module.exports =
+  ({ user, isEdition = false }) =>
+  (data) => {
+    if (isEdition) {
+      return assoc(UPDATED_BY_ATTRIBUTE, user.id, data);
+    }
 
-  return assign(data, {
-    [CREATED_BY_ATTRIBUTE]: user.id,
-    [UPDATED_BY_ATTRIBUTE]: user.id,
-  });
-};
+    return assign(data, {
+      [CREATED_BY_ATTRIBUTE]: user.id,
+      [UPDATED_BY_ATTRIBUTE]: user.id,
+    });
+  };

package/lib/string-formatting.js

@@ -1,4 +1,5 @@
 'use strict';
+
 const _ = require('lodash');
 const { trimChars, trimCharsEnd, trimCharsStart } = require('lodash/fp');
 const slugify = require('@sindresorhus/slugify');
@@ -6,9 +7,9 @@ const { kebabCase } = require('lodash');
 
 const nameToSlug = (name, options = { separator: '-' }) => slugify(name, options);
 
-const nameToCollectionName = name => slugify(name, { separator: '_' });
+const nameToCollectionName = (name) => slugify(name, { separator: '_' });
 
-const toRegressedEnumValue = value =>
+const toRegressedEnumValue = (value) =>
   slugify(value, {
     decamelize: false,
     lowercase: false,
@@ -16,14 +17,14 @@ const toRegressedEnumValue = value =>
   });
 
 const getCommonBeginning = (...strings) =>
-  _.takeWhile(strings[0], (char, index) => strings.every(string => string[index] === char)).join(
+  _.takeWhile(strings[0], (char, index) => strings.every((string) => string[index] === char)).join(
     ''
   );
 
 const getCommonPath = (...paths) => {
-  const [segments, ...otherSegments] = paths.map(it => _.split(it, '/'));
+  const [segments, ...otherSegments] = paths.map((it) => _.split(it, '/'));
   return _.join(
-    _.takeWhile(segments, (str, index) => otherSegments.every(it => it[index] === str)),
+    _.takeWhile(segments, (str, index) => otherSegments.every((it) => it[index] === str)),
     '/'
   );
 };
@@ -42,9 +43,9 @@ const escapeQuery = (query, charsToEscape, escapeChar = '\\') => {
 
 const stringIncludes = (arr, val) => arr.map(String).includes(String(val));
 const stringEquals = (a, b) => String(a) === String(b);
-const isCamelCase = value => /^[a-z][a-zA-Z0-9]+$/.test(value);
-const isKebabCase = value => /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value);
-const startsWithANumber = value => /^[0-9]/.test(value);
+const isCamelCase = (value) => /^[a-z][a-zA-Z0-9]+$/.test(value);
+const isKebabCase = (value) => /^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/.test(value);
+const startsWithANumber = (value) => /^[0-9]/.test(value);
 
 const joinBy = (joint, ...args) => {
   const trim = trimChars(joint);
@@ -59,7 +60,7 @@ const joinBy = (joint, ...args) => {
   }, '');
 };
 
-const toKebabCase = value => kebabCase(value);
+const toKebabCase = (value) => kebabCase(value);
 
 module.exports = {
   nameToSlug,

package/lib/template-configuration.js

@@ -19,7 +19,7 @@ const templateConfiguration = (obj, configPath = '') => {
       !excludeConfigPaths.includes(configPath.substr(1)) &&
       obj[key].match(regex) !== null
     ) {
-      // eslint-disable-next-line prefer-template
+      // eslint-disable-next-line prefer-template, no-eval
       acc[key] = eval('`' + obj[key] + '`');
     } else {
       acc[key] = obj[key];

package/lib/traverse-entity.js

@@ -46,7 +46,7 @@ const traverseEntity = async (visitor, options, entity) => {
     if (isRelation) {
       const isMorphRelation = attribute.relation.toLowerCase().startsWith('morph');
 
-      const traverseTarget = entry => {
+      const traverseTarget = (entry) => {
         // Handle polymorphic relationships
         const targetSchemaUID = isMorphRelation ? entry.__type : attribute.target;
         const targetSchema = strapi.getModel(targetSchemaUID);
@@ -63,7 +63,7 @@ const traverseEntity = async (visitor, options, entity) => {
     }
 
     if (isMedia) {
-      const traverseTarget = entry => {
+      const traverseTarget = (entry) => {
         const targetSchemaUID = 'plugin::upload.file';
         const targetSchema = strapi.getModel(targetSchemaUID);
 
@@ -82,7 +82,7 @@ const traverseEntity = async (visitor, options, entity) => {
       const targetSchema = strapi.getModel(attribute.component);
       const traverseOptions = { schema: targetSchema, path: newPath };
 
-      const traverseComponent = entry => traverseEntity(visitor, traverseOptions, entry);
+      const traverseComponent = (entry) => traverseEntity(visitor, traverseOptions, entry);
 
       copy[key] = isArray(value)
         ? await Promise.all(value.map(traverseComponent))
@@ -90,7 +90,7 @@ const traverseEntity = async (visitor, options, entity) => {
     }
 
     if (isDynamicZone && isArray(value)) {
-      const visitDynamicZoneEntry = entry => {
+      const visitDynamicZoneEntry = (entry) => {
         const targetSchema = strapi.getModel(entry.__component);
         const traverseOptions = { schema: targetSchema, path: newPath };
 

package/lib/validators.js

@@ -9,34 +9,38 @@ const printValue = require('./print-value');
 
 const MixedSchemaType = yup.MixedSchema;
 
-const isNotNilTest = value => !_.isNil(value);
+const isNotNilTest = (value) => !_.isNil(value);
 
 function isNotNill(msg = '${path} must be defined.') {
   return this.test('defined', msg, isNotNilTest);
 }
 
-const isNotNullTest = value => !_.isNull(value);
+const isNotNullTest = (value) => !_.isNull(value);
 function isNotNull(msg = '${path} cannot be null.') {
   return this.test('defined', msg, isNotNullTest);
 }
 
 function isFunction(message = '${path} is not a function') {
-  return this.test('is a function', message, value => _.isUndefined(value) || _.isFunction(value));
+  return this.test(
+    'is a function',
+    message,
+    (value) => _.isUndefined(value) || _.isFunction(value)
+  );
 }
 
 function isCamelCase(message = '${path} is not in camel case (anExampleOfCamelCase)') {
-  return this.test('is in camelCase', message, value => utils.isCamelCase(value));
+  return this.test('is in camelCase', message, (value) => utils.isCamelCase(value));
 }
 
 function isKebabCase(message = '${path} is not in kebab case (an-example-of-kebab-case)') {
-  return this.test('is in kebab-case', message, value => utils.isKebabCase(value));
+  return this.test('is in kebab-case', message, (value) => utils.isKebabCase(value));
 }
 
 function onlyContainsFunctions(message = '${path} contains values that are not functions') {
   return this.test(
     'only contains functions',
     message,
-    value => _.isUndefined(value) || (value && Object.values(value).every(_.isFunction))
+    (value) => _.isUndefined(value) || (value && Object.values(value).every(_.isFunction))
   );
 }
 
@@ -65,33 +69,38 @@ const handleYupError = (error, errorMessage) => {
 
 const defaultValidationParam = { strict: true, abortEarly: false };
 
-const validateYupSchema = (schema, options = {}) => async (body, errorMessage) => {
-  try {
-    const optionsWithDefaults = defaults(defaultValidationParam, options);
-    return await schema.validate(body, optionsWithDefaults);
-  } catch (e) {
-    handleYupError(e, errorMessage);
-  }
-};
-
-const validateYupSchemaSync = (schema, options = {}) => (body, errorMessage) => {
-  try {
-    const optionsWithDefaults = defaults(defaultValidationParam, options);
-    return schema.validateSync(body, optionsWithDefaults);
-  } catch (e) {
-    handleYupError(e, errorMessage);
-  }
-};
+const validateYupSchema =
+  (schema, options = {}) =>
+  async (body, errorMessage) => {
+    try {
+      const optionsWithDefaults = defaults(defaultValidationParam, options);
+      return await schema.validate(body, optionsWithDefaults);
+    } catch (e) {
+      handleYupError(e, errorMessage);
+    }
+  };
+
+const validateYupSchemaSync =
+  (schema, options = {}) =>
+  (body, errorMessage) => {
+    try {
+      const optionsWithDefaults = defaults(defaultValidationParam, options);
+      return schema.validateSync(body, optionsWithDefaults);
+    } catch (e) {
+      handleYupError(e, errorMessage);
+    }
+  };
 
 // Temporary fix of this issue : https://github.com/jquense/yup/issues/616
 yup.setLocale({
   mixed: {
     notType({ path, type, value, originalValue }) {
-      let isCast = originalValue != null && originalValue !== value;
-      let msg =
+      const isCast = originalValue != null && originalValue !== value;
+      const msg =
         `${path} must be a \`${type}\` type, ` +
-        `but the final value was: \`${printValue(value, true)}\`` +
-        (isCast ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : '.');
+        `but the final value was: \`${printValue(value, true)}\`${
+          isCast ? ` (cast from the value \`${printValue(originalValue, true)}\`).` : '.'
+        }`;
 
       /* Remove comment that is not supposed to be seen by the enduser
       if (value === null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/utils",
-  "version": "4.3.2",
+  "version": "4.3.5",
   "description": "Shared utilities for the Strapi packages",
   "keywords": [
     "strapi",
@@ -36,7 +36,7 @@
   },
   "dependencies": {
     "@sindresorhus/slugify": "1.1.0",
-    "date-fns": "2.28.0",
+    "date-fns": "2.29.2",
     "http-errors": "1.8.1",
     "lodash": "4.17.21",
     "yup": "0.32.9"
@@ -45,5 +45,5 @@
     "node": ">=14.19.1 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "gitHead": "7039c0d22836c94457130515b3a55eb93d2411f8"
+  "gitHead": "a52b0535513ff35b4ef46c9daf7be48f2ba71737"
 }