@strapi/admin 4.16.2 → 4.18.0

package/ee/server/services/review-workflows/workflows/content-types.js

@@ -1,89 +0,0 @@
-'use strict';
-
-const { mapAsync } = require('@strapi/utils');
-const { difference, merge } = require('lodash/fp');
-const { getService } = require('../../../utils');
-const { WORKFLOW_MODEL_UID } = require('../../../constants/workflows');
-
-module.exports = ({ strapi }) => {
-  const contentManagerContentTypeService = strapi
-    .plugin('content-manager')
-    .service('content-types');
-  const stagesService = getService('stages', { strapi });
-
-  const updateContentTypeConfig = async (uid, reviewWorkflowOption) => {
-    // Merge options in the configuration as the configuration service use a destructuration merge which doesn't include nested objects
-    const modelConfig = await contentManagerContentTypeService.findConfiguration(uid);
-
-    await contentManagerContentTypeService.updateConfiguration(
-      { uid },
-      { options: merge(modelConfig.options, { reviewWorkflows: reviewWorkflowOption }) }
-    );
-  };
-
-  return {
-    /**
-     * Migrates entities stages. Used when a content type is assigned to a workflow.
-     * @param {*} options
-     * @param {Array<string>} options.srcContentTypes - The content types assigned to the previous workflow
-     * @param {Array<string>} options.destContentTypes - The content types assigned to the new workflow
-     * @param {Workflow.Stage} options.stageId - The new stage to assign the entities to
-     */
-    async migrate({ srcContentTypes = [], destContentTypes, stageId }) {
-      const workflowsService = getService('workflows', { strapi });
-      const { created, deleted } = diffContentTypes(srcContentTypes, destContentTypes);
-
-      await mapAsync(
-        created,
-        async (uid) => {
-          // Content Types should only be assigned to one workflow
-          // However, edge cases can happen, and this handles them
-          const srcWorkflows = await workflowsService._getAssignedWorkflows(uid, {});
-
-          if (srcWorkflows.length) {
-            // Updates all existing entities stages links to the new stage
-            await stagesService.updateEntitiesStage(uid, { toStageId: stageId });
-            // Transfer content types from the previous workflow(s)
-            await mapAsync(srcWorkflows, (srcWorkflow) =>
-              this.transferContentTypes(srcWorkflow, uid)
-            );
-          }
-          await updateContentTypeConfig(uid, true);
-
-          // Create new stages links to the new stage
-          return stagesService.updateEntitiesStage(uid, {
-            fromStageId: null,
-            toStageId: stageId,
-          });
-        },
-        // transferContentTypes can cause race conditions if called in parallel when updating the same workflow
-        { concurrency: 1 }
-      );
-
-      await mapAsync(deleted, async (uid) => {
-        await updateContentTypeConfig(uid, false);
-        await stagesService.deleteAllEntitiesStage(uid, {});
-      });
-    },
-
-    /**
-     * Filters the content types assigned to a workflow
-     * @param {Workflow} srcWorkflow - The workflow to transfer from
-     * @param {string} uid - The content type uid
-     */
-    async transferContentTypes(srcWorkflow, uid) {
-      // Update assignedContentTypes of the previous workflow
-      await strapi.entityService.update(WORKFLOW_MODEL_UID, srcWorkflow.id, {
-        data: {
-          contentTypes: srcWorkflow.contentTypes.filter((contentType) => contentType !== uid),
-        },
-      });
-    },
-  };
-};
-
-const diffContentTypes = (srcContentTypes, destContentTypes) => {
-  const created = difference(destContentTypes, srcContentTypes);
-  const deleted = difference(srcContentTypes, destContentTypes);
-  return { created, deleted };
-};

package/ee/server/services/review-workflows/workflows/index.js

