@strapi/utils 4.0.0-next.9 → 4.0.3

package/lib/validators.js

@@ -2,7 +2,10 @@
 
 const yup = require('yup');
 const _ = require('lodash');
+const { defaults } = require('lodash/fp');
 const utils = require('./string-formatting');
+const { YupValidationError } = require('./errors');
+const printValue = require('./print-value');
 
 const MixedSchemaType = yup.mixed;
 
@@ -56,27 +59,53 @@ class StrapiIDSchema extends MixedSchemaType {
 
 yup.strapiID = () => new StrapiIDSchema();
 
-/**
- * Returns a formatted error for http responses
- * @param {Object} validationError - a Yup ValidationError
- */
-const formatYupErrors = validationError => {
-  if (!validationError.inner) {
-    throw new Error('invalid.input');
-  }
+const handleYupError = (error, errorMessage) => {
+  throw new YupValidationError(error, errorMessage);
+};
+
+const defaultValidationParam = { strict: true, abortEarly: false };
 
-  if (validationError.inner.length === 0) {
-    if (validationError.path === undefined) return validationError.errors;
-    return { [validationError.path]: validationError.errors };
+const validateYupSchema = (schema, options = {}) => async (body, errorMessage) => {
+  try {
+    const optionsWithDefaults = defaults(defaultValidationParam, options);
+    return await schema.validate(body, optionsWithDefaults);
+  } catch (e) {
+    handleYupError(e, errorMessage);
   }
+};
 
-  return validationError.inner.reduce((acc, err) => {
-    acc[err.path] = err.errors;
-    return acc;
-  }, {});
+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 =
+        `${path} must be a \`${type}\` type, ` +
+        `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) {
+        msg += `\n If "null" is intended as an empty value be sure to mark the schema as \`.nullable()\``;
+      }
+      */
+      return msg;
+    },
+  },
+});
+
 module.exports = {
   yup,
-  formatYupErrors,
+  handleYupError,
+  validateYupSchema,
+  validateYupSchemaSync,
 };

package/package.json

