@strapi/admin 4.11.4 → 4.12.0-beta.1

package/ee/server/controllers/workflows/stages/index.js

@@ -1,12 +1,24 @@
 'use strict';
 
-const { ApplicationError } = require('@strapi/utils').errors;
+const { mapAsync } = require('@strapi/utils');
 const { getService } = require('../../../utils');
-const { hasReviewWorkflow } = require('../../../utils/review-workflows');
-const {
-  validateUpdateStages,
-  validateUpdateStageOnEntity,
-} = require('../../../validation/review-workflows');
+const { validateUpdateStageOnEntity } = require('../../../validation/review-workflows');
+const { STAGE_MODEL_UID } = require('../../../constants/workflows');
+
+/**
+ *
+ * @param { Strapi } strapi - Strapi instance
+ * @param userAbility
+ * @return { (Stage) => SanitizedStage }
+ */
+function sanitizeStage({ strapi }, userAbility) {
+  const permissionChecker = strapi
+    .plugin('content-manager')
+    .service('permission-checker')
+    .create({ userAbility, model: STAGE_MODEL_UID });
+
+  return (entity) => permissionChecker.sanitizeOutput(entity);
+}
 
 module.exports = {
   /**
@@ -17,14 +29,15 @@ module.exports = {
     const { workflow_id: workflowId } = ctx.params;
     const { populate } = ctx.query;
     const stagesService = getService('stages');
+    const sanitizer = sanitizeStage({ strapi }, ctx.state.userAbility);
 
-    const data = await stagesService.find({
+    const stages = await stagesService.find({
       workflowId,
       populate,
     });
 
     ctx.body = {
-      data,
+      data: await mapAsync(stages, sanitizer),
     };
   },
   /**
@@ -35,36 +48,18 @@ module.exports = {
     const { id, workflow_id: workflowId } = ctx.params;
     const { populate } = ctx.query;
     const stagesService = getService('stages');
+    const sanitizer = sanitizeStage({ strapi }, ctx.state.userAbility);
 
-    const data = await stagesService.findById(id, {
+    const stage = await stagesService.findById(id, {
       workflowId,
       populate,
     });
 
     ctx.body = {
-      data,
+      data: await sanitizer(stage),
     };
   },
 
-  /**
-   * Replace all stages in a workflow
-   * @param {import('koa').BaseContext} ctx - koa context
-   *
-   */
-  async replace(ctx) {
-    const { workflow_id: workflowId } = ctx.params;
-    const stagesService = getService('stages');
-    const {
-      body: { data: stages },
-    } = ctx.request;
-
-    const stagesValidated = await validateUpdateStages(stages);
-
-    const data = await stagesService.replaceWorkflowStages(workflowId, stagesValidated);
-
-    ctx.body = { data };
-  },
-
   /**
    * Updates an entity's stage.
    * @async
@@ -80,23 +75,28 @@ module.exports = {
    */
   async updateEntity(ctx) {
     const stagesService = getService('stages');
+    const workflowService = getService('workflows');
+
     const { model_uid: modelUID, id: entityIdString } = ctx.params;
+    const { body } = ctx.request;
+
     const entityId = Number(entityIdString);
 
+    const { sanitizeOutput } = strapi
+      .plugin('content-manager')
+      .service('permission-checker')
+      .create({ userAbility: ctx.state.userAbility, model: modelUID });
+
     const { id: stageId } = await validateUpdateStageOnEntity(
-      ctx.request?.body?.data,
+      { id: Number(body?.data?.id) },
       'You should pass an id to the body of the put request.'
     );
 
-    if (!hasReviewWorkflow({ strapi }, modelUID)) {
-      throw new ApplicationError(`Review workflows is not activated on ${modelUID}.`);
-    }
-
-    // TODO When multiple workflows are possible, check if the stage is part of the right one
-    // Didn't need this today as their can only be one workflow
+    const workflow = await workflowService.assertContentTypeBelongsToWorkflow(modelUID);
+    workflowService.assertStageBelongsToWorkflow(stageId, workflow);
 
-    const data = await stagesService.updateEntity({ id: entityId, modelUID }, stageId);
+    const entity = await stagesService.updateEntity({ id: entityId, modelUID }, stageId);
 
-    ctx.body = { data };
+    ctx.body = { data: await sanitizeOutput(entity) };
   },
 };

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

