@strapi/review-workflows 0.0.0-next.959c5589d0d3efa25d7ca014656d9ff48c173399 → 0.0.0-next.b0db56479de441dfe8feb37a43c7f6f6fecf75c1

package/dist/server/index.mjs

@@ -6386,7 +6386,8 @@ const WORKFLOW_POPULATE = {
         }
       }
     }
-  }
+  },
+  stageRequiredToPublish: true
 };
 function checkVersionThreshold(startVersion, currentVersion, thresholdVersion) {
   return semver$1.gte(currentVersion, thresholdVersion) && semver$1.lt(startVersion, thresholdVersion);
@@ -6561,8 +6562,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 });
@@ -6607,6 +6640,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,
@@ -6756,6 +6795,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 }) => {
 };
@@ -6988,9 +7028,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 });
@@ -7041,14 +7081,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 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;
       });
     },
     /**
@@ -7061,6 +7114,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 () => {
@@ -7069,9 +7123,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 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,
@@ -7079,12 +7152,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;
       });
     },
     /**
@@ -7107,10 +7185,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;
       });
     },
     /**
@@ -7322,8 +7402,9 @@ const stages$1 = ({ strapi: strapi2 }) => {
     /**
      * Update the stage of an entity
      */
-    async updateEntity(documentId, locale, model, 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`);
@@ -7331,9 +7412,15 @@ const stages$1 = ({ strapi: strapi2 }) => {
       const entity = await strapi2.documents(model).update({
         documentId,
         locale,
-        data: { [ENTITY_STAGE_ATTRIBUTE]: stage },
+        // 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;
     },
@@ -7480,32 +7567,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;
     }
   };
 };
@@ -7578,11 +7661,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 });
@@ -7835,9 +7918,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 errors.ValidationError("Entry is not at the required stage to publish");
+  }
+  return next();
+};
 const documentServiceMiddleware = () => ({
   assignStageOnCreate,
-  handleStageOnUpdate
+  handleStageOnUpdate,
+  checkStageBeforePublish
 });
 const services = {
   workflows: workflows$1,
@@ -7887,12 +7988,14 @@ const validateContentTypes = yup.array().of(
 const validateWorkflowCreateSchema = yup.object().shape({
   name: yup.string().max(255).min(1, "Workflow name can not be empty").required(),
   stages: 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: yup.string().min(1).nullable()
 });
 const validateWorkflowUpdateSchema = yup.object().shape({
   name: yup.string().max(255).min(1, "Workflow name can not be empty"),
   stages: 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: yup.string().min(1).nullable()
 });
 const validateUpdateAssigneeOnEntitySchema = yup.object().shape({
   id: yup.number().integer().min(1).nullable()
@@ -8095,12 +8198,7 @@ const stages = {
     );
     const workflow2 = await workflowService.assertContentTypeBelongsToWorkflow(modelUID);
     workflowService.assertStageBelongsToWorkflow(stageId, workflow2);
-    const updatedEntity = await stagesService.updateEntity(
-      entity.documentId,
-      entity.locale,
-      modelUID,
-      stageId
-    );
+    const updatedEntity = await stagesService.updateEntity(entity, modelUID, stageId);
     ctx.body = { data: await sanitizeOutput(updatedEntity) };
   },
   /**
@@ -8197,12 +8295,7 @@ const assignees = {
       "You should pass a valid id to the body of the put request."
     );
     await workflowService.assertContentTypeBelongsToWorkflow(model);
-    const updatedEntity = await assigneeService.updateEntityAssignee(
-      documentId,
-      locale || null,
-      model,
-      assigneeId
-    );
+    const updatedEntity = await assigneeService.updateEntityAssignee(entity, model, assigneeId);
     ctx.body = { data: await sanitizeOutput(updatedEntity) };
   }
 };