@strapi/strapi 4.3.4 → 4.3.7

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

@@ -2,11 +2,8 @@
 
 const _ = require('lodash');
 const delegate = require('delegates');
-const {
-  InvalidTimeError,
-  InvalidDateError,
-  InvalidDateTimeError,
-} = require('@strapi/database').errors;
+const { InvalidTimeError, InvalidDateError, InvalidDateTimeError } =
+  require('@strapi/database').errors;
 const {
   webhook: webhookUtils,
   contentTypes: contentTypesUtils,
@@ -17,6 +14,7 @@ const uploadFiles = require('../utils/upload-files');
 
 const {
   omitComponentData,
+  getComponents,
   createComponents,
   updateComponents,
   deleteComponents,
@@ -37,51 +35,6 @@ const updatePipeline = (data, context) => {
   return applyTransforms(data, context);
 };
 
-module.exports = ctx => {
-  const implementation = createDefaultImplementation(ctx);
-
-  const service = {
-    implementation,
-    decorate(decorator) {
-      if (typeof decorator !== 'function') {
-        throw new Error(`Decorator must be a function, received ${typeof decorator}`);
-      }
-
-      this.implementation = Object.assign({}, this.implementation, decorator(this.implementation));
-      return this;
-    },
-  };
-
-  const delegator = delegate(service, 'implementation');
-
-  // 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;
-};
-
 /**
  * @type {import('.').default}
  */
@@ -261,8 +214,10 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
       return null;
     }
 
+    const componentsToDelete = await getComponents(uid, entityToDelete);
+
     await db.query(uid).delete({ where: { id: entityToDelete.id } });
-    await deleteComponents(uid, entityToDelete);
+    await deleteComponents(uid, { ...entityToDelete, ...componentsToDelete });
 
     await this.emitEvent(uid, ENTRY_DELETE, entityToDelete);
 
@@ -276,7 +231,23 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
     // select / populate
     const query = transformParamsToQuery(uid, wrappedParams);
 
-    return db.query(uid).deleteMany(query);
+    const entitiesToDelete = await db.query(uid).findMany(query);
+
+    if (!entitiesToDelete.length) {
+      return null;
+    }
+
+    const componentsToDelete = await Promise.all(
+      entitiesToDelete.map((entityToDelete) => getComponents(uid, entityToDelete))
+    );
+
+    const deletedEntities = await db.query(uid).deleteMany(query);
+    await Promise.all(componentsToDelete.map((compos) => deleteComponents(uid, compos)));
+
+    // Trigger webhooks. One for each entity
+    await Promise.all(entitiesToDelete.map((entity) => this.emitEvent(uid, ENTRY_DELETE, entity)));
+
+    return deletedEntities;
   },
 
   load(uid, entity, field, params = {}) {
@@ -303,8 +274,58 @@ const createDefaultImplementation = ({ strapi, db, eventHub, entityValidator })
         Object.assign(loadParams, transformParamsToQuery('plugin::upload.file', params));
         break;
       }
+      default: {
+        break;
+      }
     }
 
     return db.query(uid).load(entity, field, loadParams);
   },
 });
+
+module.exports = (ctx) => {
+  const implementation = createDefaultImplementation(ctx);
+
+  const service = {
+    implementation,
+    decorate(decorator) {
+      if (typeof decorator !== 'function') {
+        throw new Error(`Decorator must be a function, received ${typeof decorator}`);
+      }
+
+      this.implementation = { ...this.implementation, ...decorator(this.implementation) };
+      return this;
+    },
+  };
+
+  const delegator = delegate(service, 'implementation');
+
+  // 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;
+};

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

@@ -2,6 +2,7 @@
  * Entity validator
  * Module that will validate input data for entity creation or edition
  */
+
 'use strict';
 
 const { has, assoc, prop, isObject } = require('lodash/fp');
@@ -25,110 +26,117 @@ const addMinMax = (validator, { attr, updatedAttribute }) => {
   return validator;
 };
 
