@strapi/review-workflows 0.0.0-experimental.f31889311d753b5f7d95198ae84d8fce1d156cd6 → 0.0.0-experimental.f49f46a1c17445a39e8af3f63124bcccf73842e6

package/dist/server/index.js

@@ -6387,7 +6387,8 @@ const WORKFLOW_POPULATE = {
         }
       }
     }
-  }
+  },
+  stageRequiredToPublish: true
 };
 function checkVersionThreshold(startVersion, currentVersion, thresholdVersion) {
   return semver$1.gte(currentVersion, thresholdVersion) && semver$1.lt(startVersion, thresholdVersion);
@@ -6562,8 +6563,40 @@ function extendReviewWorkflowContentTypes({ strapi: strapi2 }) {
     });
   }
 }
+function persistRWOnDowngrade({ strapi: strapi2 }) {
+  const { removePersistedTablesWithSuffix, persistTables } = getAdminService("persist-tables");
+  return async ({ contentTypes: contentTypes2 }) => {
+    const getStageTableToPersist = (contentTypeUID) => {
+      const { attributes, tableName } = strapi2.db.metadata.get(contentTypeUID);
+      const joinTableName = attributes[ENTITY_STAGE_ATTRIBUTE].joinTable.name;
+      return {
+        name: joinTableName,
+        dependsOn: [{ name: tableName }]
+      };
+    };
+    const getAssigneeTableToPersist = (contentTypeUID) => {
+      const { attributes, tableName } = strapi2.db.metadata.get(contentTypeUID);
+      const joinTableName = attributes[ENTITY_ASSIGNEE_ATTRIBUTE].joinTable.name;
+      return {
+        name: joinTableName,
+        dependsOn: [{ name: tableName }]
+      };
+    };
+    const enabledRWContentTypes = fp.pipe([
+      getVisibleContentTypesUID,
+      fp.filter((uid) => hasStageAttribute(contentTypes2[uid]))
+    ])(contentTypes2);
+    const stageJoinTablesToPersist = enabledRWContentTypes.map(getStageTableToPersist);
+    await removePersistedTablesWithSuffix("_strapi_stage_lnk");
+    await persistTables(stageJoinTablesToPersist);
+    const assigneeJoinTablesToPersist = enabledRWContentTypes.map(getAssigneeTableToPersist);
+    await removePersistedTablesWithSuffix("_strapi_assignee_lnk");
+    await persistTables(assigneeJoinTablesToPersist);
+  };
+}
 const register = async ({ strapi: strapi2 }) => {
   strapi2.hook("strapi::content-types.beforeSync").register(migrateStageAttribute);
+  strapi2.hook("strapi::content-types.afterSync").register(persistRWOnDowngrade({ strapi: strapi2 }));
   strapi2.hook("strapi::content-types.afterSync").register(migrateReviewWorkflowStagesColor).register(migrateReviewWorkflowStagesRoles).register(migrateReviewWorkflowName).register(migrateWorkflowsContentTypes).register(migrateDeletedCTInWorkflows);
   reviewWorkflowsMiddlewares.contentTypeMiddleware(strapi2);
   extendReviewWorkflowContentTypes({ strapi: strapi2 });
@@ -6608,6 +6641,12 @@ const workflow = {
         relation: "oneToMany",
         mappedBy: "workflow"
       },
+      stageRequiredToPublish: {
+        type: "relation",
+        target: "plugin::review-workflows.workflow-stage",
+        relation: "oneToOne",
+        required: false
+      },
       contentTypes: {
         type: "json",
         required: true,
@@ -6757,6 +6796,7 @@ const bootstrap = async (args) => {
   const docsMiddlewares = getService("document-service-middlewares");
   strapi.documents.use(docsMiddlewares.assignStageOnCreate);
   strapi.documents.use(docsMiddlewares.handleStageOnUpdate);
+  strapi.documents.use(docsMiddlewares.checkStageBeforePublish);
 };
 const destroy = async ({ strapi: strapi2 }) => {
 };
@@ -6838,23 +6878,6 @@ const reviewWorkflows = {
         ]
       }
     },
