@strapi/admin 4.3.4 → 4.3.5

package/server/services/permission/engine.js

@@ -43,11 +43,11 @@ const allowedOperations = [
 ];
 const operations = pick(allowedOperations, sift);
 
-const conditionsMatcher = conditions => {
+const conditionsMatcher = (conditions) => {
   return sift.createQueryTester(conditions, { operations });
 };
 
-module.exports = conditionProvider => {
+module.exports = (conditionProvider) => {
   const state = {
     hooks: createEngineHooks(),
   };
@@ -112,7 +112,7 @@ module.exports = conditionProvider => {
       );
 
       const permissionWithSanitizedProperties = invalidProperties.reduce(
-        property => permissionDomain.deleteProperty(property, permission),
+        (property) => permissionDomain.deleteProperty(property, permission),
         permission
       );
 
@@ -174,13 +174,13 @@ module.exports = conditionProvider => {
       const resolveConditions = map(conditionProvider.get);
 
       // 2. Filter conditions, only keep those whose handler is a function
-      const filterValidConditions = filter(condition => isFunction(condition.handler));
+      const filterValidConditions = filter((condition) => isFunction(condition.handler));
 
       // 3. Evaluate the conditions handler and returns an object
       // containing both the original condition and its result
-      const evaluateConditions = conditions => {
+      const evaluateConditions = (conditions) => {
         return Promise.all(
-          conditions.map(async condition => ({
+          conditions.map(async (condition) => ({
             condition,
             result: await condition.handler(
               user,
@@ -237,7 +237,7 @@ module.exports = conditionProvider => {
      * @returns {function}
      */
     createRegisterFunction(can, permission, user) {
-      const registerToCasl = caslPermission => {
+      const registerToCasl = (caslPermission) => {
         const { action, subject, fields, condition } = caslPermission;
 
         can(
@@ -248,7 +248,7 @@ module.exports = conditionProvider => {
         );
       };
 
-      const runWillRegisterHook = async caslPermission => {
+      const runWillRegisterHook = async (caslPermission) => {
         const hookContext = createWillRegisterContext(caslPermission, {
           permission,
           user,
@@ -259,7 +259,7 @@ module.exports = conditionProvider => {
         return caslPermission;
       };
 
-      return async caslPermission => {
+      return async (caslPermission) => {
         await runWillRegisterHook(caslPermission);
         registerToCasl(caslPermission);
       };

package/server/services/permission/permissions-manager/query-builers.js

@@ -19,7 +19,7 @@ const operatorsMap = {
   $not: '$not',
 };
 
-const mapKey = key => {
+const mapKey = (key) => {
   if (_.isString(key) && key.startsWith('$') && key in operatorsMap) {
     return operatorsMap[key];
   }
@@ -27,19 +27,19 @@ const mapKey = key => {
 };
 
 const buildCaslQuery = (ability, action, model) => {
-  return rulesToQuery(ability, action, model, o => o.conditions);
+  return rulesToQuery(ability, action, model, (o) => o.conditions);
 };
 
-const buildStrapiQuery = caslQuery => {
+const buildStrapiQuery = (caslQuery) => {
   return unwrapDeep(caslQuery);
 };
 
-const unwrapDeep = obj => {
+const unwrapDeep = (obj) => {
   if (!_.isPlainObject(obj) && !_.isArray(obj)) {
     return obj;
   }
   if (_.isArray(obj)) {
-    return obj.map(v => unwrapDeep(v));
+    return obj.map((v) => unwrapDeep(v));
   }
 
   return _.reduce(

package/server/services/permission/permissions-manager/sanitize.js

@@ -19,12 +19,8 @@ const {
 
 const { contentTypes, traverseEntity, sanitize, pipeAsync } = require('@strapi/utils');
 
-const {
-  constants,
-  getNonVisibleAttributes,
-  getNonWritableAttributes,
-  getWritableAttributes,
-} = contentTypes;
+const { constants, getNonVisibleAttributes, getNonWritableAttributes, getWritableAttributes } =
+  contentTypes;
 const {
   ID_ATTRIBUTE,
   CREATED_AT_ATTRIBUTE,
@@ -73,20 +69,20 @@ module.exports = ({ action, ability, model }) => {
     );
   };
 
-  const wrapSanitize = createSanitizeFunction => {
+  const wrapSanitize = (createSanitizeFunction) => {
     const wrappedSanitize = async (data, options = {}) => {
       if (isArray(data)) {
-        return Promise.all(data.map(entity => wrappedSanitize(entity, options)));
+        return Promise.all(data.map((entity) => wrappedSanitize(entity, options)));
       }
 
       const { subject, action: actionOverride } = getDefaultOptions(data, options);
 
       const permittedFields = permittedFieldsOf(ability, actionOverride, subject, {
-        fieldsFrom: rule => rule.fields || [],
+        fieldsFrom: (rule) => rule.fields || [],
       });
 
       const hasAtLeastOneRegistered = some(
-        fields => !isNil(fields),
+        (fields) => !isNil(fields),
         flatMap(prop('fields'), ability.rulesFor(actionOverride, detectSubjectType(subject)))
       );
       const shouldIncludeAllFields = isEmpty(permittedFields) && !hasAtLeastOneRegistered;

package/server/services/permission/queries.js

@@ -25,7 +25,7 @@ const permissionDomain = require('../../domain/permission/index');
  * @param rolesIds ids of roles
  * @returns {Promise<array>}
  */
-const deleteByRolesIds = async rolesIds => {
+const deleteByRolesIds = async (rolesIds) => {
   const permissionsToDelete = await strapi.query('admin::permission').findMany({
     select: ['id'],
     where: {
@@ -43,7 +43,7 @@ const deleteByRolesIds = async rolesIds => {
  * @param ids ids of permissions
  * @returns {Promise<array>}
  */
-const deleteByIds = async ids => {
+const deleteByIds = async (ids) => {
   for (const id of ids) {
     await strapi.query('admin::permission').delete({ where: { id } });
   }
@@ -54,7 +54,7 @@ const deleteByIds = async ids => {
  * @param permissions
  * @returns {Promise<*[]|*>}
  */
-const createMany = async permissions => {
+const createMany = async (permissions) => {
   const createdPermissions = [];
   for (const permission of permissions) {
     const newPerm = await strapi.query('admin::permission').create({ data: permission });
@@ -94,11 +94,11 @@ const findMany = async (params = {}) => {
  * @param user - user
  * @returns {Promise<Permission[]>}
  */
-const findUserPermissions = async user => {
+const findUserPermissions = async (user) => {
   return findMany({ where: { role: { users: { id: user.id } } } });
 };
 
-const filterPermissionsToRemove = async permissions => {
+const filterPermissionsToRemove = async (permissions) => {
   const { actionProvider } = getService('permission');
 
   const permissionsToRemove = [];
@@ -108,7 +108,7 @@ const filterPermissionsToRemove = async permissions => {
     const { applyToProperties } = options;
 
     const invalidProperties = await Promise.all(
-      (applyToProperties || []).map(async property => {
+      (applyToProperties || []).map(async (property) => {
         const applies = await actionProvider.appliesToProperty(
           property,
           permission.action,
@@ -156,12 +156,11 @@ const cleanPermissionsInDatabase = async () => {
 
     // 2. Clean permissions' fields (add required ones, remove the non-existing ones)
     const remainingPermissions = permissions.filter(
-      permission => !permissionsIdToRemove.includes(permission.id)
+      (permission) => !permissionsIdToRemove.includes(permission.id)
     );
 
-    const permissionsWithCleanFields = contentTypeService.cleanPermissionFields(
-      remainingPermissions
-    );
+    const permissionsWithCleanFields =
+      contentTypeService.cleanPermissionFields(remainingPermissions);
 
     // Update only the ones that need to be updated
     const permissionsNeedingToBeUpdated = differenceWith(
@@ -172,7 +171,7 @@ const cleanPermissionsInDatabase = async () => {
       remainingPermissions
     );
 
-    const updatePromiseProvider = permission => {
+    const updatePromiseProvider = (permission) => {
       return update({ id: permission.id }, permission);
     };
 
@@ -228,11 +227,11 @@ const ensureBoundPermissionsInDatabase = async () => {
     if (missingActions.length > 0) {
       const permissions = pipe(
         // Create a permission skeleton from the action id
-        map(action => ({ action, subject: contentType.uid, role: editorRole.id })),
+        map((action) => ({ action, subject: contentType.uid, role: editorRole.id })),
         // Use the permission domain to create a clean permission from the given object
         map(permissionDomain.create),
         // Adds the fields property if the permission action is eligible
-        map(permission =>
+        map((permission) =>
           BOUND_ACTIONS_FOR_FIELDS.includes(permission.action)
             ? permissionDomain.setProperty('fields', fields, permission)
             : permission

package/server/services/permission/sections-builder/handlers.js

@@ -78,21 +78,23 @@ const contentTypesBase = ({ action, section }) => {
 /**
  * Initialize the subjects array of a section based on the action's subjects
  */
-const subjectsHandlerFor = kind => ({ action, section: contentTypesSection }) => {
-  const { subjects } = action;
-
-  const newSubjects = subjects
-    // Ignore already added subjects
-    .filter(isNotInSubjects(contentTypesSection.subjects))
-    // Transform UIDs into content-types
-    .map(resolveContentType)
-    // Only keep specific kind of content-types
-    .filter(isOfKind(kind))
-    // Transform the content-types into section's subjects
-    .map(toSubjectTemplate);
-
-  contentTypesSection.subjects.push(...newSubjects);
-};
+const subjectsHandlerFor =
+  (kind) =>
+  ({ action, section: contentTypesSection }) => {
+    const { subjects } = action;
+
+    const newSubjects = subjects
+      // Ignore already added subjects
+      .filter(isNotInSubjects(contentTypesSection.subjects))
+      // Transform UIDs into content-types
+      .map(resolveContentType)
+      // Only keep specific kind of content-types
+      .filter(isOfKind(kind))
+      // Transform the content-types into section's subjects
+      .map(toSubjectTemplate);
+
+    contentTypesSection.subjects.push(...newSubjects);
+  };
 
 const buildNode = (model, attributeName, attribute) => {
   if (!isVisibleAttribute(model, attributeName)) {
@@ -113,10 +115,10 @@ const buildNode = (model, attributeName, attribute) => {
   return node;
 };
 
-const buildDeepAttributesCollection = model => {
+const buildDeepAttributesCollection = (model) => {
   return Object.entries(model.attributes)
     .map(([attributeName, attribute]) => buildNode(model, attributeName, attribute))
-    .filter(node => node !== null);
+    .filter((node) => node !== null);
 };
 
 /**
@@ -129,8 +131,8 @@ const fieldsProperty = ({ action, section }) => {
   const { subjects } = action;
 
   section.subjects
-    .filter(subject => subjects.includes(subject.uid))
-    .forEach(subject => {
+    .filter((subject) => subjects.includes(subject.uid))
+    .forEach((subject) => {
       const { uid } = subject;
       const contentType = resolveContentType(uid);
 

package/server/services/permission/sections-builder/section.js

@@ -29,8 +29,8 @@ const createSection = ({
   };
 
   // Register initial hooks
-  handlers.forEach(handler => state.hooks.handlers.register(handler));
-  matchers.forEach(matcher => state.hooks.matchers.register(matcher));
+  handlers.forEach((handler) => state.hooks.handlers.register(handler));
+  matchers.forEach((matcher) => state.hooks.matchers.register(matcher));
 
   return {
     hooks: state.hooks,

package/server/services/permission/sections-builder/utils.js

@@ -2,19 +2,19 @@
 
 const { curry, matchesProperty, pick } = require('lodash/fp');
 
-const isOfKind = kind => matchesProperty('kind', kind);
+const isOfKind = (kind) => matchesProperty('kind', kind);
 
-const resolveContentType = uid => strapi.contentTypes[uid];
+const resolveContentType = (uid) => strapi.contentTypes[uid];
 
-const isNotInSubjects = subjects => uid => !subjects.find(subject => subject.uid === uid);
+const isNotInSubjects = (subjects) => (uid) => !subjects.find((subject) => subject.uid === uid);
 
 const hasProperty = curry((property, subject) => {
-  return !!subject.properties.find(prop => prop.value === property);
+  return !!subject.properties.find((prop) => prop.value === property);
 });
 
 const getValidOptions = pick(['applyToProperties']);
 
-const toSubjectTemplate = ct => ({ uid: ct.uid, label: ct.info.singularName, properties: [] });
+const toSubjectTemplate = (ct) => ({ uid: ct.uid, label: ct.info.singularName, properties: [] });
 
 module.exports = {
   isOfKind,

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
@@ -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}`);
 };