-const addRequiredValidation = createOrUpdate => (validator, { attr: { required } }) => {
-  if (required) {
-    if (createOrUpdate === 'creation') {
-      validator = validator.notNil();
-    } else if (createOrUpdate === 'update') {
-      validator = validator.notNull();
+const addRequiredValidation =
+  (createOrUpdate) =>
+  (validator, { attr: { required } }) => {
+    if (required) {
+      if (createOrUpdate === 'creation') {
+        validator = validator.notNil();
+      } else if (createOrUpdate === 'update') {
+        validator = validator.notNull();
+      }
+    } else {
+      validator = validator.nullable();
     }
-  } else {
-    validator = validator.nullable();
-  }
-  return validator;
-};
+    return validator;
+  };
 
-const addDefault = createOrUpdate => (validator, { attr }) => {
-  if (createOrUpdate === 'creation') {
-    if (
-      ((attr.type === 'component' && attr.repeatable) || attr.type === 'dynamiczone') &&
-      !attr.required
-    ) {
-      validator = validator.default([]);
+const addDefault =
+  (createOrUpdate) =>
+  (validator, { attr }) => {
+    if (createOrUpdate === 'creation') {
+      if (
+        ((attr.type === 'component' && attr.repeatable) || attr.type === 'dynamiczone') &&
+        !attr.required
+      ) {
+        validator = validator.default([]);
+      } else {
+        validator = validator.default(attr.default);
+      }
     } else {
-      validator = validator.default(attr.default);
+      validator = validator.default(undefined);
     }
-  } else {
-    validator = validator.default(undefined);
-  }
 
-  return validator;
-};
+    return validator;
+  };
 
-const preventCast = validator => validator.transform((val, originalVal) => originalVal);
+const preventCast = (validator) => validator.transform((val, originalVal) => originalVal);
 
-const createComponentValidator = createOrUpdate => ({ attr, updatedAttribute }, { isDraft }) => {
-  let validator;
+const createComponentValidator =
+  (createOrUpdate) =>
+  ({ attr, updatedAttribute }, { isDraft }) => {
+    let validator;
 
-  const model = strapi.getModel(attr.component);
-  if (!model) {
-    throw new Error('Validation failed: Model not found');
-  }
+    const model = strapi.getModel(attr.component);
+    if (!model) {
+      throw new Error('Validation failed: Model not found');
+    }
 
-  if (prop('repeatable', attr) === true) {
-    validator = yup
-      .array()
-      .of(
-        yup.lazy(item =>
-          createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }).notNull()
-        )
-      );
+    if (prop('repeatable', attr) === true) {
+      validator = yup
+        .array()
+        .of(
+          yup.lazy((item) =>
+            createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }).notNull()
+          )
+        );
+      validator = addRequiredValidation(createOrUpdate)(validator, { attr: { required: true } });
+      validator = addMinMax(validator, { attr, updatedAttribute });
+    } else {
+      validator = createModelValidator(createOrUpdate)({ model, updatedAttribute }, { isDraft });
+      validator = addRequiredValidation(createOrUpdate)(validator, {
+        attr: { required: !isDraft && attr.required },
+      });
+    }
+
+    return validator;
+  };
+
+const createDzValidator =
+  (createOrUpdate) =>
+  ({ attr, updatedAttribute }, { isDraft }) => {
+    let validator;
+
+    validator = yup.array().of(
+      yup.lazy((item) => {
+        const model = strapi.getModel(prop('__component', item));
+        const schema = yup
+          .object()
+          .shape({
+            __component: yup.string().required().oneOf(Object.keys(strapi.components)),
+          })
+          .notNull();
+
+        return model
+          ? schema.concat(createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }))
+          : schema;
+      })
+    );
     validator = addRequiredValidation(createOrUpdate)(validator, { attr: { required: true } });
     validator = addMinMax(validator, { attr, updatedAttribute });
-  } else {
-    validator = createModelValidator(createOrUpdate)({ model, updatedAttribute }, { isDraft });
-    validator = addRequiredValidation(createOrUpdate)(validator, {
-      attr: { required: !isDraft && attr.required },
-    });
-  }
-
-  return validator;
-};
-
-const createDzValidator = createOrUpdate => ({ attr, updatedAttribute }, { isDraft }) => {
-  let validator;
-
-  validator = yup.array().of(
-    yup.lazy(item => {
-      const model = strapi.getModel(prop('__component', item));
-      const schema = yup
-        .object()
-        .shape({
-          __component: yup
-            .string()
-            .required()
-            .oneOf(Object.keys(strapi.components)),
-        })
-        .notNull();
-
-      return model
-        ? schema.concat(createModelValidator(createOrUpdate)({ model, data: item }, { isDraft }))
-        : schema;
-    })
-  );
-  validator = addRequiredValidation(createOrUpdate)(validator, { attr: { required: true } });
-  validator = addMinMax(validator, { attr, updatedAttribute });
 
-  return validator;
-};
+    return validator;
+  };
 