@@ -0,0 +1,29 @@
+'use strict';
+
+const { get, keys, pickBy, pipe } = require('lodash/fp');
+const { WORKFLOW_MODEL_UID } = require('../constants/workflows');
+
+async function migrateWorkflowsContentTypes({ oldContentTypes, contentTypes }) {
+  // Look for RW contentTypes attribute
+  const hadContentTypes = !!oldContentTypes?.[WORKFLOW_MODEL_UID]?.attributes?.contentTypes;
+  const hasContentTypes = !!contentTypes?.[WORKFLOW_MODEL_UID]?.attributes?.contentTypes;
+
+  if (!hadContentTypes && hasContentTypes) {
+    // Initialize contentTypes with an empty array and assign only to one
+    // workflow the Content Types which were using Review Workflow before.
+    await strapi.query(WORKFLOW_MODEL_UID).updateMany({ data: { contentTypes: [] } });
+
+    // Find Content Types which were using Review Workflow before
+    const contentTypes = pipe([pickBy(get('options.reviewWorkflows')), keys])(oldContentTypes);
+
+    if (contentTypes.length) {
+      // Update only one workflow with the contentTypes
+      // Before this release there was only one workflow, so this operation is safe.
+      await strapi
+        .query(WORKFLOW_MODEL_UID)
+        .update({ where: { id: { $notNull: true } }, data: { contentTypes } });
+    }
+  }
+}
+
+module.exports = migrateWorkflowsContentTypes;

package/ee/server/migrations/review-workflows-deleted-ct-in-workflows.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { difference, keys } = require('lodash/fp');
+const { mapAsync } = require('@strapi/utils');
+const { WORKFLOW_MODEL_UID } = require('../constants/workflows');
+const { getWorkflowContentTypeFilter } = require('../utils/review-workflows');
+
+/**
+ * @param {Object} oldContentTypes
+ * @param {Object} contentTypes
+ * @return {Promise<void>}
+ */
+async function migrateDeletedCTInWorkflows({ oldContentTypes, contentTypes }) {
+  const deletedContentTypes = difference(keys(oldContentTypes), keys(contentTypes)) ?? [];
+
+  if (deletedContentTypes.length) {
+    await mapAsync(deletedContentTypes, async (deletedContentTypeUID) => {
+      const workflow = await strapi.query(WORKFLOW_MODEL_UID).findOne({
+        select: ['id', 'contentTypes'],
+        where: {
+          contentTypes: getWorkflowContentTypeFilter({ strapi }, deletedContentTypeUID),
+        },
+      });
+
+      if (workflow) {
+        await strapi.query(WORKFLOW_MODEL_UID).update({
+          where: { id: workflow.id },
+          data: {
+            contentTypes: workflow.contentTypes.filter(
+              (contentTypeUID) => contentTypeUID !== deletedContentTypeUID
+            ),
+          },
+        });
+      }
+    });
+  }
+}
+
+module.exports = migrateDeletedCTInWorkflows;

package/ee/server/migrations/review-workflows-stage-attribute.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const semver = require('semver');
+const { getOr } = require('lodash/fp');
+const { mapAsync } = require('@strapi/utils');
+const { STAGE_MODEL_UID } = require('../constants/workflows');
+const { findTables } = require('../utils/persisted-tables');
+
+function checkVersionThreshold(startVersion, currentVersion, thresholdVersion) {
+  return semver.gte(currentVersion, thresholdVersion) && semver.lt(startVersion, thresholdVersion);
+}
+
+async function migrateStageAttribute({ oldContentTypes, contentTypes }) {
+  const getRWVersion = getOr('0.0.0', `${STAGE_MODEL_UID}.options.version`);
+  const oldRWVersion = getRWVersion(oldContentTypes);
+  const currentRWVersion = getRWVersion(contentTypes);
+
+  const migrationNeeded = checkVersionThreshold(oldRWVersion, currentRWVersion, '1.1.0');
+
+  if (migrationNeeded) {
+    const oldAttributeTableName = 'strapi_review_workflows_stage';
+    const newAttributeTableName = 'strapi_stage';
+    const tables = await findTables({ strapi }, new RegExp(oldAttributeTableName));
+
+    await mapAsync(tables, async (tableName) => {
+      const newTableName = tableName.replace(oldAttributeTableName, newAttributeTableName);
+      const alreadyHasNextTable = await strapi.db.connection.schema.hasTable(newTableName);
+
+      // The table can be already created but empty. In order to rename the old one, we need to drop the previously created empty one.
+      if (alreadyHasNextTable) {
+        const dataInTable = await strapi.db.connection(newTableName).select().limit(1);
+        if (!dataInTable.length) {
+          await strapi.db.connection.schema.dropTable(newTableName);
+        }
+      }
+
+      try {
+        await strapi.db.connection.schema.renameTable(tableName, newTableName);
+      } catch (e) {
+        strapi.log.warn(
+          `An error occurred during the migration of ${tableName} table to ${newTableName}.\nIf ${newTableName} already exists, migration can't be done automatically.`
+        );
+        strapi.log.warn(e.message);
+      }
+    });
+  }
+}
+
+module.exports = migrateStageAttribute;

