@strapi/admin 4.16.2 → 4.17.1

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

@@ -1,384 +0,0 @@
-'use strict';
-
-const {
-  mapAsync,
-  reduceAsync,
-  errors: { ApplicationError, ValidationError },
-} = require('@strapi/utils');
-const { map, pick, isEqual } = require('lodash/fp');
-
-const { STAGE_MODEL_UID, ENTITY_STAGE_ATTRIBUTE, ERRORS } = require('../../constants/workflows');
-const { getService } = require('../../utils');
-
-const sanitizedStageFields = ['id', 'name', 'workflow', 'color'];
-const sanitizeStageFields = pick(sanitizedStageFields);
-
-module.exports = ({ strapi }) => {
-  const metrics = getService('review-workflows-metrics', { strapi });
-  const stagePermissionsService = getService('stage-permissions', { strapi });
-  const workflowsValidationService = getService('review-workflows-validation', { strapi });
-
-  return {
-    find({ workflowId, populate }) {
-      const params = {
-        filters: { workflow: workflowId },
-        populate,
-      };
-      return strapi.entityService.findMany(STAGE_MODEL_UID, params);
-    },
-
-    findById(id, { populate } = {}) {
-      const params = {
-        populate,
-      };
-      return strapi.entityService.findOne(STAGE_MODEL_UID, id, params);
-    },
-
-    async createMany(stagesList, { fields } = {}) {
-      const params = { select: fields ?? '*' };
-
-      // TODO: pick the fields from the stage
-      const stages = await Promise.all(
-        stagesList.map((stage) =>
-          strapi.entityService.create(STAGE_MODEL_UID, {
-            data: sanitizeStageFields(stage),
-            ...params,
-          })
-        )
-      );
-
-      // Create stage permissions
-      await reduceAsync(stagesList)(async (_, stage, idx) => {
-        // Ignore stages without permissions
-        if (!stage.permissions || stage.permissions.length === 0) {
-          return;
-        }
-
-        const stagePermissions = stage.permissions;
-        const stageId = stages[idx].id;
-
-        const permissions = await mapAsync(
-          stagePermissions,
-          // Register each stage permission
-          (permission) =>
-            stagePermissionsService.register({
-              roleId: permission.role,
-              action: permission.action,
-              fromStage: stageId,
-            })
-        );
-
-        // Update stage with the new permissions
-        await strapi.entityService.update(STAGE_MODEL_UID, stageId, {
-          data: {
-            permissions: permissions.flat().map((p) => p.id),
-          },
-        });
-      }, []);
-
-      metrics.sendDidCreateStage();
-
-      return stages;
-    },
-
-    async update(srcStage, destStage) {
-      let stagePermissions = srcStage?.permissions ?? [];
-      const stageId = destStage.id;
-
-      if (destStage.permissions) {
-        await this.deleteStagePermissions([srcStage]);
-
-        const permissions = await mapAsync(destStage.permissions, (permission) =>
-          stagePermissionsService.register({
-            roleId: permission.role,
-            action: permission.action,
-            fromStage: stageId,
-          })
-        );
-        stagePermissions = permissions.flat().map((p) => p.id);
-      }
-
-      const stage = await strapi.entityService.update(STAGE_MODEL_UID, stageId, {
-        data: {
-          ...destStage,
-          permissions: stagePermissions,
-        },
-      });
-
-      metrics.sendDidEditStage();
-
-      return stage;
-    },
-
-    async delete(stage) {
-      // Unregister all permissions related to this stage id
-      await this.deleteStagePermissions([stage]);
-
-      const deletedStage = await strapi.entityService.delete(STAGE_MODEL_UID, stage.id);
-
-      metrics.sendDidDeleteStage();
-
-      return deletedStage;
-    },
-
-    async deleteMany(stages) {
-      await this.deleteStagePermissions(stages);
-
-      return strapi.entityService.deleteMany(STAGE_MODEL_UID, {
-        filters: { id: { $in: stages.map((s) => s.id) } },
-      });
-    },
-
-    async deleteStagePermissions(stages) {
-      // TODO: Find another way to do this for when we use the "to" parameter.
-      const permissions = stages.map((s) => s.permissions || []).flat();
-      await stagePermissionsService.unregister(permissions || []);
-    },
-
-    count({ workflowId } = {}) {
-      const opts = {};
-
-      if (workflowId) {
-        opts.where = {
-          workflow: workflowId,
-        };
-      }
-      return strapi.entityService.count(STAGE_MODEL_UID, opts);
-    },
-
-    async replaceStages(srcStages, destStages, contentTypesToMigrate = []) {
-      const { created, updated, deleted } = getDiffBetweenStages(srcStages, destStages);
-
-      assertAtLeastOneStageRemain(srcStages || [], { created, deleted });
-
-      // Update stages and assign entity stages
-      return strapi.db.transaction(async ({ trx }) => {
-        // Create the new stages
-        const createdStages = await this.createMany(created, { fields: ['id'] });
-        // Put all the newly created stages ids
-        const createdStagesIds = map('id', createdStages);
-
-        // Update the workflow stages
-        await mapAsync(updated, (destStage) => {
-          const srcStage = srcStages.find((s) => s.id === destStage.id);
-
-          return this.update(srcStage, destStage);
-        });
-
-        // Delete the stages that are not in the new stages list
-        await mapAsync(deleted, async (stage) => {
-          // Find the nearest stage in the workflow and newly created stages
-          // that is not deleted, prioritizing the previous stages
-          const nearestStage = findNearestMatchingStage(
-            [...srcStages, ...createdStages],
-            srcStages.findIndex((s) => s.id === stage.id),
-            (targetStage) => {
-              return !deleted.find((s) => s.id === targetStage.id);
-            }
-          );
-
-          // Assign the new stage to entities that had the deleted stage
-          await mapAsync(contentTypesToMigrate, (contentTypeUID) => {
-            this.updateEntitiesStage(contentTypeUID, {
-              fromStageId: stage.id,
-              toStageId: nearestStage.id,
-              trx,
-            });
-          });
-
-          return this.delete(stage);
-        });
-
-        return destStages.map((stage) => ({ ...stage, id: stage.id ?? createdStagesIds.shift() }));
-      });
-    },
-
-    /**
-     * Update the stage of an entity
-     *
-     * @param {object} entityInfo
-     * @param {number} entityInfo.id - Entity id
-     * @param {string} entityInfo.modelUID - the content-type of the entity
-     * @param {number} stageId - The id of the stage to assign to the entity
-     */
-    async updateEntity(entityInfo, stageId) {
-      const stage = await this.findById(stageId);
-
-      await workflowsValidationService.validateWorkflowCount();
-
-      if (!stage) {
-        throw new ApplicationError(`Selected stage does not exist`);
-      }
-
-      const entity = await strapi.entityService.update(entityInfo.modelUID, entityInfo.id, {
-        data: { [ENTITY_STAGE_ATTRIBUTE]: stageId },
-        populate: [ENTITY_STAGE_ATTRIBUTE],
-      });
-
-      metrics.sendDidChangeEntryStage();
-
-      return entity;
-    },
-
-    /**
-     * Updates entity stages of a content type:
-     *  - If fromStageId is undefined, all entities with an existing stage will be assigned the new stage
-     *  - If fromStageId is null, all entities without a stage will be assigned the new stage
-     *  - If fromStageId is a number, all entities with that stage will be assigned the new stage
-     *
-     * For performance reasons we use knex queries directly.
-     *
-     * @param {string} contentTypeUID
-     * @param {number | undefined | null} fromStageId
-     * @param {number} toStageId
-     * @param {import('knex').Knex.Transaction} trx
-     * @returns
-     */
-    async updateEntitiesStage(contentTypeUID, { fromStageId, toStageId }) {
-      const { attributes, tableName } = strapi.db.metadata.get(contentTypeUID);
-      const joinTable = attributes[ENTITY_STAGE_ATTRIBUTE].joinTable;
-      const joinColumn = joinTable.joinColumn.name;
-      const invJoinColumn = joinTable.inverseJoinColumn.name;
-
-      await workflowsValidationService.validateWorkflowCount();
-
-      return strapi.db.transaction(async ({ trx }) => {
-        // Update all already existing links to the new stage
-        if (fromStageId === undefined) {
-          return strapi.db
-            .getConnection()
-            .from(joinTable.name)
-            .update({ [invJoinColumn]: toStageId })
-            .transacting(trx);
-        }
-
-        // Update all links from the specified stage to the new stage
-        const selectStatement = strapi.db
-          .getConnection()
-          .select({ [joinColumn]: 't1.id', [invJoinColumn]: toStageId })
-          .from(`${tableName} as t1`)
-          .leftJoin(`${joinTable.name} as t2`, `t1.id`, `t2.${joinColumn}`)
-          .where(`t2.${invJoinColumn}`, fromStageId)
-          .toSQL();
-
-        // Insert rows for all entries of the content type that have the specified stage
-        return strapi.db
-          .getConnection(joinTable.name)
-          .insert(
-            strapi.db.connection.raw(
-              `(${joinColumn}, ${invJoinColumn})  ${selectStatement.sql}`,
-              selectStatement.bindings
-            )
-          )
-          .transacting(trx);
-      });
-    },
-
-    /**
-     * Deletes all entity stages of a content type
-     * @param {string} contentTypeUID
-     * @returns
-     */
-    async deleteAllEntitiesStage(contentTypeUID) {
-      const { attributes } = strapi.db.metadata.get(contentTypeUID);
-      const joinTable = attributes[ENTITY_STAGE_ATTRIBUTE].joinTable;
-
-      // Delete all stage links for the content type
-      return strapi.db.transaction(async ({ trx }) =>
-        strapi.db.getConnection().from(joinTable.name).delete().transacting(trx)
-      );
-    },
-  };
-};
-
-/**
- * Compares two arrays of stages and returns an object indicating the differences.
- *
- * The function compares the `id` properties of each stage in `sourceStages` and `comparisonStages` to determine if the stage is present in both arrays.
- * If a stage with the same `id` is found in both arrays but the `name` property is different, the stage is considered updated.
- * If a stage with a particular `id` is only found in `comparisonStages`, it is considered created.
- * If a stage with a particular `id` is only found in `sourceStages`, it is considered deleted.
- *
- * @typedef {{id: Number, name: String, workflow: Number}} Stage
- * @typedef {{created: Stage[], updated: Stage[], deleted: Stage[]}} DiffStages
- *
- * The DiffStages object has three properties: `created`, `updated`, and `deleted`.
- * `created` is an array of stages that are in `comparisonStages` but not in `sourceStages`.
- * `updated` is an array of stages that have different names in `comparisonStages` and `sourceStages`.
- * `deleted` is an array of stages that are in `sourceStages` but not in `comparisonStages`.
- *
- * @param {Stage[]} sourceStages
- * @param {Stage[]} comparisonStages
- * @returns { DiffStages }
- */
-function getDiffBetweenStages(sourceStages, comparisonStages) {
-  const result = comparisonStages.reduce(
-    // ...
-
-    (acc, stageToCompare) => {
-      const srcStage = sourceStages.find((stage) => stage.id === stageToCompare.id);
-
-      if (!srcStage) {
-        acc.created.push(stageToCompare);
-      } else if (
-        !isEqual(
-          pick(['name', 'color', 'permissions'], srcStage),
-          pick(['name', 'color', 'permissions'], stageToCompare)
-        )
-      ) {
-        acc.updated.push(stageToCompare);
-      }
-      return acc;
-    },
-    { created: [], updated: [] }
-  );
-
-  result.deleted = sourceStages.filter(
-    (srcStage) => !comparisonStages.some((cmpStage) => cmpStage.id === srcStage.id)
-  );
-
-  return result;
-}
-
-/**
- * Asserts that at least one stage remains in the workflow after applying deletions and additions.
- *
- * @param {Array} workflowStages - An array of stages in the current workflow.
- * @param {Object} diffStages - An object containing the stages to be deleted and created.
- * @param {Array} diffStages.deleted - An array of stages that are planned to be deleted from the workflow.
- * @param {Array} diffStages.created - An array of stages that are planned to be created in the workflow.
- *
- * @throws {ValidationError} If the number of remaining stages in the workflow after applying deletions and additions is less than 1.
- */
-function assertAtLeastOneStageRemain(workflowStages, diffStages) {
-  const remainingStagesCount =
-    workflowStages.length - diffStages.deleted.length + diffStages.created.length;
-  if (remainingStagesCount < 1) {
-    throw new ValidationError(ERRORS.WORKFLOW_WITHOUT_STAGES);
-  }
-}
-
-/**
- * Find the id of the nearest object in an array that matches a condition.
- * Used for searching for the nearest stage that is not deleted.
- * Starts by searching the elements before the index, then the remaining elements in the array.
- *
- * @param {Array} stages
- * @param {Number} startIndex the index to start searching from
- * @param {Function} condition must evaluate to true for the object to be considered a match
- * @returns {Object} stage
- */
-function findNearestMatchingStage(stages, startIndex, condition) {
-  // Start by searching the elements before the startIndex
-  for (let i = startIndex; i >= 0; i -= 1) {
-    if (condition(stages[i])) {
-      return stages[i];
-    }
-  }
-
-  // If no matching element is found before the startIndex,
-  // search the remaining elements in the array
-  const remainingArray = stages.slice(startIndex + 1);
-  const nearestObject = remainingArray.filter(condition)[0];
-  return nearestObject;
-}

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