@@ -1,49 +1,49 @@
 {
   "name": "@strapi/utils",
-  "version": "4.0.0-next.9",
+  "version": "4.0.3",
   "description": "Shared utilities for the Strapi packages",
-  "homepage": "https://strapi.io",
   "keywords": [
     "strapi",
-    "utilities",
-    "utils",
-    "winston"
+    "utils"
   ],
-  "directories": {
-    "lib": "./lib"
+  "homepage": "https://strapi.io",
+  "bugs": {
+    "url": "https://github.com/strapi/strapi/issues"
   },
-  "main": "./lib",
-  "dependencies": {
-    "@sindresorhus/slugify": "1.1.0",
-    "date-fns": "^2.19.0",
-    "lodash": "4.17.21",
-    "pino": "^4.7.1",
-    "pluralize": "^8.0.0",
-    "yup": "^0.32.9"
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/strapi/strapi.git"
   },
+  "license": "SEE LICENSE IN LICENSE",
   "author": {
+    "name": "Strapi Solutions SAS",
     "email": "hi@strapi.io",
-    "name": "Strapi team",
     "url": "https://strapi.io"
   },
   "maintainers": [
     {
-      "name": "Strapi team",
+      "name": "Strapi Solutions SAS",
       "email": "hi@strapi.io",
       "url": "https://strapi.io"
     }
   ],
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/strapi/strapi.git"
+  "main": "./lib",
+  "directories": {
+    "lib": "./lib"
   },
-  "bugs": {
-    "url": "https://github.com/strapi/strapi/issues"
+  "scripts": {
+    "test:unit": "jest --verbose"
+  },
+  "dependencies": {
+    "@sindresorhus/slugify": "1.1.0",
+    "date-fns": "2.24.0",
+    "http-errors": "1.8.0",
+    "lodash": "4.17.21",
+    "yup": "0.32.9"
   },
   "engines": {
-    "node": ">=12.x.x <=16.x.x",
+    "node": ">=12.22.0 <=16.x.x",
     "npm": ">=6.0.0"
   },
-  "license": "SEE LICENSE IN LICENSE",
-  "gitHead": "231263a3535658bab1e9492c6aaaed8692d62a53"
+  "gitHead": "48893ae3fc951b618fd8c4fdc6970e623d2c92db"
 }

package/lib/sanitize-entity.js

@@ -1,172 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const {
-  constants,
-  isPrivateAttribute,
-  getNonWritableAttributes,
-  getNonVisibleAttributes,
-  getWritableAttributes,
-} = require('./content-types');
-
-const { ID_ATTRIBUTE, CREATED_AT_ATTRIBUTE, UPDATED_AT_ATTRIBUTE } = constants;
-
-const sanitizeEntity = (dataSource, options) => {
-  const { model, withPrivate = false, isOutput = true, includeFields = null } = options;
-
-  if (typeof dataSource !== 'object' || _.isNil(dataSource)) {
-    return dataSource;
-  }
-
-  const data = parseOriginalData(dataSource);
-
-  if (typeof data !== 'object' || _.isNil(data)) {
-    return data;
-  }
-
-  if (_.isArray(data)) {
-    return data.map(entity => sanitizeEntity(entity, options));
-  }
-
-  if (_.isNil(model)) {
-    if (isOutput) {
-      return null;
-    } else {
-      return data;
-    }
-  }
-
-  const { attributes } = model;
-  const allowedFields = getAllowedFields({ includeFields, model, isOutput });
-
-  const reducerFn = (acc, value, key) => {
-    const attribute = attributes[key];
-    const allowedFieldsHasKey = allowedFields.includes(key);
-
-    if (shouldRemoveAttribute(model, key, attribute, { withPrivate, isOutput })) {
-      return acc;
-    }
-
-    // Relations
-    const relation = attribute && (attribute.model || attribute.collection || attribute.component);
-    if (relation) {
-      if (_.isNil(value)) {
-        return { ...acc, [key]: value };
-      }
-
-      const [nextFields, isAllowed] = includeFields
-        ? getNextFields(allowedFields, key, { allowedFieldsHasKey })
-        : [null, true];
-
-      if (!isAllowed) {
-        return acc;
-      }
-
-      const baseOptions = {
-        withPrivate,
-        isOutput,
-        includeFields: nextFields,
-      };
-
-      let sanitizeFn;
-      if (relation === '*') {
-        sanitizeFn = entity => {
-          if (_.isNil(entity) || !_.has(entity, '__contentType')) {
-            return entity;
-          }
-
-          return sanitizeEntity(entity, {
-            model: strapi.getModel(entity.__contentType),
-            ...baseOptions,
-          });
-        };
-      } else {
-        sanitizeFn = entity =>
-          sanitizeEntity(entity, {
-            model: strapi.getModel(relation, attribute.plugin),
-            ...baseOptions,
-          });
-      }
-
-      const nextVal = Array.isArray(value) ? value.map(sanitizeFn) : sanitizeFn(value);
-
-      return { ...acc, [key]: nextVal };
-    }
-
-    const isAllowedField = !includeFields || allowedFieldsHasKey;
-
-    // Dynamic zones
-    if (attribute && attribute.type === 'dynamiczone' && value !== null && isAllowedField) {
-      const nextVal = value.map(elem =>
-        sanitizeEntity(elem, {
-          model: strapi.getModel(elem.__component),
-          withPrivate,
-          isOutput,
-        })
-      );
-      return { ...acc, [key]: nextVal };
-    }
-
-    // Other fields
-    if (isAllowedField) {
-      return { ...acc, [key]: value };
-    }
-
-    return acc;
-  };
-
-  return _.reduce(data, reducerFn, {});
-};
-
-const parseOriginalData = data => (_.isFunction(data.toJSON) ? data.toJSON() : data);
-
-const COMPONENT_FIELDS = ['__component'];
-const STATIC_FIELDS = [ID_ATTRIBUTE];
-
-const getAllowedFields = ({ includeFields, model, isOutput }) => {
-  const nonWritableAttributes = getNonWritableAttributes(model);
-  const nonVisibleAttributes = getNonVisibleAttributes(model);
-
-  const writableAttributes = getWritableAttributes(model);
-
-  const nonVisibleWritableAttributes = _.intersection(writableAttributes, nonVisibleAttributes);
-
-  return _.concat(
-    includeFields || [],
-    ...(isOutput
-      ? [
-          STATIC_FIELDS,
-          CREATED_AT_ATTRIBUTE,
-          UPDATED_AT_ATTRIBUTE,
-          COMPONENT_FIELDS,
-          ...nonWritableAttributes,
-          ...nonVisibleAttributes,
-        ]
-      : [STATIC_FIELDS, COMPONENT_FIELDS, ...nonVisibleWritableAttributes])
-  );
-};
-
-const getNextFields = (fields, key, { allowedFieldsHasKey }) => {
-  const searchStr = `${key}.`;
-
-  const transformedFields = (fields || [])
-    .filter(field => field.startsWith(searchStr))
-    .map(field => field.replace(searchStr, ''));
-
-  const isAllowed = allowedFieldsHasKey || transformedFields.length > 0;
-  const nextFields = allowedFieldsHasKey ? null : transformedFields;
-
-  return [nextFields, isAllowed];
-};
-
-const shouldRemoveAttribute = (model, key, attribute = {}, { withPrivate, isOutput }) => {
-  const isPassword = attribute.type === 'password';
-  const isPrivate = isPrivateAttribute(model, key);
-
-  const shouldRemovePassword = isOutput;
-  const shouldRemovePrivate = !withPrivate && isOutput;
-
-  return !!((isPassword && shouldRemovePassword) || (isPrivate && shouldRemovePrivate));
-};
-
-module.exports = sanitizeEntity;