@strapi/admin 4.3.2 → 4.3.5

package/server/services/project-settings.js

@@ -8,11 +8,11 @@ const DEFAULT_PROJECT_SETTINGS = {
   menuLogo: null,
 };
 
-const parseFilesData = async files => {
+const parseFilesData = async (files) => {
   const formatedFilesData = {};
 
   await Promise.all(
-    PROJECT_SETTINGS_FILE_INPUTS.map(async inputName => {
+    PROJECT_SETTINGS_FILE_INPUTS.map(async (inputName) => {
       const file = files[inputName];
 
       // Skip empty file inputs
@@ -23,7 +23,7 @@ const parseFilesData = async files => {
       const getStream = () => fs.createReadStream(file.path);
 
       // Add formated data for the upload provider
-      formatedFilesData[inputName] = strapi
+      formatedFilesData[inputName] = await strapi
         .plugin('upload')
         .service('upload')
         .formatFileInfo({
@@ -35,10 +35,7 @@ const parseFilesData = async files => {
       // Add image dimensions
       Object.assign(
         formatedFilesData[inputName],
-        await strapi
-          .plugin('upload')
-          .service('image-manipulation')
-          .getDimensions({ getStream })
+        await strapi.plugin('upload').service('image-manipulation').getDimensions({ getStream })
       );
 
       // Add file path, and stream
@@ -61,7 +58,7 @@ const getProjectSettings = async () => {
   };
 
   // Filter file input fields
-  PROJECT_SETTINGS_FILE_INPUTS.forEach(inputName => {
+  PROJECT_SETTINGS_FILE_INPUTS.forEach((inputName) => {
     if (!projectSettings[inputName]) {
       return;
     }
@@ -83,14 +80,14 @@ const uploadFiles = async (files = {}) => {
   // Call the provider upload function for each file
   return Promise.all(
     Object.values(files)
-      .filter(file => file.stream instanceof fs.ReadStream)
-      .map(file => strapi.plugin('upload').provider.uploadStream(file))
+      .filter((file) => file.stream instanceof fs.ReadStream)
+      .map((file) => strapi.plugin('upload').provider.uploadStream(file))
   );
 };
 
 const deleteOldFiles = async ({ previousSettings, newSettings }) => {
   return Promise.all(
-    PROJECT_SETTINGS_FILE_INPUTS.map(async inputName => {
+    PROJECT_SETTINGS_FILE_INPUTS.map(async (inputName) => {
       // Skip if the store doesn't contain project settings
       if (!previousSettings) {
         return;
@@ -121,14 +118,14 @@ const deleteOldFiles = async ({ previousSettings, newSettings }) => {
   );
 };
 
-const updateProjectSettings = async newSettings => {
+const updateProjectSettings = async (newSettings) => {
   const store = strapi.store({ type: 'core', name: 'admin' });
   const previousSettings = await store.get({ key: 'project-settings' });
   const files = pick(newSettings, PROJECT_SETTINGS_FILE_INPUTS);
 
   await uploadFiles(files);
 
-  PROJECT_SETTINGS_FILE_INPUTS.forEach(inputName => {
+  PROJECT_SETTINGS_FILE_INPUTS.forEach((inputName) => {
     // If the user input exists but is not a formdata "file" remove it
     if (newSettings[inputName] !== undefined && !(typeof newSettings[inputName] === 'object')) {
       newSettings[inputName] = null;

package/server/services/role.js

@@ -27,7 +27,7 @@ const sanitizeRole = omit(['users', 'permissions']);
 const COMPARABLE_FIELDS = ['conditions', 'properties', 'subject', 'action'];
 const pickComparableFields = pick(COMPARABLE_FIELDS);
 
-const jsonClean = data => JSON.parse(JSON.stringify(data));
+const jsonClean = (data) => JSON.parse(JSON.stringify(data));
 
 /**
  * Compare two permissions
@@ -48,7 +48,7 @@ const arePermissionsEqual = (p1, p2) => {
  * @param attributes A partial role object
  * @returns {Promise<role>}
  */
-const create = async attributes => {
+const create = async (attributes) => {
   const alreadyExists = await exists({ name: attributes.name });
 
   if (alreadyExists) {
@@ -107,9 +107,9 @@ const find = (params = {}, populate) => {
  * Find all roles in database
  * @returns {Promise<array>}
  */
-const findAllWithUsersCount = async populate => {
+const findAllWithUsersCount = async (populate) => {
   const roles = await strapi.query('admin::role').findMany({ populate });
-  for (let role of roles) {
+  for (const role of roles) {
     role.usersCount = await getUsersCount(role.id);
   }
 
@@ -171,7 +171,7 @@ const checkRolesIdForDeletion = async (ids = []) => {
     throw new ApplicationError('You cannot delete the super admin role');
   }
 
-  for (let roleId of ids) {
+  for (const roleId of ids) {
     const usersCount = await getUsersCount(roleId);
     if (usersCount !== 0) {
       throw new ApplicationError('Some roles are still assigned to some users');
@@ -205,7 +205,7 @@ const deleteByIds = async (ids = []) => {
  * @returns {Promise<number>}
  * @param roleId
  */
-const getUsersCount = async roleId => {
+const getUsersCount = async (roleId) => {
   return strapi.query('admin::user').count({ where: { roles: { id: roleId } } });
 };
 
@@ -231,7 +231,7 @@ const createRolesIfNoneExist = async () => {
   const { actionProvider } = getService('permission');
 
   const allActions = actionProvider.values();
-  const contentTypesActions = allActions.filter(a => a.section === 'contentTypes');
+  const contentTypesActions = allActions.filter((a) => a.section === 'contentTypes');
 
   // create 3 roles
   const superAdminRole = await create({
@@ -264,7 +264,7 @@ const createRolesIfNoneExist = async () => {
 
   const authorPermissions = editorPermissions
     .filter(({ action }) => action !== ACTIONS.publish)
-    .map(permission =>
+    .map((permission) =>
       permissionDomain.create({ ...permission, conditions: ['admin::is-creator'] })
     );
 
@@ -368,7 +368,7 @@ const addPermissions = async (roleId, permissions) => {
   return createMany(permissionsWithRole);
 };
 
-const isContentTypeAction = action => action.section === CONTENT_TYPE_SECTION;
+const isContentTypeAction = (action) => action.section === CONTENT_TYPE_SECTION;
 
 /**
  * Reset super admin permissions (giving it all permissions)
@@ -385,8 +385,8 @@ const resetSuperAdminPermissions = async () => {
 
   const allActions = permissionService.actionProvider.values();
 
-  const contentTypesActions = allActions.filter(action => isContentTypeAction(action));
-  const otherActions = allActions.filter(action => !isContentTypeAction(action));
+  const contentTypesActions = allActions.filter((action) => isContentTypeAction(action));
+  const otherActions = allActions.filter((action) => !isContentTypeAction(action));
 
   // First, get the content-types permissions
   const permissions = contentTypeService.getPermissionsWithNestedFields(contentTypesActions);
@@ -396,7 +396,9 @@ const resetSuperAdminPermissions = async () => {
     const { actionId, subjects } = action;
 
     if (isArray(subjects)) {
-      acc.push(...subjects.map(subject => permissionDomain.create({ action: actionId, subject })));
+      acc.push(
+        ...subjects.map((subject) => permissionDomain.create({ action: actionId, subject }))
+      );
     } else {
       acc.push(permissionDomain.create({ action: actionId }));
     }
@@ -416,7 +418,7 @@ const resetSuperAdminPermissions = async () => {
  * @param {object} user
  * @return {boolean}
  */
-const hasSuperAdminRole = user => {
+const hasSuperAdminRole = (user) => {
   const roles = _.get(user, 'roles', []);
 
   return roles.map(prop('code')).includes(SUPER_ADMIN_CODE);

package/server/services/token.js

@@ -27,7 +27,7 @@ const createToken = () => {
  * Creates a JWT token for an administration user
  * @param {object} user - admin user
  */
-const createJwtToken = user => {
+const createJwtToken = (user) => {
   const { options, secret } = getTokenOptions();
 
   return jwt.sign({ id: user.id }, secret, options);
@@ -38,7 +38,7 @@ const createJwtToken = user => {
  * @param {string} token - a token to decode
  * @return {Object} decodeInfo - the decoded info
  */
-const decodeJwtToken = token => {
+const decodeJwtToken = (token) => {
   const { secret } = getTokenOptions();
 
   try {

package/server/services/user.js

@@ -9,13 +9,13 @@ const { password: passwordValidator } = require('../validation/common-validators
 const { getService } = require('../utils');
 const { SUPER_ADMIN_CODE } = require('./constants');
 
-const sanitizeUserRoles = role => _.pick(role, ['id', 'name', 'description', 'code']);
+const sanitizeUserRoles = (role) => _.pick(role, ['id', 'name', 'description', 'code']);
 
 /**
  * Remove private user fields
  * @param {Object} user - user to sanitize
  */
-const sanitizeUser = user => {
+const sanitizeUser = (user) => {
   return {
     ..._.omit(user, ['password', 'resetPasswordToken', 'registrationToken', 'roles']),
     roles: user.roles && user.roles.map(sanitizeUserRoles),
@@ -27,7 +27,7 @@ const sanitizeUser = user => {
  * @param attributes A partial user object
  * @returns {Promise<user>}
  */
-const create = async attributes => {
+const create = async (attributes) => {
   const userInfo = {
     registrationToken: getService('token').createToken(),
     ...attributes,
@@ -120,7 +120,7 @@ const resetPasswordByEmail = async (email, password) => {
  * Check if a user is the last super admin
  * @param {int|string} userId user's id to look for
  */
-const isLastSuperAdminUser = async userId => {
+const isLastSuperAdminUser = async (userId) => {
   const user = await findOne(userId);
   const superAdminRole = await getService('role').getSuperAdminWithUsersCount();
 
@@ -141,7 +141,7 @@ const exists = async (attributes = {}) => {
  * @param {string} registrationToken - a user registration token
  * @returns {Promise<registrationInfo>} - Returns user email, firstname and lastname
  */
-const findRegistrationInfo = async registrationToken => {
+const findRegistrationInfo = async (registrationToken) => {
   const user = await strapi.query('admin::user').findOne({ where: { registrationToken } });
 
   if (!user) {
@@ -206,7 +206,7 @@ const findPage = async (query = {}) => {
  * @param id id of the user to delete
  * @returns {Promise<user>}
  */
-const deleteById = async id => {
+const deleteById = async (id) => {
   // Check at least one super admin remains
   const userToDelete = await strapi.query('admin::user').findOne({
     where: { id },
@@ -218,7 +218,7 @@ const deleteById = async id => {
   }
 
   if (userToDelete) {
-    if (userToDelete.roles.some(r => r.code === SUPER_ADMIN_CODE)) {
+    if (userToDelete.roles.some((r) => r.code === SUPER_ADMIN_CODE)) {
       const superAdminRole = await getService('role').getSuperAdminWithUsersCount();
       if (superAdminRole.usersCount === 1) {
         throw new ValidationError('You must have at least one user with super admin role.');
@@ -233,7 +233,7 @@ const deleteById = async id => {
  * @param ids ids of the users to delete
  * @returns {Promise<user>}
  */
-const deleteByIds = async ids => {
+const deleteByIds = async (ids) => {
   // Check at least one super admin remains
   const superAdminRole = await getService('role').getSuperAdminWithUsersCount();
   const nbOfSuperAdminToDelete = await strapi.query('admin::user').count({
@@ -285,7 +285,7 @@ const count = async (where = {}) => {
 /** Assign some roles to several users
  * @returns {undefined}
  */
-const assignARoleToAll = async roleId => {
+const assignARoleToAll = async (roleId) => {
   const users = await strapi.query('admin::user').findMany({
     select: ['id'],
     where: {
@@ -294,7 +294,7 @@ const assignARoleToAll = async roleId => {
   });
 
   await Promise.all(
-    users.map(user => {
+    users.map((user) => {
       return strapi.query('admin::user').update({
         where: { id: user.id },
         data: { roles: [roleId] },
@@ -320,7 +320,7 @@ const displayWarningIfUsersDontHaveRole = async () => {
 const getLanguagesInUse = async () => {
   const users = await strapi.query('admin::user').findMany({ select: ['preferedLanguage'] });
 
-  return users.map(user => user.preferedLanguage || 'en');
+  return users.map((user) => user.preferedLanguage || 'en');
 };
 
 module.exports = {

package/server/strategies/admin.js

@@ -3,7 +3,7 @@
 const { getService } = require('../utils');
 
 /** @type {import('.').AuthenticateFunction} */
-const authenticate = async ctx => {
+const authenticate = async (ctx) => {
   const { authorization } = ctx.request.header;
 
   if (!authorization) {

package/server/strategies/api-token.js

@@ -4,9 +4,9 @@ const { UnauthorizedError, ForbiddenError } = require('@strapi/utils').errors;
 const constants = require('../services/constants');
 const { getService } = require('../utils');
 
-const isReadScope = scope => scope.endsWith('find') || scope.endsWith('findOne');
+const isReadScope = (scope) => scope.endsWith('find') || scope.endsWith('findOne');
 
-const extractToken = ctx => {
+const extractToken = (ctx) => {
   if (ctx.request && ctx.request.header && ctx.request.header.authorization) {
     const parts = ctx.request.header.authorization.split(/\s+/);
 
@@ -21,7 +21,7 @@ const extractToken = ctx => {
 };
 
 /** @type {import('.').AuthenticateFunction} */
-const authenticate = async ctx => {
+const authenticate = async (ctx) => {
   const apiTokenService = getService('api-token');
   const token = extractToken(ctx);
 

package/server/utils/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const getService = name => {
+const getService = (name) => {
   return strapi.service(`admin::${name}`);
 };
 

package/server/validation/action-provider.js

@@ -14,13 +14,10 @@ const registerProviderActionSchema = yup
           .string()
           .matches(
             /^[a-z]([a-z|.|-]+)[a-z]$/,
-            v => `${v.path}: The id can only contain lowercase letters, dots and hyphens.`
+            (v) => `${v.path}: The id can only contain lowercase letters, dots and hyphens.`
           )
           .required(),
-        section: yup
-          .string()
-          .oneOf(['contentTypes', 'plugins', 'settings'])
-          .required(),
+        section: yup.string().oneOf(['contentTypes', 'plugins', 'settings']).required(),
         pluginName: yup.mixed().when('section', {
           is: 'plugins',
           then: validators.isAPluginName.required(),
@@ -28,10 +25,7 @@ const registerProviderActionSchema = yup
         }),
         subjects: yup.mixed().when('section', {
           is: 'contentTypes',
-          then: yup
-            .array()
-            .of(yup.string())
-            .required(),
+          then: yup.array().of(yup.string()).required(),
           otherwise: yup
             .mixed()
             .oneOf([undefined], 'subjects should only be defined for the "contentTypes" section'),
@@ -45,18 +39,18 @@ const registerProviderActionSchema = yup
             .test(
               'settingsCategory',
               'category should only be defined for the "settings" section',
-              cat => cat === undefined
+              (cat) => cat === undefined
             ),
         }),
         subCategory: yup.mixed().when('section', {
-          is: section => ['settings', 'plugins'].includes(section),
+          is: (section) => ['settings', 'plugins'].includes(section),
           then: yup.string(),
           otherwise: yup
             .mixed()
             .test(
               'settingsSubCategory',
               'subCategory should only be defined for "plugins" and "settings" sections',
-              subCat => {
+              (subCat) => {
                 return subCat === undefined;
               }
             ),

package/server/validation/api-tokens.js

@@ -6,30 +6,18 @@ const constants = require('../services/constants');
 const apiTokenCreationSchema = yup
   .object()
   .shape({
-    name: yup
-      .string()
-      .min(1)
-      .required(),
+    name: yup.string().min(1).required(),
     description: yup.string().optional(),
-    type: yup
-      .string()
-      .oneOf(Object.values(constants.API_TOKEN_TYPE))
-      .required(),
+    type: yup.string().oneOf(Object.values(constants.API_TOKEN_TYPE)).required(),
   })
   .noUnknown();
 
 const apiTokenUpdateSchema = yup
   .object()
   .shape({
-    name: yup
-      .string()
-      .min(1)
-      .notNull(),
+    name: yup.string().min(1).notNull(),
     description: yup.string().nullable(),
-    type: yup
-      .string()
-      .oneOf(Object.values(constants.API_TOKEN_TYPE))
-      .notNull(),
+    type: yup.string().oneOf(Object.values(constants.API_TOKEN_TYPE)).notNull(),
   })
   .noUnknown();
 

package/server/validation/authentication/renew-token.js

@@ -2,10 +2,6 @@
 
 const { yup, validateYupSchema } = require('@strapi/utils');
 
-const renewToken = yup
-  .object()
-  .shape({ token: yup.string().required() })
-  .required()
-  .noUnknown();
+const renewToken = yup.object().shape({ token: yup.string().required() }).required().noUnknown();
 
 module.exports = validateYupSchema(renewToken);

package/server/validation/common-functions/check-fields-are-correctly-nested.js

@@ -2,11 +2,12 @@
 
 const _ = require('lodash');
 
-const checkFieldsAreCorrectlyNested = fields => {
+const checkFieldsAreCorrectlyNested = (fields) => {
   if (_.isNil(fields)) {
     // Only check if the fields exist
     return true;
-  } else if (!Array.isArray(fields)) {
+  }
+  if (!Array.isArray(fields)) {
     return false;
   }
 
@@ -15,7 +16,8 @@ const checkFieldsAreCorrectlyNested = fields => {
     failed = fields
       .slice(indexA + 1)
       .some(
-        fieldB => fieldB.startsWith(`${fields[indexA]}.`) || fields[indexA].startsWith(`${fieldB}.`)
+        (fieldB) =>
+          fieldB.startsWith(`${fields[indexA]}.`) || fields[indexA].startsWith(`${fieldB}.`)
       );
     if (failed) break;
   }

package/server/validation/common-functions/check-fields-dont-have-duplicates.js

@@ -2,11 +2,12 @@
 
 const _ = require('lodash');
 
-const checkFieldsDontHaveDuplicates = fields => {
+const checkFieldsDontHaveDuplicates = (fields) => {
   if (_.isNil(fields)) {
     // Only check if the fields exist
     return true;
-  } else if (!Array.isArray(fields)) {
+  }
+  if (!Array.isArray(fields)) {
     return false;
   }