@@ -1,237 +0,0 @@
-'use strict';
-
-const { set, isString, map, get } = require('lodash/fp');
-const { ApplicationError } = require('@strapi/utils').errors;
-const { WORKFLOW_MODEL_UID, WORKFLOW_POPULATE } = require('../../../constants/workflows');
-const { getService } = require('../../../utils');
-const { getWorkflowContentTypeFilter } = require('../../../utils/review-workflows');
-const workflowsContentTypesFactory = require('./content-types');
-
-const processFilters = ({ strapi }, filters = {}) => {
-  const processedFilters = { ...filters };
-
-  if (isString(filters.contentTypes)) {
-    processedFilters.contentTypes = getWorkflowContentTypeFilter({ strapi }, filters.contentTypes);
-  }
-
-  return processedFilters;
-};
-
-// TODO: How can we improve this? Maybe using traversePopulate?
-const processPopulate = (populate) => {
-  // If it does not exist or it's not an object (like an array) return the default populate
-  if (!populate) {
-    return populate;
-  }
-
-  return WORKFLOW_POPULATE;
-};
-
-module.exports = ({ strapi }) => {
-  const workflowsContentTypes = workflowsContentTypesFactory({ strapi });
-  const workflowsValidationService = getService('review-workflows-validation', { strapi });
-  const metrics = getService('review-workflows-metrics', { strapi });
-
-  return {
-    /**
-     * Returns all the workflows matching the user-defined filters.
-     * @param {object} opts - Options for the query.
-     * @param {object} opts.filters - Filters object.
-     * @returns {Promise<object[]>} - List of workflows that match the user's filters.
-     */
-    async find(opts = {}) {
-      const filters = processFilters({ strapi }, opts.filters);
-      const populate = processPopulate(opts.populate);
-
-      return strapi.entityService.findMany(WORKFLOW_MODEL_UID, { ...opts, filters, populate });
-    },
-
-    /**
-     * Returns the workflow with the specified ID.
-     * @param {string} id - ID of the requested workflow.
-     * @param {object} opts - Options for the query.
-     * @returns {Promise<object>} - Workflow object matching the requested ID.
-     */
-    findById(id, opts) {
-      const populate = processPopulate(opts.populate);
-      return strapi.entityService.findOne(WORKFLOW_MODEL_UID, id, { ...opts, populate });
-    },
-
-    /**
-     * Creates a new workflow.
-     * @param {object} opts - Options for creating the new workflow.
-     * @returns {Promise<object>} - Workflow object that was just created.
-     * @throws {ValidationError} - If the workflow has no stages.
-     */
-    async create(opts) {
-      let createOpts = { ...opts, populate: WORKFLOW_POPULATE };
-
-      workflowsValidationService.validateWorkflowStages(opts.data.stages);
-      await workflowsValidationService.validateWorkflowCount(1);
-
-      return strapi.db.transaction(async () => {
-        // Create stages
-        const stages = await getService('stages', { strapi }).createMany(opts.data.stages);
-        const mapIds = map(get('id'));
-
-        createOpts = set('data.stages', mapIds(stages), createOpts);
-
-        // Update (un)assigned Content Types
-        if (opts.data.contentTypes) {
-          await workflowsContentTypes.migrate({
-            destContentTypes: opts.data.contentTypes,
-            stageId: stages[0].id,
-          });
-        }
-
-        metrics.sendDidCreateWorkflow();
-
-        // Create Workflow
-        return strapi.entityService.create(WORKFLOW_MODEL_UID, createOpts);
-      });
-    },
-
-    /**
-     * Updates an existing workflow.
-     * @param {object} workflow - The existing workflow to update.
-     * @param {object} opts - Options for updating the workflow.
-     * @returns {Promise<object>} - Workflow object that was just updated.
-     * @throws {ApplicationError} - If the supplied stage ID does not belong to the workflow.
-     */
-    async update(workflow, opts) {
-      const stageService = getService('stages', { strapi });
-      let updateOpts = { ...opts, populate: { ...WORKFLOW_POPULATE } };
-      let updatedStageIds;
-
-      await workflowsValidationService.validateWorkflowCount();
-
-      return strapi.db.transaction(async () => {
-        // Update stages
-        if (opts.data.stages) {
-          workflowsValidationService.validateWorkflowStages(opts.data.stages);
-          opts.data.stages.forEach((stage) =>
-            this.assertStageBelongsToWorkflow(stage.id, workflow)
-          );
-
-          updatedStageIds = await stageService
-            .replaceStages(workflow.stages, opts.data.stages, workflow.contentTypes)
-            .then((stages) => stages.map((stage) => stage.id));
-
-          updateOpts = set('data.stages', updatedStageIds, updateOpts);
-        }
-
-        // Update (un)assigned Content Types
-        if (opts.data.contentTypes) {
-          await workflowsContentTypes.migrate({
-            srcContentTypes: workflow.contentTypes,
-            destContentTypes: opts.data.contentTypes,
-            stageId: updatedStageIds ? updatedStageIds[0] : workflow.stages[0].id,
-          });
-        }
-
-        metrics.sendDidEditWorkflow();
-
-        // Update Workflow
-        return strapi.entityService.update(WORKFLOW_MODEL_UID, workflow.id, updateOpts);
-      });
-    },
-
-    /**
-     * Deletes an existing workflow.
-     * Also deletes all the workflow stages and migrate all assigned the content types.
-     * @param {*} workflow
-     * @param {*} opts
-     * @returns
-     */
-    async delete(workflow, opts) {
-      const stageService = getService('stages', { strapi });
-
-      const workflowCount = await this.count();
-
-      if (workflowCount <= 1) {
-        throw new ApplicationError('Can not delete the last workflow');
-      }
-
-      return strapi.db.transaction(async () => {
-        // Delete stages
-        await stageService.deleteMany(workflow.stages);
-
-        // Unassign all content types, this will migrate the content types to null
-        await workflowsContentTypes.migrate({
-          srcContentTypes: workflow.contentTypes,
-          destContentTypes: [],
-        });
-
-        // Delete Workflow
-        return strapi.entityService.delete(WORKFLOW_MODEL_UID, workflow.id, opts);
-      });
-    },
-    /**
-     * Returns the total count of workflows.
-     * @returns {Promise<number>} - Total count of workflows.
-     */
-    count() {
-      return strapi.entityService.count(WORKFLOW_MODEL_UID);
-    },
-
-    /**
-     * Finds the assigned workflow for a given content type ID.
-     * @param {string} uid - Content type ID to find the assigned workflow for.
-     * @param {object} opts - Options for the query.
-     * @returns {Promise<object|null>} - Assigned workflow object if found, or null.
-     */
-    async getAssignedWorkflow(uid, opts = {}) {
-      const workflows = await this._getAssignedWorkflows(uid, opts);
-      return workflows.length > 0 ? workflows[0] : null;
-    },
-
-    /**
-     * Finds all the assigned workflows for a given content type ID.
-     * Normally, there should only be one workflow assigned to a content type.
-     * However, edge cases can occur where a content type is assigned to multiple workflows.
-     * @param {string} uid - Content type ID to find the assigned workflows for.
-     * @param {object} opts - Options for the query.
-     * @returns {Promise<object[]>} - List of assigned workflow objects.
-     */
-    async _getAssignedWorkflows(uid, opts = {}) {
-      return this.find({
-        ...opts,
-        filters: { contentTypes: getWorkflowContentTypeFilter({ strapi }, uid) },
-      });
-    },
-
-    /**
-     * Asserts that a content type has an assigned workflow.
-     * @param {string} uid - Content type ID to verify the assignment of.
-     * @returns {Promise<object>} - Workflow object associated with the content type ID.
-     * @throws {ApplicationError} - If no assigned workflow is found for the content type ID.
-     */
-    async assertContentTypeBelongsToWorkflow(uid) {
-      const workflow = await this.getAssignedWorkflow(uid, {
-        populate: 'stages',
-      });
-      if (!workflow) {
-        throw new ApplicationError(`Review workflows is not activated on Content Type ${uid}.`);
-      }
-      return workflow;
-    },
-
-    /**
-     * Asserts that a stage belongs to a given workflow.
-     * @param {string} stageId - ID of stage to check.
-     * @param {object} workflow - Workflow object to check against.
-     * @returns
-     * @throws {ApplicationError} - If the stage does not belong to the specified workflow.
-     */
-    assertStageBelongsToWorkflow(stageId, workflow) {
-      if (!stageId) {
-        return;
-      }
-
-      const belongs = workflow.stages.some((stage) => stage.id === stageId);
-      if (!belongs) {
-        throw new ApplicationError(`Stage does not belong to workflow "${workflow.name}"`);
-      }
-    },
-  };
-};