@@ -1,68 +0,0 @@
-'use strict';
-
-const { uniq } = require('lodash/fp');
-const { ValidationError } = require('@strapi/utils').errors;
-const { getService } = require('../../utils');
-const { ERRORS, MAX_WORKFLOWS, MAX_STAGES_PER_WORKFLOW } = require('../../constants/workflows');
-const { clampMaxWorkflows, clampMaxStagesPerWorkflow } = require('../../utils/review-workflows');
-
-module.exports = ({ strapi }) => {
-  return {
-    limits: {
-      numberOfWorkflows: MAX_WORKFLOWS,
-      stagesPerWorkflow: MAX_STAGES_PER_WORKFLOW,
-    },
-    register({ numberOfWorkflows, stagesPerWorkflow }) {
-      if (!Object.isFrozen(this.limits)) {
-        this.limits.numberOfWorkflows = clampMaxWorkflows(
-          numberOfWorkflows || this.limits.numberOfWorkflows
-        );
-        this.limits.stagesPerWorkflow = clampMaxStagesPerWorkflow(
-          stagesPerWorkflow || this.limits.stagesPerWorkflow
-        );
-        Object.freeze(this.limits);
-      }
-    },
-    /**
-     * Validates the stages of a workflow.
-     * @param {Array} stages - Array of stages to be validated.
-     * @throws {ValidationError} - If the workflow has no stages or exceeds the limit.
-     */
-    validateWorkflowStages(stages) {
-      if (!stages || stages.length === 0) {
-        throw new ValidationError(ERRORS.WORKFLOW_WITHOUT_STAGES);
-      }
-      if (stages.length > this.limits.stagesPerWorkflow) {
-        throw new ValidationError(ERRORS.STAGES_LIMIT);
-      }
-      // Validate stage names are not duplicated
-      const stageNames = stages.map((stage) => stage.name);
-      if (uniq(stageNames).length !== stageNames.length) {
-        throw new ValidationError(ERRORS.DUPLICATED_STAGE_NAME);
-      }
-    },
-
-    async validateWorkflowCountStages(workflowId, countAddedStages = 0) {
-      const stagesService = getService('stages', { strapi });
-      const countWorkflowStages = await stagesService.count({ workflowId });
-
-      if (countWorkflowStages + countAddedStages > this.limits.stagesPerWorkflow) {
-        throw new ValidationError(ERRORS.STAGES_LIMIT);
-      }
-    },
-
-    /**
-     * Validates the count of existing and added workflows.
-     * @param {number} [countAddedWorkflows=0] - The count of workflows to be added.
-     * @throws {ValidationError} - If the total count of workflows exceeds the limit.
-     * @returns {Promise<void>} - A Promise that resolves when the validation is completed.
-     */
-    async validateWorkflowCount(countAddedWorkflows = 0) {
-      const workflowsService = getService('workflows', { strapi });
-      const countWorkflows = await workflowsService.count();
-      if (countWorkflows + countAddedWorkflows > this.limits.numberOfWorkflows) {
-        throw new ValidationError(ERRORS.WORKFLOWS_LIMIT);
-      }
-    },
-  };
-};

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