-const createRelationValidator = createOrUpdate => ({ attr, updatedAttribute }, { isDraft }) => {
-  let validator;
+const createRelationValidator =
+  (createOrUpdate) =>
+  ({ attr, updatedAttribute }, { isDraft }) => {
+    let validator;
 
-  if (Array.isArray(updatedAttribute.value)) {
-    validator = yup.array().of(yup.mixed());
-  } else {
-    validator = yup.mixed();
-  }
+    if (Array.isArray(updatedAttribute.value)) {
+      validator = yup.array().of(yup.mixed());
+    } else {
+      validator = yup.mixed();
+    }
 
-  validator = addRequiredValidation(createOrUpdate)(validator, {
-    attr: { required: !isDraft && attr.required },
-  });
+    validator = addRequiredValidation(createOrUpdate)(validator, {
+      attr: { required: !isDraft && attr.required },
+    });
 
-  return validator;
-};
+    return validator;
+  };
 
-const createScalarAttributeValidator = createOrUpdate => (metas, options) => {
+const createScalarAttributeValidator = (createOrUpdate) => (metas, options) => {
   let validator;
 
   if (has(metas.attr.type, validators)) {
@@ -145,7 +153,7 @@ const createScalarAttributeValidator = createOrUpdate => (metas, options) => {
   return validator;
 };
 
-const createAttributeValidator = createOrUpdate => (metas, options) => {
+const createAttributeValidator = (createOrUpdate) => (metas, options) => {
   let validator;
 
   if (isMediaAttribute(metas.attr)) {
@@ -169,50 +177,49 @@ const createAttributeValidator = createOrUpdate => (metas, options) => {
   return validator;
 };
 
-const createModelValidator = createOrUpdate => ({ model, data, entity }, options) => {
-  const writableAttributes = model ? getWritableAttributes(model) : [];
+const createModelValidator =
+  (createOrUpdate) =>
+  ({ model, data, entity }, options) => {
+    const writableAttributes = model ? getWritableAttributes(model) : [];
+
+    const schema = writableAttributes.reduce((validators, attributeName) => {
+      const validator = createAttributeValidator(createOrUpdate)(
+        {
+          attr: model.attributes[attributeName],
+          updatedAttribute: { name: attributeName, value: prop(attributeName, data) },
+          model,
+          entity,
+        },
+        options
+      );
 
-  const schema = writableAttributes.reduce((validators, attributeName) => {
-    const validator = createAttributeValidator(createOrUpdate)(
-      {
-        attr: model.attributes[attributeName],
-        updatedAttribute: { name: attributeName, value: prop(attributeName, data) },
-        model,
-        entity,
-      },
-      options
-    );
+      return assoc(attributeName, validator)(validators);
+    }, {});
 
-    return assoc(attributeName, validator)(validators);
-  }, {});
+    return yup.object().shape(schema);
+  };
 
-  return yup.object().shape(schema);
-};
+const createValidateEntity =
+  (createOrUpdate) =>
+  async (model, data, { isDraft = false } = {}, entity = null) => {
+    if (!isObject(data)) {
+      const { displayName } = model.info;
 
-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}`
-    );
-  }
+      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);
-};
+    const validator = createModelValidator(createOrUpdate)(
+      {
+        model,
+        data,
+        entity,
+      },
+      { isDraft }
+    ).required();
+    return validateYupSchema(validator, { strict: false, abortEarly: false })(data);
+  };
 
 module.exports = {
   validateEntityCreation: createValidateEntity('creation'),

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

@@ -13,17 +13,20 @@ const { yup } = require('@strapi/utils');
 /**
  * Utility function to compose validators
  */
-const composeValidators = (...fns) => (...args) => {
-  let validator = yup.mixed();
-
-  // if we receive a schema then use it as base schema for nested composition
-  if (yup.isSchema(args[0])) {
-    validator = args[0];
-    args = args.slice(1);
-  }
+const composeValidators =
+  (...fns) =>
+  (...args) => {
+    let nextArgs = args;
+    let validator = yup.mixed();
+
+    // if we receive a schema then use it as base schema for nested composition
+    if (yup.isSchema(args[0])) {
+      validator = args[0];
+      nextArgs = args.slice(1);
+    }
 
-  return fns.reduce((validator, fn) => fn(validator, ...args), validator);
-};
+    return fns.reduce((validator, fn) => fn(validator, ...nextArgs), validator);
+  };
 
 /* Validator utils */
 
@@ -124,7 +127,7 @@ const addUniqueValidator = (validator, { attr, model, updatedAttribute, entity }
     return validator;
   }
 
-  return validator.test('unique', 'This attribute must be unique', async value => {
+  return validator.test('unique', 'This attribute must be unique', async (value) => {
     /**
      * If the attribute value is `null` we want to skip the unique validation.
      * Otherwise it'll only accept a single `null` entry in the database.
@@ -143,7 +146,7 @@ const addUniqueValidator = (validator, { attr, model, updatedAttribute, entity }
       return true;
     }
 
-    let whereParams = entity
+    const whereParams = entity
       ? { $and: [{ [updatedAttribute.name]: value }, { $not: { id: entity.id } }] }
       : { [updatedAttribute.name]: value };
 
@@ -166,12 +169,12 @@ const stringValidator = composeValidators(
   addUniqueValidator
 );
 
-const emailValidator = composeValidators(stringValidator, validator =>
+const emailValidator = composeValidators(stringValidator, (validator) =>
   validator.email().min(1, '${path} cannot be empty')
 );
 
-const uidValidator = composeValidators(stringValidator, validator =>
-  validator.matches(new RegExp('^[A-Za-z0-9-_.~]*$'))
+const uidValidator = composeValidators(stringValidator, (validator) =>
+  validator.matches(/^[A-Za-z0-9-_.~]*$/)
 );
 
 const enumerationValidator = ({ attr }) => {

package/lib/services/errors.js

@@ -1,12 +1,8 @@
 'use strict';
 
 const createError = require('http-errors');
-const {
-  NotFoundError,
-  UnauthorizedError,
-  ForbiddenError,
-  PayloadTooLargeError,
-} = require('@strapi/utils').errors;
+const { NotFoundError, UnauthorizedError, ForbiddenError, PayloadTooLargeError } =
+  require('@strapi/utils').errors;
 
 const mapErrorsAndStatus = [
   {
@@ -27,8 +23,8 @@ const mapErrorsAndStatus = [
   },
 ];
 
-const formatApplicationError = error => {
-  const errorAndStatus = mapErrorsAndStatus.find(pair => error instanceof pair.classError);
+const formatApplicationError = (error) => {
+  const errorAndStatus = mapErrorsAndStatus.find((pair) => error instanceof pair.classError);
   const status = errorAndStatus ? errorAndStatus.status : 400;
 
   return {
@@ -45,7 +41,7 @@ const formatApplicationError = error => {
   };
 };
 
-const formatHttpError = error => {
+const formatHttpError = (error) => {
   return {
     status: error.status,
     body: {
@@ -60,7 +56,7 @@ const formatHttpError = error => {
   };
 };
 
-const formatInternalError = error => {
+const formatInternalError = (error) => {
   const httpError = createError(error);
 
   if (httpError.expose) {

package/lib/services/event-hub.js

@@ -1,6 +1,7 @@
 /**
  * The event hub is Strapi's event control center.
  */
+
 'use strict';
 
 const EventEmitter = require('events');

package/lib/services/fs.js

@@ -6,7 +6,7 @@ const fse = require('fs-extra');
 /**
  * create strapi fs layer
  */
-module.exports = strapi => {
+module.exports = (strapi) => {
   function normalizePath(optPath) {
     const filePath = Array.isArray(optPath) ? optPath.join('/') : optPath;
 

package/lib/services/metrics/index.js

@@ -1,4 +1,5 @@
 'use strict';
+
 /**
  * Strapi telemetry package.
  * You can learn more at https://docs.strapi.io/developer-docs/latest/getting-started/usage-information.html
@@ -22,7 +23,7 @@ const LIMITED_EVENTS = [
   'didEnableResponsiveDimensions',
 ];
 
-const createTelemetryInstance = strapi => {
+const createTelemetryInstance = (strapi) => {
   const uuid = strapi.config.get('uuid');
   const telemetryDisabled = strapi.config.get('packageJsonStrapi.telemetryDisabled');
   const isDisabled =
@@ -76,7 +77,7 @@ const createTelemetryInstance = strapi => {
     },
     destroy() {
       // clear open handles
-      crons.forEach(cron => cron.cancel());
+      crons.forEach((cron) => cron.cancel());
     },
     async send(event, payload) {
       if (isDisabled) return true;
@@ -85,16 +86,12 @@ const createTelemetryInstance = strapi => {
   };
 };
 
-const hash = str =>
-  crypto
-    .createHash('sha256')
-    .update(str)
-    .digest('hex');
+const hash = (str) => crypto.createHash('sha256').update(str).digest('hex');
 
-const hashProject = strapi =>
+const hashProject = (strapi) =>
   hash(`${strapi.config.get('info.name')}${strapi.config.get('info.description')}`);
 
-const hashDep = strapi => {
+const hashDep = (strapi) => {
   const depStr = JSON.stringify(strapi.config.info.dependencies);
   const readmePath = path.join(strapi.dirs.app.root, 'README.md');
 

package/lib/services/metrics/is-truthy.js

@@ -2,7 +2,7 @@
 
 const _ = require('lodash');
 
-const isTruthy = val => {
+const isTruthy = (val) => {
   return [1, true].includes(val) || ['true', '1'].includes(_.toLower(val));
 };