package/ee/server/migrations/review-workflows-stages-color.js

@@ -5,10 +5,10 @@ const { STAGE_DEFAULT_COLOR } = require('../constants/workflows');
 async function migrateReviewWorkflowStagesColor({ oldContentTypes, contentTypes }) {
   // Look for CT's color attribute
   const hadColor = !!oldContentTypes?.['admin::workflow-stage']?.attributes?.color;
-  const hasColor = !!contentTypes['admin::workflow-stage']?.attributes?.color;
+  const hasColor = !!contentTypes?.['admin::workflow-stage']?.attributes?.color;
 
   // Add the default stage color if color attribute was added
-  if (!hadColor || hasColor) {
+  if (!hadColor && hasColor) {
     await strapi.query('admin::workflow-stage').updateMany({
       data: {
         color: STAGE_DEFAULT_COLOR,

package/ee/server/migrations/review-workflows-workflow-name.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const { WORKFLOW_MODEL_UID } = require('../constants/workflows');
+const defaultWorkflow = require('../constants/default-workflow.json');
+
+async function migrateReviewWorkflowName({ oldContentTypes, contentTypes }) {
+  // Look for RW name attribute
+  const hadName = !!oldContentTypes?.[WORKFLOW_MODEL_UID]?.attributes?.name;
+  const hasName = !!contentTypes?.[WORKFLOW_MODEL_UID]?.attributes?.name;
+
+  // Add the default workflow name if name attribute was added
+  if (!hadName && hasName) {
+    await strapi.query(WORKFLOW_MODEL_UID).updateMany({
+      data: {
+        name: defaultWorkflow.name,
+      },
+    });
+  }
+}
+
+module.exports = migrateReviewWorkflowName;

package/ee/server/register.js

@@ -4,6 +4,10 @@ const { features } = require('@strapi/strapi/lib/utils/ee');
 const executeCERegister = require('../../server/register');
 const migrateAuditLogsTable = require('./migrations/audit-logs-table');
 const migrateReviewWorkflowStagesColor = require('./migrations/review-workflows-stages-color');
+const migrateReviewWorkflowName = require('./migrations/review-workflows-workflow-name');
+const migrateWorkflowsContentTypes = require('./migrations/review-workflows-content-types');
+const migrateStageAttribute = require('./migrations/review-workflows-stage-attribute');
+const migrateDeletedCTInWorkflows = require('./migrations/review-workflows-deleted-ct-in-workflows');
 const createAuditLogsService = require('./services/audit-logs');
 const reviewWorkflowsMiddlewares = require('./middlewares/review-workflows');
 const { getService } = require('./utils');
@@ -18,11 +22,17 @@ module.exports = async ({ strapi }) => {
     await auditLogsService.register();
   }
   if (features.isEnabled('review-workflows')) {
-    strapi.hook('strapi::content-types.afterSync').register(migrateReviewWorkflowStagesColor);
+    strapi.hook('strapi::content-types.beforeSync').register(migrateStageAttribute);
+    strapi
+      .hook('strapi::content-types.afterSync')
+      .register(migrateReviewWorkflowStagesColor)
+      .register(migrateReviewWorkflowName)
+      .register(migrateWorkflowsContentTypes)
+      .register(migrateDeletedCTInWorkflows);
     const reviewWorkflowService = getService('review-workflows');
 
     reviewWorkflowsMiddlewares.contentTypeMiddleware(strapi);
-    await reviewWorkflowService.register();
+    await reviewWorkflowService.register(features.get('review-workflows'));
   }
   await executeCERegister({ strapi });
 };

package/ee/server/routes/review-workflows.js

@@ -7,9 +7,9 @@ module.exports = {
   routes: [
     // Review workflow
     {
-      method: 'GET',
+      method: 'POST',
       path: '/review-workflows/workflows',
-      handler: 'workflows.find',
+      handler: 'workflows.create',
       config: {
         middlewares: [enableFeatureMiddleware('review-workflows')],
         policies: [
@@ -17,16 +17,50 @@ module.exports = {
           {
             name: 'admin::hasPermissions',
             config: {
-              actions: ['admin::review-workflows.read'],
+              actions: ['admin::review-workflows.create'],
             },
           },
         ],
       },
     },
     {
-      method: 'GET',
+      method: 'PUT',
       path: '/review-workflows/workflows/:id',
-      handler: 'workflows.findById',
+      handler: 'workflows.update',
+      config: {
+        middlewares: [enableFeatureMiddleware('review-workflows')],
+        policies: [
+          'admin::isAuthenticatedAdmin',
+          {
+            name: 'admin::hasPermissions',
+            config: {
+              actions: ['admin::review-workflows.update'],
+            },
+          },
+        ],
+      },
+    },
+    {
+      method: 'DELETE',
+      path: '/review-workflows/workflows/:id',
+      handler: 'workflows.delete',
+      config: {
+        middlewares: [enableFeatureMiddleware('review-workflows')],
+        policies: [
+          'admin::isAuthenticatedAdmin',
+          {
+            name: 'admin::hasPermissions',
+            config: {
+              actions: ['admin::review-workflows.delete'],
+            },
+          },
+        ],
+      },
+    },
+    {
+      method: 'GET',
+      path: '/review-workflows/workflows',
+      handler: 'workflows.find',
       config: {
         middlewares: [enableFeatureMiddleware('review-workflows')],
         policies: [
@@ -42,8 +76,8 @@ module.exports = {
     },
     {
       method: 'GET',
-      path: '/review-workflows/workflows/:workflow_id/stages',
-      handler: 'stages.find',
+      path: '/review-workflows/workflows/:id',
+      handler: 'workflows.findById',
       config: {
         middlewares: [enableFeatureMiddleware('review-workflows')],
         policies: [
@@ -58,9 +92,9 @@ module.exports = {
       },
     },
     {
-      method: 'PUT',
+      method: 'GET',
       path: '/review-workflows/workflows/:workflow_id/stages',
-      handler: 'stages.replace',
+      handler: 'stages.find',
       config: {
         middlewares: [enableFeatureMiddleware('review-workflows')],
         policies: [
@@ -102,7 +136,7 @@ module.exports = {
           {
             name: 'admin::hasPermissions',
             config: {
-              actions: ['admin::review-workflows.read'],
+              actions: ['admin::review-workflows.update'],
             },
           },
         ],

package/ee/server/services/index.js

@@ -9,6 +9,7 @@ module.exports = {
   workflows: require('./review-workflows/workflows'),
   stages: require('./review-workflows/stages'),
   'review-workflows': require('./review-workflows/review-workflows'),
+  'review-workflows-validation': require('./review-workflows/validation'),
   'review-workflows-decorator': require('./review-workflows/entity-service-decorator'),
   'review-workflows-metrics': require('./review-workflows/metrics'),
 };

package/ee/server/services/review-workflows/entity-service-decorator.js

@@ -3,17 +3,16 @@
 const { isNil, isNull } = require('lodash/fp');
 const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
 const { WORKFLOW_UPDATE_STAGE } = require('../../constants/webhookEvents');
-const { hasReviewWorkflow, getDefaultWorkflow } = require('../../utils/review-workflows');
+const { getService } = require('../../utils');
 
 /**
  * Assigns the entity data to the default workflow stage if no stage is present in the data
  * @param {Object} data
  * @returns
  */
-const getDataWithStage = async (data) => {
+const getDataWithStage = async (workflow, data) => {
   if (!isNil(ENTITY_STAGE_ATTRIBUTE, data)) {
-    const defaultWorkflow = await getDefaultWorkflow({ strapi });
-    return { ...data, [ENTITY_STAGE_ATTRIBUTE]: defaultWorkflow.stages[0].id };
+    return { ...data, [ENTITY_STAGE_ATTRIBUTE]: workflow.stages[0].id };
   }
   return data;
 };
@@ -43,22 +42,18 @@ const getEntityStage = async (uid, id) => {
  */
 const decorator = (service) => ({
   async create(uid, opts = {}) {
-    const hasRW = hasReviewWorkflow({ strapi }, uid);
+    const workflow = await getService('workflows').getAssignedWorkflow(uid, {
+      populate: 'stages',
+    });
 
-    if (!hasRW) {
+    if (!workflow) {
       return service.create.call(this, uid, opts);
     }
 
-    const data = await getDataWithStage(opts.data);
+    const data = await getDataWithStage(workflow, opts.data);
     return service.create.call(this, uid, { ...opts, data });
   },
   async update(uid, entityId, opts = {}) {
-    const hasRW = hasReviewWorkflow({ strapi }, uid);
-
-    if (!hasRW) {
-      return service.update.call(this, uid, entityId, opts);
-    }
-
     // Prevents the stage from being set to null
     const data = { ...opts.data };
     if (isNull(data[ENTITY_STAGE_ATTRIBUTE])) {

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

@@ -1,41 +1,57 @@
 'use strict';
 
-const { set, forEach, pipe, map } = require('lodash/fp');
-const { mapAsync } = require('@strapi/utils');
+const { filter, set, forEach, pipe, map, stubTrue, cond, defaultsDeep } = require('lodash/fp');
 const { getService } = require('../../utils');
-const { getContentTypeUIDsWithActivatedReviewWorkflows } = require('../../utils/review-workflows');
+const { getVisibleContentTypesUID, hasStageAttribute } = require('../../utils/review-workflows');
 
 const defaultStages = require('../../constants/default-stages.json');
 const defaultWorkflow = require('../../constants/default-workflow.json');
-const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+const {
+  ENTITY_STAGE_ATTRIBUTE,
+  MAX_WORKFLOWS,
+  MAX_STAGES_PER_WORKFLOW,
+} = require('../../constants/workflows');
 
-const { getDefaultWorkflow } = require('../../utils/review-workflows');
 const { persistTables, removePersistedTablesWithSuffix } = require('../../utils/persisted-tables');
 const webhookEvents = require('../../constants/webhookEvents');
 
-async function initDefaultWorkflow({ workflowsService, stagesService, strapi }) {
+const MAX_DB_TABLE_NAME_LEN = 63; // Postgres limit
+// The longest index name that Strapi can create is prefixed with '_strapi_stage_links_inv_fk', so the content type name  should be no longer than this.
+const MAX_JOIN_TABLE_NAME_SUFFIX =
+  1 /* _ */ + ENTITY_STAGE_ATTRIBUTE.length + '_links_inv_fk'.length;
+const MAX_CONTENT_TYPE_NAME_LEN = MAX_DB_TABLE_NAME_LEN - MAX_JOIN_TABLE_NAME_SUFFIX;
+
+const DEFAULT_OPTIONS = {
+  workflows: MAX_WORKFLOWS,
+  stagesPerWorkflow: MAX_STAGES_PER_WORKFLOW,
+};
+
+async function initDefaultWorkflow({ workflowsService, stagesService }) {
   const wfCount = await workflowsService.count();
   const stagesCount = await stagesService.count();
 
   // Check if there is nothing about review-workflow in DB
   // If any, the feature has already been initialized with a workflow and stages
   if (wfCount === 0 && stagesCount === 0) {
-    const stages = await stagesService.createMany(defaultStages, { fields: ['id'] });
     const workflow = {
       ...defaultWorkflow,
-      stages: {
-        connect: stages.map((stage) => stage.id),
-      },
+      stages: defaultStages,
     };
 
-    await workflowsService.create(workflow);
-    // If there is any manually activated RW on content-types, we want to migrate the related entities
-    await enableReviewWorkflow({ strapi })({ contentTypes: strapi.contentTypes });
+    await workflowsService.create({ data: workflow });
   }
 }
 
 function extendReviewWorkflowContentTypes({ strapi }) {
   const extendContentType = (contentTypeUID) => {
+    const assertContentTypeCompatibility = (contentType) =>
+      contentType.collectionName.length <= MAX_CONTENT_TYPE_NAME_LEN;
+    const incompatibleContentTypeAlert = (contentType) => {
+      strapi.log.warn(
+        `Review Workflow cannot be activated for the content type with the name '${contentType.info.displayName}' because the name exceeds the maximum length of ${MAX_CONTENT_TYPE_NAME_LEN} characters.`
+      );
+      return contentType;
+    };
     const setStageAttribute = set(`attributes.${ENTITY_STAGE_ATTRIBUTE}`, {
       writable: true,
       private: false,
@@ -46,49 +62,21 @@ function extendReviewWorkflowContentTypes({ strapi }) {
       relation: 'oneToOne',
       target: 'admin::workflow-stage',
     });
-    strapi.container.get('content-types').extend(contentTypeUID, setStageAttribute);
+
+    const extendContentTypeIfCompatible = cond([
+      [assertContentTypeCompatibility, setStageAttribute],
+      [stubTrue, incompatibleContentTypeAlert],
+    ]);
+    strapi.container.get('content-types').extend(contentTypeUID, extendContentTypeIfCompatible);
   };
+
   pipe([
-    getContentTypeUIDsWithActivatedReviewWorkflows,
+    getVisibleContentTypesUID,
     // Iterate over UIDs to extend the content-type
     forEach(extendContentType),
   ])(strapi.contentTypes);
 }
 
-/**
- * Enables the review workflow for the given content types.
- * @param {Object} strapi - Strapi instance
- */
-function enableReviewWorkflow({ strapi }) {
-  /**
-   * @param {Array<string>} contentTypes - Content type UIDs to enable the review workflow for.
-   * @returns {Promise<void>} - Promise that resolves when the review workflow is enabled.
-   */
-  return async ({ contentTypes }) => {
-    const defaultWorkflow = await getDefaultWorkflow({ strapi });
-    // This is possible if this is the first start of EE, there won't be any workflow in DB before bootstrap
-    if (!defaultWorkflow) {
-      return;
-    }
-    const firstStage = defaultWorkflow.stages[0];
-    const stagesService = getService('stages', { strapi });
-
-    const updateEntitiesStage = async (contentTypeUID) => {
-      // Update CT entities stage
-      return stagesService.updateEntitiesStage(contentTypeUID, {
-        fromStageId: null,
-        toStageId: firstStage.id,
-      });
-    };
-
-    return pipe([
-      getContentTypeUIDsWithActivatedReviewWorkflows,
-      // Iterate over UIDs to extend the content-type
-      (contentTypesUIDs) => mapAsync(contentTypesUIDs, updateEntitiesStage),
-    ])(contentTypes);
-  };
-}
-
 function persistStagesJoinTables({ strapi }) {
   return async ({ contentTypes }) => {
     const getStageTableToPersist = (contentTypeUID) => {
@@ -99,12 +87,13 @@ function persistStagesJoinTables({ strapi }) {
     };
 
     const joinTablesToPersist = pipe([
-      getContentTypeUIDsWithActivatedReviewWorkflows,
+      getVisibleContentTypesUID,
+      filter((uid) => hasStageAttribute(contentTypes[uid])),
       map(getStageTableToPersist),
     ])(contentTypes);
 
     // TODO: Instead of removing all the tables, we should only remove the ones that are not in the joinTablesToPersist
-    await removePersistedTablesWithSuffix('_strapi_review_workflows_stage_links');
+    await removePersistedTablesWithSuffix('_strapi_stage_links');
     await persistTables(joinTablesToPersist);
   };
 }
@@ -117,16 +106,19 @@ const registerWebhookEvents = async ({ strapi }) =>
 module.exports = ({ strapi }) => {
   const workflowsService = getService('workflows', { strapi });
   const stagesService = getService('stages', { strapi });
+  const workflowsValidationService = getService('review-workflows-validation', { strapi });
 
   return {
     async bootstrap() {
       await registerWebhookEvents({ strapi });
       await initDefaultWorkflow({ workflowsService, stagesService, strapi });
     },
-    async register() {
+    async register({ options } = { options: {} }) {
       extendReviewWorkflowContentTypes({ strapi });
-      strapi.hook('strapi::content-types.afterSync').register(enableReviewWorkflow({ strapi }));
       strapi.hook('strapi::content-types.afterSync').register(persistStagesJoinTables({ strapi }));
+
+      const reviewWorkflowsOptions = defaultsDeep(DEFAULT_OPTIONS, options);
+      workflowsValidationService.register(reviewWorkflowsOptions);
     },
   };
 };