@@ -1,146 +0,0 @@
-'use strict';
-
-const contentTypeServiceFactory = require('../content-types');
-
-const stagesServiceMock = {
-  updateEntitiesStage: jest.fn(),
-  deleteAllEntitiesStage: jest.fn(),
-};
-
-const workflowsServiceMock = {
-  getAssignedWorkflow: jest.fn(),
-  _getAssignedWorkflows: jest.fn(),
-};
-
-const reviewWorkflowsValidationMock = {
-  register: jest.fn(),
-  validateWorkflowCount: jest.fn().mockResolvedValue(true),
-  validateWorkflowStages: jest.fn(),
-};
-
-const getServiceMock = {
-  stages: stagesServiceMock,
-  workflows: workflowsServiceMock,
-  'review-workflows-validation': reviewWorkflowsValidationMock,
-};
-
-jest.mock('../../../../utils', () => {
-  return {
-    getService: jest.fn((serviceName) => getServiceMock[serviceName]),
-  };
-});
-
-const CTMPContentTypesServiceMock = {
-  findConfiguration: jest.fn(),
-  updateConfiguration: jest.fn(),
-};
-
-const contentManagerPluginServicesMock = {
-  'content-types': CTMPContentTypesServiceMock,
-};
-
-const contentManagerPluginMock = {
-  service: jest.fn((serviceName) => contentManagerPluginServicesMock[serviceName]),
-};
-
-const pluginsMock = {
-  'content-manager': contentManagerPluginMock,
-};
-
-const entityServiceMock = {
-  update: jest.fn(),
-};
-
-const strapiMock = {
-  plugin: jest.fn((pluginName) => pluginsMock[pluginName]),
-  entityService: entityServiceMock,
-};
-
-describe('Review Workflows', () => {
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('content types service', () => {
-    const contentTypeService = contentTypeServiceFactory({ strapi: strapiMock });
-
-    describe('migrate', () => {
-      test('should update the configuration of newly added content types', async () => {
-        const prevOptions = { testOptions: true };
-
-        workflowsServiceMock._getAssignedWorkflows.mockResolvedValueOnce([]);
-        CTMPContentTypesServiceMock.findConfiguration.mockResolvedValueOnce({
-          options: prevOptions,
-        });
-        stagesServiceMock.updateEntitiesStage.mockResolvedValueOnce('update entity');
-
-        await contentTypeService.migrate({
-          srcContentTypes: [],
-          destContentTypes: ['content'],
-          stageId: 1,
-        });
-
-        expect(CTMPContentTypesServiceMock.findConfiguration).toHaveBeenCalled();
-        expect(CTMPContentTypesServiceMock.updateConfiguration).toBeCalledTimes(1);
-        expect(CTMPContentTypesServiceMock.updateConfiguration).toHaveBeenCalledWith(
-          { uid: 'content' },
-          {
-            options: {
-              testOptions: true,
-              reviewWorkflows: true,
-            },
-          }
-        );
-        expect(stagesServiceMock.updateEntitiesStage).toBeCalledTimes(1);
-      });
-      test('should not update the configuration of transferred content types from a workflow to another', async () => {
-        const prevOptions = { testOptions: true };
-
-        workflowsServiceMock.getAssignedWorkflow.mockResolvedValueOnce({
-          id: 1,
-          contentTypes: ['content'],
-        });
-        CTMPContentTypesServiceMock.findConfiguration.mockResolvedValueOnce({
-          options: prevOptions,
-        });
-
-        await contentTypeService.migrate({
-          srcContentTypes: ['content'],
-          destContentTypes: ['content'],
-          stageId: 1,
-        });
-
-        expect(CTMPContentTypesServiceMock.updateConfiguration).toBeCalledTimes(0);
-        expect(stagesServiceMock.updateEntitiesStage).toBeCalledTimes(0);
-      });
-      test('should update the configuration of deleted content types', async () => {
-        const prevOptions = { testOptions: true };
-
-        workflowsServiceMock.getAssignedWorkflow.mockResolvedValueOnce(null);
-        CTMPContentTypesServiceMock.findConfiguration.mockResolvedValueOnce({
-          options: prevOptions,
-        });
-        stagesServiceMock.updateEntitiesStage.mockResolvedValueOnce('update entity');
-
-        await contentTypeService.migrate({
-          srcContentTypes: ['content'],
-          destContentTypes: [],
-          stageId: 1,
-        });
-
-        expect(CTMPContentTypesServiceMock.findConfiguration).toHaveBeenCalled();
-        expect(CTMPContentTypesServiceMock.updateConfiguration).toBeCalledTimes(1);
-        expect(CTMPContentTypesServiceMock.updateConfiguration).toHaveBeenCalledWith(
-          { uid: 'content' },
-          {
-            options: {
-              testOptions: true,
-              reviewWorkflows: false,
-            },
-          }
-        );
-        expect(stagesServiceMock.deleteAllEntitiesStage).toBeCalledTimes(1);
-      });
-    });
-  });
-});

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