@strapi/admin 4.3.4 → 4.3.7

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;
   }
 

package/server/validation/common-validators.js

@@ -10,14 +10,11 @@ const {
   checkFieldsDontHaveDuplicates,
 } = require('./common-functions');
 
-const getActionFromProvider = actionId => {
+const getActionFromProvider = (actionId) => {
   return getService('permission').actionProvider.get(actionId);
 };
 
-const email = yup
-  .string()
-  .email()
-  .lowercase();
+const email = yup.string().email().lowercase();
 
 const firstname = yup.string().min(1);
 
@@ -36,7 +33,7 @@ const roles = yup.array(yup.strapiID()).min(1);
 
 const isAPluginName = yup
   .string()
-  .test('is-a-plugin-name', 'is not a plugin name', function(value) {
+  .test('is-a-plugin-name', 'is not a plugin name', function (value) {
     return [undefined, 'admin', ...Object.keys(strapi.plugins)].includes(value)
       ? true
       : this.createError({ path: this.path, message: `${this.path} is not an existing plugin` });
@@ -45,7 +42,7 @@ const isAPluginName = yup
 const arrayOfConditionNames = yup
   .array()
   .of(yup.string())
-  .test('is-an-array-of-conditions', 'is not a plugin name', function(value) {
+  .test('is-an-array-of-conditions', 'is not a plugin name', function (value) {
     const ids = strapi.admin.services.permission.conditionProvider.keys();
     return _.isUndefined(value) || _.difference(value, ids).length === 0
       ? true
@@ -55,14 +52,14 @@ const arrayOfConditionNames = yup
 const permissionsAreEquals = (a, b) =>
   a.action === b.action && (a.subject === b.subject || (_.isNil(a.subject) && _.isNil(b.subject)));
 
-const checkNoDuplicatedPermissions = permissions =>
+const checkNoDuplicatedPermissions = (permissions) =>
   !Array.isArray(permissions) ||
   permissions.every((permA, i) =>
-    permissions.slice(i + 1).every(permB => !permissionsAreEquals(permA, permB))
+    permissions.slice(i + 1).every((permB) => !permissionsAreEquals(permA, permB))
   );
 
-const checkNilFields = action =>
-  function(fields) {
+const checkNilFields = (action) =>
+  function (fields) {
     // If the parent has no action field, then we ignore this test
     if (isNil(action)) {
       return true;
@@ -71,7 +68,7 @@ const checkNilFields = action =>
     return actionDomain.appliesToProperty('fields', action) || isNil(fields);
   };
 
-const fieldsPropertyValidation = action =>
+const fieldsPropertyValidation = (action) =>
   yup
     .array()
     .of(yup.string())
@@ -105,20 +102,22 @@ const updatePermissions = yup
             action: yup
               .string()
               .required()
-              .test('action-validity', 'action is not an existing permission action', function(
-                actionId
-              ) {
-                // If the action field is Nil, ignore the test and let the required check handle the error
-                if (isNil(actionId)) {
-                  return true;
+              .test(
+                'action-validity',
+                'action is not an existing permission action',
+                function (actionId) {
+                  // If the action field is Nil, ignore the test and let the required check handle the error
+                  if (isNil(actionId)) {
+                    return true;
+                  }
+
+                  return !!getActionFromProvider(actionId);
                 }
-
-                return !!getActionFromProvider(actionId);
-              }),
+              ),
             subject: yup
               .string()
               .nullable()
-              .test('subject-validity', 'Invalid subject submitted', function(subject) {
+              .test('subject-validity', 'Invalid subject submitted', function (subject) {
                 const action = getActionFromProvider(this.options.parent.action);
 
                 if (!action) {
@@ -137,57 +136,61 @@ const updatePermissions = yup
               }),
             properties: yup
               .object()
-              .test('properties-structure', 'Invalid property set at ${path}', function(
-                properties
-              ) {
-                const action = getActionFromProvider(this.options.parent.action);
-                const hasNoProperties = isEmpty(properties) || isNil(properties);
-
-                if (!has('options.applyToProperties', action)) {
-                  return hasNoProperties;
+              .test(
+                'properties-structure',
+                'Invalid property set at ${path}',
+                function (properties) {
+                  const action = getActionFromProvider(this.options.parent.action);
+                  const hasNoProperties = isEmpty(properties) || isNil(properties);
+
+                  if (!has('options.applyToProperties', action)) {
+                    return hasNoProperties;
+                  }
+
+                  if (hasNoProperties) {
+                    return true;
+                  }
+
+                  const { applyToProperties } = action.options;
+
+                  if (!isArray(applyToProperties)) {
+                    return false;
+                  }
+
+                  return Object.keys(properties).every((property) =>
+                    applyToProperties.includes(property)
+                  );
                 }
-
-                if (hasNoProperties) {
-                  return true;
-                }
-
-                const { applyToProperties } = action.options;
-
-                if (!isArray(applyToProperties)) {
-                  return false;
+              )
+              .test(
+                'fields-property',
+                'Invalid fields property at ${path}',
+                async function (properties = {}) {
+                  const action = getActionFromProvider(this.options.parent.action);
+
+                  if (!action || !properties) {
+                    return true;
+                  }
+
+                  if (!actionDomain.appliesToProperty('fields', action)) {
+                    return true;
+                  }
+
+                  try {
+                    await fieldsPropertyValidation(action).validate(properties.fields, {
+                      strict: true,
+                      abortEarly: false,
+                    });
+                    return true;
+                  } catch (e) {
+                    // Propagate fieldsPropertyValidation error with updated path
+                    throw this.createError({
+                      message: e.message,
+                      path: `${this.path}.fields`,
+                    });
+                  }
                 }
-
-                return Object.keys(properties).every(property =>
-                  applyToProperties.includes(property)
-                );
-              })
-              .test('fields-property', 'Invalid fields property at ${path}', async function(
-                properties = {}
-              ) {
-                const action = getActionFromProvider(this.options.parent.action);
-
-                if (!action || !properties) {
-                  return true;
-                }
-
-                if (!actionDomain.appliesToProperty('fields', action)) {
-                  return true;
-                }
-
-                try {
-                  await fieldsPropertyValidation(action).validate(properties.fields, {
-                    strict: true,
-                    abortEarly: false,
-                  });
-                  return true;
-                } catch (e) {
-                  // Propagate fieldsPropertyValidation error with updated path
-                  throw this.createError({
-                    message: e.message,
-                    path: `${this.path}.fields`,
-                  });
-                }
-              }),
+              ),
             conditions: yup.array().of(yup.string()),
           })
           .noUnknown()

package/server/validation/permission.js

@@ -21,12 +21,12 @@ const actionFieldsAreEqual = (a, b) => {
 };
 
 const haveSameFieldsAsOtherActions = (a, i, allActions) =>
-  allActions.slice(i + 1).every(b => actionFieldsAreEqual(a, b));
+  allActions.slice(i + 1).every((b) => actionFieldsAreEqual(a, b));
 
-const checkPermissionsAreBound = role =>
-  function(permissions) {
+const checkPermissionsAreBound = (role) =>
+  function (permissions) {
     const permsBySubject = _.groupBy(
-      permissions.filter(perm => BOUND_ACTIONS.includes(perm.action)),
+      permissions.filter((perm) => BOUND_ACTIONS.includes(perm.action)),
       'subject'
     );
 
@@ -34,12 +34,12 @@ const checkPermissionsAreBound = role =>
       const boundActions = getBoundActionsBySubject(role, subject);
       const missingActions =
         _.xor(
-          perms.map(p => p.action),
+          perms.map((p) => p.action),
           boundActions
         ).length !== 0;
       if (missingActions) return false;
 
-      const permsBoundByFields = perms.filter(p => BOUND_ACTIONS_FOR_FIELDS.includes(p.action));
+      const permsBoundByFields = perms.filter((p) => BOUND_ACTIONS_FOR_FIELDS.includes(p.action));
       const everyActionsHaveSameFields = _.every(permsBoundByFields, haveSameFieldsAsOtherActions);
       if (!everyActionsHaveSameFields) return false;
     }
@@ -47,15 +47,15 @@ const checkPermissionsAreBound = role =>
     return true;
   };
 
-const noPublishPermissionForAuthorRole = role =>
-  function(permissions) {
+const noPublishPermissionForAuthorRole = (role) =>
+  function (permissions) {
     const isAuthor = role.code === AUTHOR_CODE;
-    const hasPublishPermission = permissions.some(perm => perm.action === PUBLISH_ACTION);
+    const hasPublishPermission = permissions.some((perm) => perm.action === PUBLISH_ACTION);
 
     return !(isAuthor && hasPublishPermission);
   };
 
-const getUpdatePermissionsSchemas = role => [
+const getUpdatePermissionsSchemas = (role) => [
   validators.updatePermissions,
   yup.object().shape({ permissions: actionsExistSchema.clone() }),
   yup.object().shape({
@@ -100,12 +100,12 @@ const validatedUpdatePermissionsInput = async (permissions, role) => {
 
 // validatePermissionsExist
 
-const checkPermissionsExist = function(permissions) {
+const checkPermissionsExist = function (permissions) {
   const existingActions = getService('permission').actionProvider.values();
   const failIndex = permissions.findIndex(
-    permission =>
+    (permission) =>
       !existingActions.some(
-        action =>
+        (action) =>
           action.actionId === permission.action &&
           (action.section !== 'contentTypes' || action.subjects.includes(permission.subject))
       )

package/server/validation/policies/hasPermissions.js

@@ -5,13 +5,9 @@ const { yup, validateYupSchema } = require('@strapi/utils');
 
 const hasPermissionsSchema = yup.object({
   actions: yup.array().of(
-    yup.lazy(val => {
+    yup.lazy((val) => {
       if (_.isArray(val)) {
-        return yup
-          .array()
-          .of(yup.string())
-          .min(1)
-          .max(2);
+        return yup.array().of(yup.string()).min(1).max(2);
       }
 
       if (_.isString(val)) {

package/server/validation/user.js

@@ -47,11 +47,7 @@ const userUpdateSchema = yup
 const usersDeleteSchema = yup
   .object()
   .shape({
-    ids: yup
-      .array()
-      .of(yup.strapiID())
-      .min(1)
-      .required(),
+    ids: yup.array().of(yup.strapiID()).min(1).required(),
   })
   .noUnknown();
 

package/utils/create-cache-dir.js

@@ -6,7 +6,7 @@ const fs = require('fs-extra');
 const tsUtils = require('@strapi/typescript-utils');
 const getCustomAppConfigFile = require('./get-custom-app-config-file');
 
-const getPkgPath = name => path.dirname(require.resolve(`${name}/package.json`));
+const getPkgPath = (name) => path.dirname(require.resolve(`${name}/package.json`));
 
 async function createPluginsJs(plugins, dest) {
   const pluginsArray = plugins.map(({ pathToPlugin, name }) => {
@@ -77,11 +77,11 @@ async function createCacheDir({ appDir, plugins }) {
   );
 
   const pluginsWithFront = Object.keys(plugins)
-    .filter(pluginName => {
+    .filter((pluginName) => {
       const pluginInfo = plugins[pluginName];
       return fs.existsSync(path.resolve(pluginInfo.pathToPlugin, 'strapi-admin.js'));
     })
-    .map(name => ({ name, ...plugins[name] }));
+    .map((name) => ({ name, ...plugins[name] }));
 
   // create .cache dir
   await fs.emptyDir(cacheDir);

package/utils/get-custom-app-config-file.js

@@ -9,14 +9,14 @@ const { isUsingTypeScript } = require('@strapi/typescript-utils');
  * @param {String} dir - Directory of the admin panel
  * @returns String
  */
-const getCustomAppConfigFile = async dir => {
+const getCustomAppConfigFile = async (dir) => {
   const adminSrcPath = join(dir, 'src', 'admin');
   const useTypeScript = await isUsingTypeScript(adminSrcPath, 'tsconfig.json');
 
   const files = await fse.readdir(adminSrcPath);
 
-  const appJsx = files.find(file => /^app.jsx?$/.test(file));
-  const appTsx = files.find(file => /^app.tsx?$/.test(file));
+  const appJsx = files.find((file) => /^app.jsx?$/.test(file));
+  const appTsx = files.find((file) => /^app.tsx?$/.test(file));
 
   if (useTypeScript) {
     return appTsx || appJsx;

package/utils/get-plugins-path.js

@@ -2,6 +2,7 @@
 
 const { join, resolve } = require('path');
 const fs = require('fs-extra');
+// eslint-disable-next-line import/no-extraneous-dependencies
 const glob = require('glob');
 
 // Only for dev environement
@@ -12,7 +13,7 @@ const getPluginsPath = () => {
   const corePackageDirs = glob.sync(corePath);
   const pluginsPackageDirs = glob.sync(pluginsPath);
 
-  const packageDirs = [...corePackageDirs, ...pluginsPackageDirs].filter(dir => {
+  const packageDirs = [...corePackageDirs, ...pluginsPackageDirs].filter((dir) => {
     const isCoreAdmin = dir.includes('packages/core/admin');
     const pathToEntryPoint = join(dir, 'admin', 'src', 'index.js');
     const doesAdminFolderExist = fs.pathExistsSync(pathToEntryPoint);
@@ -20,7 +21,7 @@ const getPluginsPath = () => {
     return !isCoreAdmin && doesAdminFolderExist;
   });
 
-  return packageDirs.map(dir => resolve(__dirname, '..', join(dir, 'admin', 'src')));
+  return packageDirs.map((dir) => resolve(__dirname, '..', join(dir, 'admin', 'src')));
 };
 
 module.exports = getPluginsPath;