@strapi/strapi 4.0.0-beta.2 → 4.0.0-beta.20

package/lib/services/entity-service/attributes/transforms.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const { getOr, toNumber, isString, isBuffer } = require('lodash/fp');
+const bcrypt = require('bcryptjs');
+
+const transforms = {
+  password(value, context) {
+    const { attribute } = context;
+
+    if (!isString(value) && !isBuffer(value)) {
+      return value;
+    }
+
+    const rounds = toNumber(getOr(10, 'encryption.rounds', attribute));
+
+    return bcrypt.hashSync(value, rounds);
+  },
+};
+
+module.exports = transforms;

package/lib/services/entity-service/components.js

@@ -4,6 +4,7 @@ const _ = require('lodash');
 const { has, prop, omit, toString } = require('lodash/fp');
 
 const { contentTypes: contentTypesUtils } = require('@strapi/utils');
+const { ApplicationError } = require('@strapi/utils').errors;
 
 const omitComponentData = (contentType, data) => {
   const { attributes } = contentType;
@@ -208,11 +209,9 @@ const deleteOldComponents = async (
 
   idsToKeep.forEach(id => {
     if (!allIds.includes(id)) {
-      const err = new Error(
+      throw new ApplicationError(
         `Some of the provided components in ${attributeName} are not related to the entity`
       );
-      err.status = 400;
-      throw err;
     }
   });
 

package/lib/services/entity-service/index.d.ts

@@ -35,7 +35,7 @@ type Params<T> = {
   files?: any;
 };
 
-interface EntityService {
+export interface EntityService {
   uploadFiles<K extends keyof AllTypes, T extends AllTypes[K]>(uid: K, entity, files);
   wrapParams<K extends keyof AllTypes, T extends AllTypes[K]>(
     params: Params<T>,

package/lib/services/entity-service/index.js

@@ -1,13 +1,18 @@
 'use strict';
 
+const _ = require('lodash');
 const delegate = require('delegates');
-const { pipe } = require('lodash/fp');
-
 const {
-  sanitizeEntity,
+  InvalidTimeError,
+  InvalidDateError,
+  InvalidDateTimeError,
+} = require('@strapi/database').errors;
+const {
   webhook: webhookUtils,
   contentTypes: contentTypesUtils,
+  sanitize,
 } = require('@strapi/utils');
+const { ValidationError } = require('@strapi/utils').errors;
 const uploadFiles = require('../utils/upload-files');
 
 const {
@@ -16,16 +21,22 @@ const {
   updateComponents,
   deleteComponents,
 } = require('./components');
-const {
-  transformCommonParams,
-  transformPaginationParams,
-  transformParamsToQuery,
-  pickSelectionParams,
-} = require('./params');
+const { transformParamsToQuery, pickSelectionParams } = require('./params');
+const { applyTransforms } = require('./attributes');
 
 // TODO: those should be strapi events used by the webhooks not the other way arround
 const { ENTRY_CREATE, ENTRY_UPDATE, ENTRY_DELETE } = webhookUtils.webhookEvents;
 
+const databaseErrorsToTransform = [InvalidTimeError, InvalidDateTimeError, InvalidDateError];
+
+const creationPipeline = (data, context) => {
+  return applyTransforms(data, context);
+};
+
+const updatePipeline = (data, context) => {
+  return applyTransforms(data, context);
+};
+
 module.exports = ctx => {
   const implementation = createDefaultImplementation(ctx);
 
@@ -46,6 +57,28 @@ module.exports = ctx => {
   // delegate every method in implementation
   Object.keys(service.implementation).forEach(key => delegator.method(key));
 
+  // wrap methods to handle Database Errors
+  service.decorate(oldService => {
+    const newService = _.mapValues(
+      oldService,
+      (method, methodName) =>
+        async function(...args) {
+          try {
+            return await oldService[methodName].call(this, ...args);
+          } catch (error) {
+            if (
+              databaseErrorsToTransform.some(errorToTransform => error instanceof errorToTransform)
+            ) {
+              throw new ValidationError(error.message);
+            }
+            throw error;
+          }
+        }
+    );
+
+    return newService;
+  });
+
   return service;
 };
 
@@ -59,12 +92,13 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     return options;
   },
 
-  emitEvent(uid, event, entity) {
+  async emitEvent(uid, event, entity) {
     const model = strapi.getModel(uid);
+    const sanitizedEntity = await sanitize.sanitizers.defaultSanitizeOutput(model, entity);
 
     eventHub.emit(event, {
       model: model.modelName,
-      entry: sanitizeEntity(entity, { model }),
+      entry: sanitizedEntity,
     });
   },
 
@@ -137,7 +171,9 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     let entity = await db.query(uid).create({
       ...query,
-      data: Object.assign(omitComponentData(model, validData), componentData),
+      data: creationPipeline(Object.assign(omitComponentData(model, validData), componentData), {
+        contentType: model,
+      }),
     });
 
     // TODO: upload the files then set the links in the entity like with compo to avoid making too many queries
@@ -147,7 +183,7 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
       entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
-    this.emitEvent(uid, ENTRY_CREATE, entity);
+    await this.emitEvent(uid, ENTRY_CREATE, entity);
 
     return entity;
   },
@@ -166,9 +202,14 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
 
     const isDraft = contentTypesUtils.isDraft(entityToUpdate, model);
 
-    const validData = await entityValidator.validateEntityUpdate(model, data, {
-      isDraft,
-    });
+    const validData = await entityValidator.validateEntityUpdate(
+      model,
+      data,
+      {
+        isDraft,
+      },
+      entityToUpdate
+    );
 
     const query = transformParamsToQuery(uid, pickSelectionParams(wrappedParams));
 
@@ -178,7 +219,9 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     let entity = await db.query(uid).update({
       ...query,
       where: { id: entityId },
-      data: Object.assign(omitComponentData(model, validData), componentData),
+      data: updatePipeline(Object.assign(omitComponentData(model, validData), componentData), {
+        contentType: model,
+      }),
     });
 
     // TODO: upload the files then set the links in the entity like with compo to avoid making too many queries
@@ -188,7 +231,7 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
       entity = await this.findOne(uid, entity.id, wrappedParams);
     }
 
-    this.emitEvent(uid, ENTRY_UPDATE, entity);
+    await this.emitEvent(uid, ENTRY_UPDATE, entity);
 
     return entity;
   },
@@ -211,7 +254,7 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     await deleteComponents(uid, entityToDelete);
     await db.query(uid).delete({ where: { id: entityToDelete.id } });
 
-    this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
+    await this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
 
     return entityToDelete;
   },
@@ -226,18 +269,31 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     return db.query(uid).deleteMany(query);
   },
 
-  load(uid, entity, field, params) {
+  load(uid, entity, field, params = {}) {
     const { attributes } = strapi.getModel(uid);
 
     const attribute = attributes[field];
 
-    const loadParams =
-      attribute.type === 'relation'
-        ? transformParamsToQuery(attribute.target, params)
-        : pipe(
-            transformCommonParams,
-            transformPaginationParams
-          )(params);
+    const loadParams = {};
+
+    switch (attribute.type) {
+      case 'relation': {
+        Object.assign(loadParams, transformParamsToQuery(attribute.target, params));
+        break;
+      }
+      case 'component': {
+        Object.assign(loadParams, transformParamsToQuery(attribute.component, params));
+        break;
+      }
+      case 'dynamiczone': {
+        Object.assign(loadParams, transformParamsToQuery(null, params));
+        break;
+      }
+      case 'media': {
+        Object.assign(loadParams, transformParamsToQuery('plugin::upload.file', params));
+        break;
+      }
+    }
 
     return db.query(uid).load(entity, field, loadParams);
   },

package/lib/services/entity-service/params.js

@@ -1,6 +1,7 @@
 'use strict';
 
-const { pick, pipe, isNil } = require('lodash/fp');
+const { pick, isNil, toNumber, isInteger } = require('lodash/fp');
+const { PaginationError } = require('@strapi/utils').errors;
 
 const {
   convertSortQueryParams,
@@ -9,137 +10,86 @@ const {
   convertPopulateQueryParams,
   convertFiltersQueryParams,
   convertFieldsQueryParams,
+  convertPublicationStateParams,
 } = require('@strapi/utils/lib/convert-query-params');
 
-const { contentTypes: contentTypesUtils } = require('@strapi/utils');
+const pickSelectionParams = pick(['fields', 'populate']);
 
-const { PUBLISHED_AT_ATTRIBUTE } = contentTypesUtils.constants;
+const transformParamsToQuery = (uid, params) => {
+  // NOTE: can be a CT, a Compo or nothing in the case of polymorphism (DZ & morph relations)
+  const type = strapi.getModel(uid);
 
-// TODO: to remove once the front is migrated
-const convertOldQuery = params => {
   const query = {};
 
-  Object.keys(params).forEach(key => {
-    if (key.startsWith('_')) {
-      query[key.slice(1)] = params[key];
-    } else {
-      query[key] = params[key];
-    }
-  });
+  const { _q, sort, filters, fields, populate, page, pageSize, start, limit } = params;
 
-  return query;
-};
-
-const transformCommonParams = (params = {}) => {
-  const { _q, sort, filters, _where, fields, populate, ...query } = params;
-
-  if (_q) {
+  if (!isNil(_q)) {
     query._q = _q;
   }
 
-  if (sort) {
+  if (!isNil(sort)) {
     query.orderBy = convertSortQueryParams(sort);
   }
 
-  if (filters) {
+  if (!isNil(filters)) {
     query.where = convertFiltersQueryParams(filters);
   }
 
-  if (_where) {
-    query.where = {
-      $and: [_where].concat(query.where || []),
-    };
-  }
-
-  if (fields) {
+  if (!isNil(fields)) {
     query.select = convertFieldsQueryParams(fields);
   }
 
-  if (populate) {
+  if (!isNil(populate)) {
     query.populate = convertPopulateQueryParams(populate);
   }
 
-  return { ...convertOldQuery(query), ...query };
-};
-
-const transformPaginationParams = (params = {}) => {
-  const { page, pageSize, start, limit, ...query } = params;
-
   const isPagePagination = !isNil(page) || !isNil(pageSize);
   const isOffsetPagination = !isNil(start) || !isNil(limit);
 
   if (isPagePagination && isOffsetPagination) {
-    throw new Error(
+    throw new PaginationError(
       'Invalid pagination attributes. You cannot use page and offset pagination in the same query'
     );
   }
 
-  if (page) {
-    query.page = Number(page);
-  }
-
-  if (pageSize) {
-    query.pageSize = Number(pageSize);
-  }
+  if (!isNil(page)) {
+    const pageVal = toNumber(page);
 
-  if (start) {
-    query.offset = convertStartQueryParams(start);
-  }
+    if (!isInteger(pageVal) || pageVal <= 0) {
+      throw new PaginationError(
+        `Invalid 'page' parameter. Expected an integer > 0, received: ${page}`
+      );
+    }
 
-  if (limit) {
-    query.limit = convertLimitQueryParams(limit);
+    query.page = pageVal;
   }
 
-  return { ...convertOldQuery(query), ...query };
-};
+  if (!isNil(pageSize)) {
+    const pageSizeVal = toNumber(pageSize);
 
-const transformPublicationStateParams = uid => (params = {}) => {
-  const contentType = strapi.getModel(uid);
+    if (!isInteger(pageSizeVal) || pageSizeVal <= 0) {
+      throw new PaginationError(
+        `Invalid 'pageSize' parameter. Expected an integer > 0, received: ${page}`
+      );
+    }
 
-  if (!contentType) {
-    return params;
+    query.pageSize = pageSizeVal;
   }
 
-  const { publicationState, ...query } = params;
-
-  if (publicationState && contentTypesUtils.hasDraftAndPublish(contentType)) {
-    const { publicationState = 'live' } = params;
-
-    const liveClause = {
-      [PUBLISHED_AT_ATTRIBUTE]: {
-        $notNull: true,
-      },
-    };
-
-    if (publicationState === 'live') {
-      query.where = {
-        $and: [liveClause].concat(query.where || []),
-      };
-
-      // TODO: propagate nested publicationState filter somehow
-    }
+  if (!isNil(start)) {
+    query.offset = convertStartQueryParams(start);
   }
 
-  return { ...convertOldQuery(query), ...query };
-};
+  if (!isNil(limit)) {
+    query.limit = convertLimitQueryParams(limit);
+  }
 
-const pickSelectionParams = pick(['fields', 'populate']);
+  convertPublicationStateParams(type, params, query);
 
-const transformParamsToQuery = (uid, params) => {
-  return pipe(
-    // _q, _where, filters, etc...
-    transformCommonParams,
-    // page, pageSize, start, limit
-    transformPaginationParams,
-    // publicationState
-    transformPublicationStateParams(uid)
-  )(params);
+  return query;
 };
 
 module.exports = {
-  transformCommonParams,
-  transformPublicationStateParams,
-  transformPaginationParams,
   transformParamsToQuery,
   pickSelectionParams,
 };

package/lib/services/entity-validator/index.js

@@ -4,15 +4,19 @@
  */
 'use strict';
 
-const { has, assoc, prop } = require('lodash/fp');
+const { has, assoc, prop, isObject } = require('lodash/fp');
 const strapiUtils = require('@strapi/utils');
 const validators = require('./validators');
 
-const { yup, formatYupErrors } = strapiUtils;
+const { yup, validateYupSchema } = strapiUtils;
 const { isMediaAttribute, isScalarAttribute, getWritableAttributes } = strapiUtils.contentTypes;
+const { ValidationError } = strapiUtils.errors;
 
-const addMinMax = (attr, validator, data) => {
-  if (Number.isInteger(attr.min) && (attr.required || (Array.isArray(data) && data.length > 0))) {
+const addMinMax = (validator, { attr, updatedAttribute }) => {
+  if (
+    Number.isInteger(attr.min) &&
+    (attr.required || (Array.isArray(updatedAttribute.value) && updatedAttribute.value.length > 0))
+  ) {
     validator = validator.min(attr.min);
   }
   if (Number.isInteger(attr.max)) {
@@ -21,7 +25,7 @@ const addMinMax = (attr, validator, data) => {
   return validator;
 };
 
-const addRequiredValidation = createOrUpdate => (required, validator) => {
+const addRequiredValidation = createOrUpdate => (validator, { attr: { required } }) => {
   if (required) {
     if (createOrUpdate === 'creation') {
       validator = validator.notNil();
@@ -34,7 +38,7 @@ const addRequiredValidation = createOrUpdate => (required, validator) => {
   return validator;
 };
 
-const addDefault = createOrUpdate => (attr, validator) => {
+const addDefault = createOrUpdate => (validator, { attr }) => {
   if (createOrUpdate === 'creation') {
     if (
       ((attr.type === 'component' && attr.repeatable) || attr.type === 'dynamiczone') &&
@@ -53,7 +57,7 @@ const addDefault = createOrUpdate => (attr, validator) => {
 
 const preventCast = validator => validator.transform((val, originalVal) => originalVal);
 
-const createComponentValidator = createOrUpdate => (attr, data, { isDraft }) => {
+const createComponentValidator = createOrUpdate => ({ attr, updatedAttribute }, { isDraft }) => {
   let validator;
 
   const model = strapi.getModel(attr.component);
@@ -65,19 +69,23 @@ const createComponentValidator = createOrUpdate => (attr, data, { isDraft }) =>
     validator = yup
       .array()
       .of(
-        yup.lazy(item => createModelValidator(createOrUpdate)(model, item, { isDraft }).notNull())
+        yup.lazy(item =>
+          createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }).notNull()
+        )
       );
-    validator = addRequiredValidation(createOrUpdate)(true, validator);
-    validator = addMinMax(attr, validator, data);
+    validator = addRequiredValidation(createOrUpdate)(validator, { attr: { required: true } });
+    validator = addMinMax(validator, { attr, updatedAttribute });
   } else {
-    validator = createModelValidator(createOrUpdate)(model, data, { isDraft });
-    validator = addRequiredValidation(createOrUpdate)(!isDraft && attr.required, validator);
+    validator = createModelValidator(createOrUpdate)({ model, updatedAttribute }, { isDraft });
+    validator = addRequiredValidation(createOrUpdate)(validator, {
+      attr: { required: !isDraft && attr.required },
+    });
   }
 
   return validator;
 };
 
-const createDzValidator = createOrUpdate => (attr, data, { isDraft }) => {
+const createDzValidator = createOrUpdate => ({ attr, updatedAttribute }, { isDraft }) => {
   let validator;
 
   validator = yup.array().of(
@@ -94,76 +102,85 @@ const createDzValidator = createOrUpdate => (attr, data, { isDraft }) => {
         .notNull();
 
       return model
-        ? schema.concat(createModelValidator(createOrUpdate)(model, item, { isDraft }))
+        ? schema.concat(createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }))
         : schema;
     })
   );
-  validator = addRequiredValidation(createOrUpdate)(true, validator);
-  validator = addMinMax(attr, validator, data);
+  validator = addRequiredValidation(createOrUpdate)(validator, { attr: { required: true } });
+  validator = addMinMax(validator, { attr, updatedAttribute });
 
   return validator;
 };
 
-const createRelationValidator = createOrUpdate => (attr, data, { isDraft }) => {
+const createRelationValidator = createOrUpdate => ({ attr, updatedAttribute }, { isDraft }) => {
   let validator;
 
-  if (Array.isArray(data)) {
+  if (Array.isArray(updatedAttribute.value)) {
     validator = yup.array().of(yup.mixed());
   } else {
     validator = yup.mixed();
   }
-  validator = addRequiredValidation(createOrUpdate)(!isDraft && attr.required, validator);
+
+  validator = addRequiredValidation(createOrUpdate)(validator, {
+    attr: { required: !isDraft && attr.required },
+  });
 
   return validator;
 };
 
-const createScalarAttributeValidator = createOrUpdate => (attr, { isDraft }) => {
+const createScalarAttributeValidator = createOrUpdate => (metas, options) => {
   let validator;
 
-  if (has(attr.type, validators)) {
-    validator = validators[attr.type](attr, { isDraft });
+  if (has(metas.attr.type, validators)) {
+    validator = validators[metas.attr.type](metas, options);
   } else {
     // No validators specified - fall back to mixed
     validator = yup.mixed();
   }
 
-  validator = addRequiredValidation(createOrUpdate)(!isDraft && attr.required, validator);
+  validator = addRequiredValidation(createOrUpdate)(validator, {
+    attr: { required: !options.isDraft && metas.attr.required },
+  });
 
   return validator;
 };
 
-const createAttributeValidator = createOrUpdate => (attr, data, { isDraft }) => {
+const createAttributeValidator = createOrUpdate => (metas, options) => {
   let validator;
 
-  if (isMediaAttribute(attr)) {
+  if (isMediaAttribute(metas.attr)) {
     validator = yup.mixed();
-  } else if (isScalarAttribute(attr)) {
-    validator = createScalarAttributeValidator(createOrUpdate)(attr, { isDraft });
+  } else if (isScalarAttribute(metas.attr)) {
+    validator = createScalarAttributeValidator(createOrUpdate)(metas, options);
   } else {
-    if (attr.type === 'component') {
-      validator = createComponentValidator(createOrUpdate)(attr, data, { isDraft });
-    } else if (attr.type === 'dynamiczone') {
-      validator = createDzValidator(createOrUpdate)(attr, data, { isDraft });
+    if (metas.attr.type === 'component') {
+      validator = createComponentValidator(createOrUpdate)(metas, options);
+    } else if (metas.attr.type === 'dynamiczone') {
+      validator = createDzValidator(createOrUpdate)(metas, options);
     } else {
-      validator = createRelationValidator(createOrUpdate)(attr, data, { isDraft });
+      validator = createRelationValidator(createOrUpdate)(metas, options);
     }
 
     validator = preventCast(validator);
   }
 
-  validator = addDefault(createOrUpdate)(attr, validator);
+  validator = addDefault(createOrUpdate)(validator, metas);
 
   return validator;
 };
 
-const createModelValidator = createOrUpdate => (model, data, { isDraft }) => {
+const createModelValidator = createOrUpdate => ({ model, data, entity }, options) => {
   const writableAttributes = model ? getWritableAttributes(model) : [];
 
   const schema = writableAttributes.reduce((validators, attributeName) => {
     const validator = createAttributeValidator(createOrUpdate)(
-      model.attributes[attributeName],
-      prop(attributeName, data),
-      { isDraft }
+      {
+        attr: model.attributes[attributeName],
+        updatedAttribute: { name: attributeName, value: prop(attributeName, data) },
+        model,
+        entity,
+      },
+      options
     );
 
     return assoc(attributeName, validator)(validators);
@@ -172,13 +189,29 @@ const createModelValidator = createOrUpdate => (model, data, { isDraft }) => {
   return yup.object().shape(schema);
 };
 
-const createValidateEntity = createOrUpdate => async (model, data, { isDraft = false } = {}) => {
-  try {
-    const validator = createModelValidator(createOrUpdate)(model, data, { isDraft }).required();
-    return await validator.validate(data, { abortEarly: false });
-  } catch (e) {
-    throw strapi.errors.badRequest('ValidationError', { errors: formatYupErrors(e) });
+const createValidateEntity = createOrUpdate => async (
+  model,
+  data,
+  { isDraft = false } = {},
+  entity = null
+) => {
+  if (!isObject(data)) {
+    const { displayName } = model.info;
+
+    throw new ValidationError(
+      `Invalid payload submitted for the ${createOrUpdate} of an entity of type ${displayName}. Expected an object, but got ${typeof data}`
+    );
   }
+
+  const validator = createModelValidator(createOrUpdate)(
+    {
+      model,
+      data,
+      entity,
+    },
+    { isDraft }
+  ).required();
+  return validateYupSchema(validator, { strict: false, abortEarly: false })(data);
 };
 
 module.exports = {