@strapi/utils 4.3.4 → 4.3.7

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.4",
+  "version": "4.3.7",
   "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": "28a2a00db8234ffcf644661c4c8092aa82f8c119"
+  "gitHead": "73f523b98322cea8992c72977b94a73a624d2e79"
 }