@strapi/admin 4.11.4 → 4.12.0-beta.1

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

@@ -2,17 +2,16 @@
 
 const {
   mapAsync,
-  errors: { ApplicationError },
+  errors: { ApplicationError, ValidationError },
 } = require('@strapi/utils');
 const { map } = require('lodash/fp');
 
-const { STAGE_MODEL_UID, ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+const { STAGE_MODEL_UID, ENTITY_STAGE_ATTRIBUTE, ERRORS } = require('../../constants/workflows');
 const { getService } = require('../../utils');
-const { getContentTypeUIDsWithActivatedReviewWorkflows } = require('../../utils/review-workflows');
 
 module.exports = ({ strapi }) => {
-  const workflowsService = getService('workflows', { strapi });
   const metrics = getService('review-workflows-metrics', { strapi });
+  const workflowsValidationService = getService('review-workflows-validation', { strapi });
 
   return {
     find({ workflowId, populate }) {
@@ -30,8 +29,8 @@ module.exports = ({ strapi }) => {
       return strapi.entityService.findOne(STAGE_MODEL_UID, id, params);
     },
 
-    async createMany(stagesList, { fields }) {
-      const params = { select: fields };
+    async createMany(stagesList, { fields } = {}) {
+      const params = { select: fields ?? '*' };
 
       const stages = await Promise.all(
         stagesList.map((stage) =>
@@ -62,24 +61,34 @@ module.exports = ({ strapi }) => {
       return stage;
     },
 
-    count() {
-      return strapi.entityService.count(STAGE_MODEL_UID);
+    async deleteMany(stagesId) {
+      return strapi.entityService.deleteMany(STAGE_MODEL_UID, {
+        filters: { id: { $in: stagesId } },
+      });
     },
 
-    async replaceWorkflowStages(workflowId, stages) {
-      const workflow = await workflowsService.findById(workflowId, { populate: ['stages'] });
+    count({ workflowId } = {}) {
+      const opts = {};
 
-      const { created, updated, deleted } = getDiffBetweenStages(workflow.stages, stages);
+      if (workflowId) {
+        opts.where = {
+          workflow: workflowId,
+        };
+      }
+      return strapi.entityService.count(STAGE_MODEL_UID, opts);
+    },
 
-      assertAtLeastOneStageRemain(workflow.stages, { created, deleted });
+    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);
-        const stagesIds = stages.map((stage) => stage.id ?? createdStagesIds.shift());
-        const contentTypes = getContentTypeUIDsWithActivatedReviewWorkflows(strapi.contentTypes);
 
         // Update the workflow stages
         await mapAsync(updated, (stage) => this.update(stage.id, stage));
@@ -89,15 +98,15 @@ module.exports = ({ strapi }) => {
           // Find the nearest stage in the workflow and newly created stages
           // that is not deleted, prioritizing the previous stages
           const nearestStage = findNearestMatchingStage(
-            [...workflow.stages, ...createdStages],
-            workflow.stages.findIndex((s) => s.id === stage.id),
+            [...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(contentTypes, (contentTypeUID) => {
+          await mapAsync(contentTypesToMigrate, (contentTypeUID) => {
             this.updateEntitiesStage(contentTypeUID, {
               fromStageId: stage.id,
               toStageId: nearestStage.id,
@@ -108,9 +117,7 @@ module.exports = ({ strapi }) => {
           return this.delete(stage.id);
         });
 
-        return workflowsService.update(workflowId, {
-          stages: stagesIds,
-        });
+        return destStages.map((stage) => ({ ...stage, id: stage.id ?? createdStagesIds.shift() }));
       });
     },
 
@@ -125,6 +132,8 @@ module.exports = ({ strapi }) => {
     async updateEntity(entityInfo, stageId) {
       const stage = await this.findById(stageId);
 
+      await workflowsValidationService.validateWorkflowCount();
+
       if (!stage) {
         throw new ApplicationError(`Selected stage does not exist`);
       }
@@ -140,43 +149,72 @@ module.exports = ({ strapi }) => {
     },
 
     /**
-     * Updates the stage of all entities of a content type that are in a specific stage
+     * 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} fromStageId
+     * @param {number | undefined | null} fromStageId
      * @param {number} toStageId
      * @param {import('knex').Knex.Transaction} trx
      * @returns
      */
-    async updateEntitiesStage(contentTypeUID, { fromStageId, toStageId, trx = null }) {
+    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;
 
-      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 do not have a
-      // default stage
-      const query = strapi.db
-        .getConnection(joinTable.name)
-        .insert(
-          strapi.db.connection.raw(
-            `(${joinColumn}, ${invJoinColumn})  ${selectStatement.sql}`,
-            selectStatement.bindings
+      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);
+      });
+    },
 
-      if (trx) {
-        query.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;
 
-      return query;
+      // Delete all stage links for the content type
+      return strapi.db.transaction(async ({ trx }) =>
+        strapi.db.getConnection().from(joinTable.name).delete().transacting(trx)
+      );
     },
   };
 };
@@ -231,13 +269,13 @@ function getDiffBetweenStages(sourceStages, comparisonStages) {
  * @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 {ApplicationError} If the number of remaining stages in the workflow after applying deletions and additions is less than 1.
+ * @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 ApplicationError('At least one stage must remain in the workflow.');
+    throw new ValidationError(ERRORS.WORKFLOW_WITHOUT_STAGES);
   }
 }
 

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

@@ -0,0 +1,60 @@
+'use strict';
+
+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: {
+      workflows: MAX_WORKFLOWS,
+      stagesPerWorkflow: MAX_STAGES_PER_WORKFLOW,
+    },
+    register({ workflows, stagesPerWorkflow }) {
+      if (!Object.isFrozen(this.limits)) {
+        this.limits.workflows = clampMaxWorkflows(workflows || this.limits.workflows);
+        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);
+      }
+    },
+
+    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.workflows) {
+        throw new ValidationError(ERRORS.WORKFLOWS_LIMIT);
+      }
+    },
+  };
+};

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

@@ -0,0 +1,80 @@
+'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 }) {
+      // Workflows service is using this content-types service, to avoid an infinite loop, we need to get the service in the method
+      const workflowsService = getService('workflows', { strapi });
+      const { created, deleted } = diffContentTypes(srcContentTypes, destContentTypes);
+
+      await mapAsync(created, async (uid) => {
+        // If it was assigned to another workflow, transfer it from the previous workflow
+        const srcWorkflow = await workflowsService.getAssignedWorkflow(uid);
+        if (srcWorkflow) {
+          // Updates all existing entities stages links to the new stage
+          await stagesService.updateEntitiesStage(uid, { toStageId: stageId });
+          return this.transferContentType(srcWorkflow, uid);
+        }
+        await updateContentTypeConfig(uid, true);
+
+        // Create new stages links to the new stage
+        return stagesService.updateEntitiesStage(uid, {
+          fromStageId: null,
+          toStageId: stageId,
+        });
+      });
+
+      await mapAsync(deleted, async (uid) => {
+        await updateContentTypeConfig(uid, false);
+        await stagesService.deleteAllEntitiesStage(uid, {});
+      });
+    },
+
+    /**
+     * Filters the content types assigned to the previous workflow.
+     * @param {Workflow} srcWorkflow - The workflow to transfer from
+     * @param {string} uid - The content type uid
+     */
+    async transferContentType(srcWorkflow, uid) {
+      // Update assignedContentTypes of the previous workflow
+      await strapi.entityService.update(WORKFLOW_MODEL_UID, srcWorkflow.id, {
+        data: {
+          contentTypes: srcWorkflow.contentTypes.filter((ct) => ct !== 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

@@ -0,0 +1,207 @@
+'use strict';
+
+const { set, isString, map, get } = require('lodash/fp');
+const { ApplicationError } = require('@strapi/utils').errors;
+const { WORKFLOW_MODEL_UID } = 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;
+};
+
+module.exports = ({ strapi }) => {
+  const workflowsContentTypes = workflowsContentTypesFactory({ strapi });
+  const workflowsValidationService = getService('review-workflows-validation', { 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);
+      return strapi.entityService.findMany(WORKFLOW_MODEL_UID, { ...opts, filters });
+    },
+
+    /**
+     * 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) {
+      return strapi.entityService.findOne(WORKFLOW_MODEL_UID, id, opts);
+    },
+
+    /**
+     * 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: { stages: true } };
+
+      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,
+          });
+        }
+
+        // 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: { stages: true } };
+      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, opts);
+        }
+
+        // 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,
+          });
+        }
+
+        // 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.map((stage) => stage.id));
+
+        // 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.find({
+        ...opts,
+        filters: { contentTypes: getWorkflowContentTypeFilter({ strapi }, uid) },
+      });
+      return workflows.length > 0 ? workflows[0] : null;
+    },
+
+    /**
+     * 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/utils/review-workflows.js

@@ -1,34 +1,39 @@
 'use strict';
 
-const { get, keys, pickBy, pipe } = require('lodash/fp');
-const { WORKFLOW_MODEL_UID } = require('../constants/workflows');
+const { getOr, keys, pickBy, pipe, has, clamp } = require('lodash/fp');
+const {
+  ENTITY_STAGE_ATTRIBUTE,
+  MAX_WORKFLOWS,
+  MAX_STAGES_PER_WORKFLOW,
+} = require('../constants/workflows');
 
-/**
- * Checks if a content type has review workflows enabled.
- * @param {string|Object} contentType - Either the modelUID of the content type, or the content type object.
- * @returns {boolean} Whether review workflows are enabled for the specified content type.
- */
-function hasReviewWorkflow({ strapi }, contentType) {
-  if (typeof contentType === 'string') {
-    // If the input is a string, assume it's the modelUID of the content type and retrieve the corresponding object.
-    return hasReviewWorkflow({ strapi }, strapi.getModel(contentType));
-  }
-  // Otherwise, assume it's the content type object itself and return its `reviewWorkflows` option if it exists.
-  return contentType?.options?.reviewWorkflows || false;
-}
-// TODO To be refactored when multiple workflows are added
-const getDefaultWorkflow = async ({ strapi }) =>
-  strapi.query(WORKFLOW_MODEL_UID).findOne({ populate: ['stages'] });
-
-const getContentTypeUIDsWithActivatedReviewWorkflows = pipe([
-  // Pick only content-types with reviewWorkflows options set to true
-  pickBy(get('options.reviewWorkflows')),
+const getVisibleContentTypesUID = pipe([
+  // Pick only content-types visible in the content-manager and option is not false
+  pickBy(
+    (value) =>
+      getOr(true, 'pluginOptions.content-manager.visible', value) &&
+      !getOr(false, 'options.noStageAttribute', value)
+  ),
   // Get UIDs
   keys,
 ]);
 
+const hasStageAttribute = has(['attributes', ENTITY_STAGE_ATTRIBUTE]);
+
+const getWorkflowContentTypeFilter = ({ strapi }, contentType) => {
+  if (strapi.db.dialect.supportsOperator('$jsonSupersetOf')) {
+    return { $jsonSupersetOf: JSON.stringify([contentType]) };
+  }
+  return { $contains: `"${contentType}"` };
+};
+
+const clampMaxWorkflows = clamp(1, MAX_WORKFLOWS);
+const clampMaxStagesPerWorkflow = clamp(1, MAX_STAGES_PER_WORKFLOW);
+
 module.exports = {
-  hasReviewWorkflow,
-  getDefaultWorkflow,
-  getContentTypeUIDsWithActivatedReviewWorkflows,
+  clampMaxWorkflows,
+  clampMaxStagesPerWorkflow,
+  getVisibleContentTypesUID,
+  hasStageAttribute,
+  getWorkflowContentTypeFilter,
 };