-    {
-      method: "GET",
-      path: "/workflows/:id",
-      handler: "workflows.findById",
-      config: {
-        middlewares: [enableFeatureMiddleware("review-workflows")],
-        policies: [
-          "admin::isAuthenticatedAdmin",
-          {
-            name: "admin::hasPermissions",
-            config: {
-              actions: ["admin::review-workflows.read"]
-            }
-          }
-        ]
-      }
-    },
     {
       method: "GET",
       path: "/workflows/:workflow_id/stages",
@@ -6918,7 +6941,7 @@ const reviewWorkflows = {
           {
             name: "admin::hasPermissions",
             config: {
-              actions: ["admin::users.read", "admin::review-workflows.read"]
+              actions: ["admin::users.read"]
             }
           }
         ]
@@ -7006,9 +7029,9 @@ const processFilters = ({ strapi: strapi2 }, filters = {}) => {
 };
 const processPopulate = (populate) => {
   if (!populate) {
-    return populate;
+    return WORKFLOW_POPULATE;
   }
-  return WORKFLOW_POPULATE;
+  return populate;
 };
 const workflows$1 = ({ strapi: strapi2 }) => {
   const workflowsContentTypes = workflowsContentTypesFactory({ strapi: strapi2 });
@@ -7059,14 +7082,27 @@ const workflows$1 = ({ strapi: strapi2 }) => {
         const stages2 = await getService("stages", { strapi: strapi2 }).createMany(opts.data.stages);
         const mapIds = fp.map(fp.get("id"));
         createOpts = fp.set("data.stages", mapIds(stages2), createOpts);
+        if (opts.data.stageRequiredToPublishName) {
+          const stageRequiredToPublish = stages2.find(
+            (stage) => stage.name === opts.data.stageRequiredToPublishName
+          );
+          if (!stageRequiredToPublish) {
+            throw new utils.errors.ApplicationError("Stage required to publish does not exist");
+          }
+          createOpts = fp.set("data.stageRequiredToPublish", stageRequiredToPublish.id, createOpts);
+        }
         if (opts.data.contentTypes) {
           await workflowsContentTypes.migrate({
             destContentTypes: opts.data.contentTypes,
             stageId: stages2[0].id
           });
         }
-        metrics.sendDidCreateWorkflow();
-        return strapi2.db.query(WORKFLOW_MODEL_UID).create(strapi2.get("query-params").transform(WORKFLOW_MODEL_UID, createOpts));
+        const createdWorkflow = await strapi2.db.query(WORKFLOW_MODEL_UID).create(strapi2.get("query-params").transform(WORKFLOW_MODEL_UID, createOpts));
+        metrics.sendDidCreateWorkflow(createdWorkflow.id, !!opts.data.stageRequiredToPublishName);
+        if (opts.data.stageRequiredToPublishName) {
+          await strapi2.plugin("content-releases").service("release-action").validateActionsByContentTypes(opts.data.contentTypes);
+        }
+        return createdWorkflow;
       });
     },
     /**
@@ -7079,6 +7115,7 @@ const workflows$1 = ({ strapi: strapi2 }) => {
     async update(workflow2, opts) {
       const stageService = getService("stages", { strapi: strapi2 });
       let updateOpts = { ...opts, populate: { ...WORKFLOW_POPULATE } };
+      let updatedStages = [];
       let updatedStageIds;
       await workflowValidator.validateWorkflowCount();
       return strapi2.db.transaction(async () => {
@@ -7087,9 +7124,28 @@ const workflows$1 = ({ strapi: strapi2 }) => {
           opts.data.stages.forEach(
             (stage) => this.assertStageBelongsToWorkflow(stage.id, workflow2)
           );
-          updatedStageIds = await stageService.replaceStages(workflow2.stages, opts.data.stages, workflow2.contentTypes).then((stages2) => stages2.map((stage) => stage.id));
+          updatedStages = await stageService.replaceStages(
+            workflow2.stages,
+            opts.data.stages,
+            workflow2.contentTypes
+          );
+          updatedStageIds = updatedStages.map((stage) => stage.id);
           updateOpts = fp.set("data.stages", updatedStageIds, updateOpts);
         }
+        if (opts.data.stageRequiredToPublishName !== void 0) {
+          const stages2 = updatedStages ?? workflow2.stages;
+          if (opts.data.stageRequiredToPublishName === null) {
+            updateOpts = fp.set("data.stageRequiredToPublish", null, updateOpts);
+          } else {
+            const stageRequiredToPublish = stages2.find(
+              (stage) => stage.name === opts.data.stageRequiredToPublishName
+            );
+            if (!stageRequiredToPublish) {
+              throw new utils.errors.ApplicationError("Stage required to publish does not exist");
+            }
+            updateOpts = fp.set("data.stageRequiredToPublish", stageRequiredToPublish.id, updateOpts);
+          }
+        }
         if (opts.data.contentTypes) {
           await workflowsContentTypes.migrate({
             srcContentTypes: workflow2.contentTypes,
@@ -7097,12 +7153,17 @@ const workflows$1 = ({ strapi: strapi2 }) => {
             stageId: updatedStageIds ? updatedStageIds[0] : workflow2.stages[0].id
           });
         }
-        metrics.sendDidEditWorkflow();
+        metrics.sendDidEditWorkflow(workflow2.id, !!opts.data.stageRequiredToPublishName);
         const query = strapi2.get("query-params").transform(WORKFLOW_MODEL_UID, updateOpts);
-        return strapi2.db.query(WORKFLOW_MODEL_UID).update({
+        const updatedWorkflow = await strapi2.db.query(WORKFLOW_MODEL_UID).update({
           ...query,
           where: { id: workflow2.id }
         });
+        await strapi2.plugin("content-releases").service("release-action").validateActionsByContentTypes([
+          ...workflow2.contentTypes,
+          ...opts.data.contentTypes || []
+        ]);
+        return updatedWorkflow;
       });
     },
     /**
@@ -7125,10 +7186,12 @@ const workflows$1 = ({ strapi: strapi2 }) => {
           destContentTypes: []
         });
         const query = strapi2.get("query-params").transform(WORKFLOW_MODEL_UID, opts);
-        return strapi2.db.query(WORKFLOW_MODEL_UID).delete({
+        const deletedWorkflow = await strapi2.db.query(WORKFLOW_MODEL_UID).delete({
           ...query,
           where: { id: workflow2.id }
         });
+        await strapi2.plugin("content-releases").service("release-action").validateActionsByContentTypes(workflow2.contentTypes);
+        return deletedWorkflow;
       });
     },
     /**
@@ -7339,25 +7402,26 @@ const stages$1 = ({ strapi: strapi2 }) => {
     },
     /**
      * 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) {
+    async updateEntity(entityToUpdate, model, stageId) {
       const stage = await this.findById(stageId);
+      const { documentId, locale } = entityToUpdate;
       await workflowValidator.validateWorkflowCount();
       if (!stage) {
         throw new ApplicationError$2(`Selected stage does not exist`);
       }
-      const entity = await strapi2.db.query(entityInfo.modelUID).update({
-        where: {
-          id: entityInfo.id
-        },
-        data: { [ENTITY_STAGE_ATTRIBUTE]: stageId },
+      const entity = await strapi2.documents(model).update({
+        documentId,
+        locale,
+        // Stage doesn't have DP or i18n enabled, connecting it through the `id`
+        // will be safer than relying on the `documentId` + `locale` + `status` transformation
+        data: { [ENTITY_STAGE_ATTRIBUTE]: fp.pick(["id"], stage) },
         populate: [ENTITY_STAGE_ATTRIBUTE]
       });
+      const { tableName } = strapi2.db.metadata.get(model);
+      await strapi2.db.connection(tableName).where({ id: entityToUpdate.id }).update({
+        updated_at: new Date(entityToUpdate.updatedAt)
+      });
       metrics.sendDidChangeEntryStage();
       return entity;
     },
@@ -7504,32 +7568,28 @@ const assignees$1 = ({ strapi: strapi2 }) => {
     /**
      * Update the assignee of an entity
      */