package/ee/server/services/role.js

@@ -1,24 +0,0 @@
-'use strict';
-
-const { toString } = require('lodash/fp');
-const { ApplicationError } = require('@strapi/utils').errors;
-
-const ssoCheckRolesIdForDeletion = async (ids) => {
-  const adminStore = await strapi.store({ type: 'core', name: 'admin' });
-
-  const {
-    providers: { defaultRole },
-  } = await adminStore.get({ key: 'auth' });
-
-  for (const roleId of ids) {
-    if (defaultRole && toString(defaultRole) === toString(roleId)) {
-      throw new ApplicationError(
-        'This role is used as the default SSO role. Make sure to change this configuration before deleting the role'
-      );
-    }
-  }
-};
-
-module.exports = {
-  ssoCheckRolesIdForDeletion,
-};

package/ee/server/services/seat-enforcement.js

@@ -1,114 +0,0 @@
-'use strict';
-
-// eslint-disable-next-line node/no-extraneous-require
-const ee = require('@strapi/strapi/dist/utils/ee');
-const { take, drop, map, prop, pick, reverse, isNil } = require('lodash/fp');
-const { getService } = require('../../../server/utils');
-const { SUPER_ADMIN_CODE } = require('../../../server/services/constants');
-
-/**
- * Keeps the list of users disabled by the seat enforcement service
- */
-const getDisabledUserList = async () => {
-  return strapi.store.get({ type: 'ee', key: 'disabled_users' });
-};
-
-const enableMaximumUserCount = async (numberOfUsersToEnable) => {
-  const disabledUsers = await getDisabledUserList();
-  const orderedDisabledUsers = reverse(disabledUsers);
-
-  const usersToEnable = take(numberOfUsersToEnable, orderedDisabledUsers);
-
-  await strapi.db.query('admin::user').updateMany({
-    where: { id: map(prop('id'), usersToEnable) },
-    data: { isActive: true },
-  });
-
-  const remainingDisabledUsers = drop(numberOfUsersToEnable, orderedDisabledUsers);
-
-  await strapi.store.set({
-    type: 'ee',
-    key: 'disabled_users',
-    value: remainingDisabledUsers,
-  });
-};
-
-const disableUsersAboveLicenseLimit = async (numberOfUsersToDisable) => {
-  const currentlyDisabledUsers = (await getDisabledUserList()) ?? [];
-
-  const usersToDisable = [];
-  const nonSuperAdminUsersToDisable = await strapi.db.query('admin::user').findMany({
-    where: {
-      isActive: true,
-      roles: {
-        code: { $ne: SUPER_ADMIN_CODE },
-      },
-    },
-    orderBy: { createdAt: 'DESC' },
-    limit: numberOfUsersToDisable,
-  });
-
-  usersToDisable.push(...nonSuperAdminUsersToDisable);
-
-  if (nonSuperAdminUsersToDisable.length < numberOfUsersToDisable) {
-    const superAdminUsersToDisable = await strapi.db.query('admin::user').findMany({
-      where: {
-        isActive: true,
-        roles: { code: SUPER_ADMIN_CODE },
-      },
-      orderBy: { createdAt: 'DESC' },
-      limit: numberOfUsersToDisable - nonSuperAdminUsersToDisable.length,
-    });
-
-    usersToDisable.push(...superAdminUsersToDisable);
-  }
-
-  await strapi.db.query('admin::user').updateMany({
-    where: { id: map(prop('id'), usersToDisable) },
-    data: { isActive: false },
-  });
-
-  await strapi.store.set({
-    type: 'ee',
-    key: 'disabled_users',
-    value: currentlyDisabledUsers.concat(map(pick(['id', 'isActive']), usersToDisable)),
-  });
-};
-
-const syncDisabledUserRecords = async () => {
-  const disabledUsers = await strapi.store.get({ type: 'ee', key: 'disabled_users' });
-
-  if (!disabledUsers) {
-    return;
-  }
-
-  await strapi.db.query('admin::user').updateMany({
-    where: { id: map(prop('id'), disabledUsers) },
-    data: { isActive: false },
-  });
-};
-
-const seatEnforcementWorkflow = async () => {
-  const adminSeats = ee.seats;
-  if (isNil(adminSeats)) {
-    return;
-  }
-
-  // TODO: we need to make sure an admin can decide to disable specific user and reactivate others
-  await syncDisabledUserRecords();
-
-  const currentActiveUserCount = await getService('user').getCurrentActiveUserCount();
-
-  const adminSeatsLeft = adminSeats - currentActiveUserCount;
-
-  if (adminSeatsLeft > 0) {
-    await enableMaximumUserCount(adminSeatsLeft);
-  } else if (adminSeatsLeft < 0) {
-    await disableUsersAboveLicenseLimit(-adminSeatsLeft);
-  }
-};
-
-module.exports = {
-  seatEnforcementWorkflow,
-  getDisabledUserList,
-};