-    async updateEntityAssignee(documentId, locale, model, assigneeId) {
-      if (fp.isNil(assigneeId)) {
-        return this.deleteEntityAssignee(documentId, locale, model);
-      }
-      const userExists = await getAdminService("user", { strapi: strapi2 }).exists({ id: assigneeId });
-      if (!userExists) {
-        throw new ApplicationError(`Selected user does not exist`);
+    async updateEntityAssignee(entityToUpdate, model, assigneeId) {
+      const { documentId, locale } = entityToUpdate;
+      if (!fp.isNil(assigneeId)) {
+        const userExists = await getAdminService("user", { strapi: strapi2 }).exists({ id: assigneeId });
+        if (!userExists) {
+          throw new ApplicationError(`Selected user does not exist`);
+        }
       }
-      metrics.sendDidEditAssignee(await this.findEntityAssigneeId(documentId, model), assigneeId);
-      return strapi2.documents(model).update({
+      const oldAssigneeId = await this.findEntityAssigneeId(entityToUpdate.id, model);
+      metrics.sendDidEditAssignee(oldAssigneeId, assigneeId || null);
+      const entity = await strapi2.documents(model).update({
         documentId,
         locale,
-        data: { [ENTITY_ASSIGNEE_ATTRIBUTE]: assigneeId },
+        data: { [ENTITY_ASSIGNEE_ATTRIBUTE]: assigneeId || null },
         populate: [ENTITY_ASSIGNEE_ATTRIBUTE],
         fields: []
       });
-    },
-    async deleteEntityAssignee(documentId, locale, model) {
-      metrics.sendDidEditAssignee(await this.findEntityAssigneeId(documentId, model), null);
-      return strapi2.documents(model).update({
-        documentId,
-        locale,
-        data: { [ENTITY_ASSIGNEE_ATTRIBUTE]: null },
-        populate: [ENTITY_ASSIGNEE_ATTRIBUTE],
-        fields: []
+      const { tableName } = strapi2.db.metadata.get(model);
+      await strapi2.db.connection(tableName).where({ id: entityToUpdate.id }).update({
+        updated_at: new Date(entityToUpdate.updatedAt)
       });
+      return entity;
     }
   };
 };
@@ -7602,11 +7662,11 @@ const sendDidDeleteStage = async () => {
 const sendDidChangeEntryStage = async () => {
   strapi.telemetry.send("didChangeEntryStage", {});
 };
-const sendDidCreateWorkflow = async () => {
-  strapi.telemetry.send("didCreateWorkflow", {});
+const sendDidCreateWorkflow = async (workflowId, hasRequiredStageToPublish) => {
+  strapi.telemetry.send("didCreateWorkflow", { workflowId, hasRequiredStageToPublish });
 };
-const sendDidEditWorkflow = async () => {
-  strapi.telemetry.send("didEditWorkflow", {});
+const sendDidEditWorkflow = async (workflowId, hasRequiredStageToPublish) => {
+  strapi.telemetry.send("didEditWorkflow", { workflowId, hasRequiredStageToPublish });
 };
 const sendDidEditAssignee = async (fromId, toId) => {
   strapi.telemetry.send("didEditAssignee", { from: fromId, to: toId });
@@ -7631,13 +7691,13 @@ const reviewWorkflowsMetrics = {
   sendDidSendReviewWorkflowPropertiesOnceAWeek,
   sendDidEditAssignee
 };
-function _typeof(obj) {
+function _typeof(o) {
   "@babel/helpers - typeof";
-  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(obj2) {
-    return typeof obj2;
-  } : function(obj2) {
-    return obj2 && "function" == typeof Symbol && obj2.constructor === Symbol && obj2 !== Symbol.prototype ? "symbol" : typeof obj2;
-  }, _typeof(obj);
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
 }
 function toInteger(dirtyNumber) {
   if (dirtyNumber === null || dirtyNumber === true || dirtyNumber === false) {
@@ -7772,7 +7832,12 @@ const reviewWorkflowsWeeklyMetrics = ({ strapi: strapi2 }) => {
     },
     async registerCron() {
       const weeklySchedule = await this.ensureWeeklyStoredCronSchedule();
-      strapi2.cron.add({ [weeklySchedule]: this.sendMetrics.bind(this) });
+      strapi2.cron.add({
+        reviewWorkflowsWeekly: {
+          task: this.sendMetrics.bind(this),
+          options: weeklySchedule
+        }
+      });
     }
   };
 };
@@ -7828,6 +7893,7 @@ const handleStageOnUpdate = async (ctx, next) => {
     strapi.eventHub.emit(WORKFLOW_UPDATE_STAGE, {
       model: model.modelName,
       uid: model.uid,
+      // TODO v6: Rename to "entry", which is what is used for regular CRUD updates
       entity: {
         // @ts-expect-error
         id: result?.id,
@@ -7853,9 +7919,27 @@ const handleStageOnUpdate = async (ctx, next) => {
   }
   return next();
 };
+const checkStageBeforePublish = async (ctx, next) => {
+  if (ctx.action !== "publish") {
+    return next();
+  }
+  const workflow2 = await getService("workflows").getAssignedWorkflow(ctx.contentType.uid, {
+    populate: "stageRequiredToPublish"
+  });
+  if (!workflow2 || !workflow2.stageRequiredToPublish) {
+    return next();
+  }
+  const { documentId } = ctx.params;
+  const entryStage = await getEntityStage(ctx.contentType.uid, documentId, ctx.params);
+  if (entryStage.id !== workflow2.stageRequiredToPublish.id) {
+    throw new utils.errors.ValidationError("Entry is not at the required stage to publish");
+  }
+  return next();
+};
 const documentServiceMiddleware = () => ({
   assignStageOnCreate,
-  handleStageOnUpdate
+  handleStageOnUpdate,
+  checkStageBeforePublish
 });
 const services = {
   workflows: workflows$1,
@@ -7905,12 +7989,14 @@ const validateContentTypes = utils.yup.array().of(
 const validateWorkflowCreateSchema = utils.yup.object().shape({
   name: utils.yup.string().max(255).min(1, "Workflow name can not be empty").required(),
   stages: utils.yup.array().of(stageObject).uniqueProperty("name", "Stage name must be unique").min(1, "Can not create a workflow without stages").max(200, "Can not have more than 200 stages").required("Can not create a workflow without stages"),
-  contentTypes: validateContentTypes
+  contentTypes: validateContentTypes,
+  stageRequiredToPublishName: utils.yup.string().min(1).nullable()
 });
 const validateWorkflowUpdateSchema = utils.yup.object().shape({
   name: utils.yup.string().max(255).min(1, "Workflow name can not be empty"),
   stages: utils.yup.array().of(stageObject).uniqueProperty("name", "Stage name must be unique").min(1, "Can not update a workflow without stages").max(200, "Can not have more than 200 stages"),
-  contentTypes: validateContentTypes
+  contentTypes: validateContentTypes,
+  stageRequiredToPublishName: utils.yup.string().min(1).nullable()
 });
 const validateUpdateAssigneeOnEntitySchema = utils.yup.object().shape({
   id: utils.yup.number().integer().min(1).nullable()
@@ -8029,30 +8115,6 @@ const workflows = {
         workflowCount
       }
     };
-  },
-  /**
-   * Get one workflow based on its id contained in request parameters
-   * Returns count of workflows in meta, used to prevent workflow edition when
-   * max workflow count is reached for the current plan
-   * @param {import('koa').BaseContext} ctx - koa context
-   */
-  async findById(ctx) {
-    const { id } = ctx.params;
-    const { query } = ctx.request;
-    const { sanitizeOutput, sanitizedQuery } = getWorkflowsPermissionChecker(
-      { strapi },
-      ctx.state.userAbility
-    );
-    const { populate } = await sanitizedQuery.read(query);
-    const workflowService = getService("workflows");
-    const [workflow2, workflowCount] = await Promise.all([
-      workflowService.findById(id, { populate }).then(formatWorkflowToAdmin),
-      workflowService.count()
-    ]);
-    ctx.body = {
-      data: await sanitizeOutput(workflow2),
-      meta: { workflowCount }
-    };
   }
 };
 function sanitizeStage({ strapi: strapi2 }, userAbility) {
@@ -8137,7 +8199,7 @@ const stages = {
     );
     const workflow2 = await workflowService.assertContentTypeBelongsToWorkflow(modelUID);
     workflowService.assertStageBelongsToWorkflow(stageId, workflow2);
-    const updatedEntity = await stagesService.updateEntity({ id: entity.id, modelUID }, stageId);
+    const updatedEntity = await stagesService.updateEntity(entity, modelUID, stageId);
     ctx.body = { data: await sanitizeOutput(updatedEntity) };
   },
   /**
@@ -8157,10 +8219,9 @@ const stages = {
     if (strapi.plugin("content-manager").service("permission-checker").create({ userAbility: ctx.state.userAbility, model: modelUID }).cannot.read()) {
       return ctx.forbidden();
     }
-    const locale = await validateLocale(query?.locale);
+    const locale = await validateLocale(query?.locale) ?? void 0;
     const entity = await strapi.documents(modelUID).findOne({
       documentId,
-      // @ts-expect-error - locale should be also null in the doc service types
       locale,
       populate: [ENTITY_STAGE_ATTRIBUTE]
     });
@@ -8169,12 +8230,13 @@ const stages = {
     }
     const entityStageId = entity[ENTITY_STAGE_ATTRIBUTE]?.id;
     const canTransition = stagePermissions2.can(STAGE_TRANSITION_UID, entityStageId);
-    const [workflowCount, { stages: workflowStages }] = await Promise.all([
+    const [workflowCount, workflowResult] = await Promise.all([
       workflowService.count(),
       workflowService.getAssignedWorkflow(modelUID, {
         populate: "stages"
       })
     ]);
+    const workflowStages = workflowResult ? workflowResult.stages : [];
     const meta = {
       stageCount: workflowStages.length,
       workflowCount
@@ -8210,22 +8272,32 @@ const assignees = {
   async updateEntity(ctx) {
     const assigneeService = getService("assignees");
     const workflowService = getService("workflows");
+    const stagePermissions2 = getService("stage-permissions");
     const { model_uid: model, id: documentId } = ctx.params;
-    const { locale } = ctx.request.query || {};
+    const locale = await validateLocale(ctx.request.query?.locale) ?? void 0;
     const { sanitizeOutput } = strapi.plugin("content-manager").service("permission-checker").create({ userAbility: ctx.state.userAbility, model });
+    const entity = await strapi.documents(model).findOne({
+      documentId,
+      locale,
+      populate: [ENTITY_STAGE_ATTRIBUTE]
+    });
+    if (!entity) {
+      ctx.throw(404, "Entity not found");
+    }
+    const canTransitionStage = stagePermissions2.can(
+      STAGE_TRANSITION_UID,
+      entity[ENTITY_STAGE_ATTRIBUTE]?.id
+    );
+    if (!canTransitionStage) {
+      ctx.throw(403, "Stage transition permission is required");
+    }
     const { id: assigneeId } = await validateUpdateAssigneeOnEntity(
       ctx.request?.body?.data,
       "You should pass a valid id to the body of the put request."
     );
-    await validateLocale(locale);
     await workflowService.assertContentTypeBelongsToWorkflow(model);
-    const entity = await assigneeService.updateEntityAssignee(
-      documentId,
-      locale || null,
-      model,
-      assigneeId
-    );
-    ctx.body = { data: await sanitizeOutput(entity) };
+    const updatedEntity = await assigneeService.updateEntityAssignee(entity, model, assigneeId);
+    ctx.body = { data: await sanitizeOutput(updatedEntity) };
   }
 };
 const controllers = {