package/ee/server/services/user.js

@@ -1,234 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { pipe, map, castArray, toNumber } = require('lodash/fp');
-const { stringIncludes } = require('@strapi/utils');
-const { ValidationError } = require('@strapi/utils').errors;
-const { hasSuperAdminRole } = require('../../../server/domain/user');
-const { getService } = require('../../../server/utils');
-const { SUPER_ADMIN_CODE } = require('../../../server/services/constants');
-
-/** Checks if ee disabled users list needs to be updated
- * @param {string} id
- * @param {object} input
- */
-const updateEEDisabledUsersList = async (id, input) => {
-  const disabledUsers = await getService('seat-enforcement').getDisabledUserList();
-
-  if (!disabledUsers) {
-    return;
-  }
-
-  const user = disabledUsers.find((user) => user.id === Number(id));
-  if (!user) {
-    return;
-  }
-
-  if (user.isActive !== input.isActive) {
-    const newDisabledUsersList = disabledUsers.filter((user) => user.id !== Number(id));
-    await strapi.store.set({
-      type: 'ee',
-      key: 'disabled_users',
-      value: newDisabledUsersList,
-    });
-  }
-};
-
-const castNumberArray = pipe(castArray, map(toNumber));
-
-const removeFromEEDisabledUsersList = async (ids) => {
-  let idsToCheck;
-  if (typeof ids === 'object') {
-    idsToCheck = castNumberArray(ids);
-  } else {
-    idsToCheck = [Number(ids)];
-  }
-
-  const disabledUsers = await getService('seat-enforcement').getDisabledUserList();
-
-  if (!disabledUsers) {
-    return;
-  }
-
-  const newDisabledUsersList = disabledUsers.filter((user) => !idsToCheck.includes(user.id));
-  await strapi.store.set({
-    type: 'ee',
-    key: 'disabled_users',
-    value: newDisabledUsersList,
-  });
-};
-
-/**
- * Update a user in database
- * @param id query params to find the user to update
- * @param attributes A partial user object
- * @returns {Promise<user>}
- */
-const updateById = async (id, attributes) => {
-  // Check at least one super admin remains
-  if (_.has(attributes, 'roles')) {
-    const lastAdminUser = await isLastSuperAdminUser(id);
-    const superAdminRole = await getService('role').getSuperAdminWithUsersCount();
-    const willRemoveSuperAdminRole = !stringIncludes(attributes.roles, superAdminRole.id);
-
-    if (lastAdminUser && willRemoveSuperAdminRole) {
-      throw new ValidationError('You must have at least one user with super admin role.');
-    }
-  }
-
-  // cannot disable last super admin
-  if (attributes.isActive === false) {
-    const lastAdminUser = await isLastSuperAdminUser(id);
-    if (lastAdminUser) {
-      throw new ValidationError('You must have at least one user with super admin role.');
-    }
-  }
-
-  // hash password if a new one is sent
-  if (_.has(attributes, 'password')) {
-    const hashedPassword = await getService('auth').hashPassword(attributes.password);
-
-    const updatedUser = await strapi.query('admin::user').update({
-      where: { id },
-      data: {
-        ...attributes,
-        password: hashedPassword,
-      },
-      populate: ['roles'],
-    });
-
-    strapi.eventHub.emit('user.update', { user: sanitizeUser(updatedUser) });
-
-    return updatedUser;
-  }
-
-  const updatedUser = await strapi.query('admin::user').update({
-    where: { id },
-    data: attributes,
-    populate: ['roles'],
-  });
-
-  await updateEEDisabledUsersList(id, attributes);
-
-  if (updatedUser) {
-    strapi.eventHub.emit('user.update', { user: sanitizeUser(updatedUser) });
-  }
-
-  return updatedUser;
-};
-
-/** Delete a user
- * @param id id of the user to delete
- * @returns {Promise<user>}
- */
-const deleteById = async (id) => {
-  // Check at least one super admin remains
-  const userToDelete = await strapi.query('admin::user').findOne({
-    where: { id },
-    populate: ['roles'],
-  });
-
-  if (!userToDelete) {
-    return null;
-  }
-
-  if (userToDelete) {
-    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.');
-      }
-    }
-  }
-
-  const deletedUser = await strapi
-    .query('admin::user')
-    .delete({ where: { id }, populate: ['roles'] });
-
-  await removeFromEEDisabledUsersList(id);
-
-  strapi.eventHub.emit('user.delete', { user: sanitizeUser(deletedUser) });
-
-  return deletedUser;
-};
-
-/** Delete a user
- * @param ids ids of the users to delete
- * @returns {Promise<user>}
- */
-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({
-    where: {
-      id: ids,
-      roles: { id: superAdminRole.id },
-    },
-  });
-
-  if (superAdminRole.usersCount === nbOfSuperAdminToDelete) {
-    throw new ValidationError('You must have at least one user with super admin role.');
-  }
-
-  const deletedUsers = [];
-  for (const id of ids) {
-    const deletedUser = await strapi.query('admin::user').delete({
-      where: { id },
-      populate: ['roles'],
-    });
-
-    deletedUsers.push(deletedUser);
-  }
-
-  await removeFromEEDisabledUsersList(ids);
-
-  strapi.eventHub.emit('user.delete', {
-    users: deletedUsers.map((deletedUser) => sanitizeUser(deletedUser)),
-  });
-
-  return deletedUsers;
-};
-
-const sanitizeUserRoles = (role) => _.pick(role, ['id', 'name', 'description', 'code']);
-
-/**
- * Check if a user is the last super admin
- * @param {int|string} userId user's id to look for
- */
-const isLastSuperAdminUser = async (userId) => {
-  const user = await findOne(userId);
-  const superAdminRole = await getService('role').getSuperAdminWithUsersCount();
-
-  return superAdminRole.usersCount === 1 && hasSuperAdminRole(user);
-};
-
-/**
- * Remove private user fields
- * @param {Object} user - user to sanitize
- */
-const sanitizeUser = (user) => {
-  return {
-    ..._.omit(user, ['password', 'resetPasswordToken', 'registrationToken', 'roles']),
-    roles: user.roles && user.roles.map(sanitizeUserRoles),
-  };
-};
-
-/**
- * Find one user
- */
-const findOne = async (id, populate = ['roles']) => {
-  return strapi.entityService.findOne('admin::user', id, { populate });
-};
-
-const getCurrentActiveUserCount = async () => {
-  return strapi.db.query('admin::user').count({ where: { isActive: true } });
-};
-
-module.exports = {
-  updateEEDisabledUsersList,
-  removeFromEEDisabledUsersList,
-  getCurrentActiveUserCount,
-  deleteByIds,
-  deleteById,
-  updateById,
-};