@strapi/admin 4.9.2 → 4.10.0-beta.1

package/ee/admin/pages/SettingsPage/pages/ReviewWorkflows/utils/getWorkflowValidationSchema.js

@@ -0,0 +1,25 @@
+import * as yup from 'yup';
+
+export function getWorkflowValidationSchema({ formatMessage }) {
+  return yup.object({
+    stages: yup.array().of(
+      yup.object().shape({
+        name: yup
+          .string()
+          .required(
+            formatMessage({
+              id: 'Settings.review-workflows.validation.stage.name',
+              defaultMessage: 'Name is required',
+            })
+          )
+          .max(
+            255,
+            formatMessage({
+              id: 'Settings.review-workflows.validation.stage.max-length',
+              defaultMessage: 'Name can not be longer than 255 characters',
+            })
+          ),
+      })
+    ),
+  });
+}

package/ee/admin/pages/SettingsPage/utils/customRoutes.js

@@ -1,6 +1,6 @@
 const routes = [];
 
-if (strapi.features.isEnabled(strapi.features.SSO)) {
+if (window.strapi.features.isEnabled(window.strapi.features.SSO)) {
   routes.push({
     async Component() {
       const component = await import(
@@ -14,7 +14,21 @@ if (strapi.features.isEnabled(strapi.features.SSO)) {
   });
 }
 
-if (strapi.features.isEnabled(strapi.features.AUDIT_LOGS)) {
+if (window.strapi.features.isEnabled(window.strapi.features.REVIEW_WORKFLOWS)) {
+  routes.push({
+    async Component() {
+      const component = await import(
+        /* webpackChunkName: "review-workflows-settings" */ '../pages/ReviewWorkflows'
+      );
+
+      return component;
+    },
+    to: '/settings/review-workflows',
+    exact: true,
+  });
+}
+
+if (window.strapi.features.isEnabled(window.strapi.features.AUDIT_LOGS)) {
   routes.push({
     async Component() {
       const component = await import(

package/ee/admin/permissions/customPermissions.js

@@ -4,6 +4,9 @@ const customPermissions = {
       main: [{ action: 'admin::audit-logs.read', subject: null }],
       read: [{ action: 'admin::audit-logs.read', subject: null }],
     },
+    'review-workflows': {
+      main: [{ action: 'admin::review-workflows.read', subject: null }],
+    },
     sso: {
       main: [{ action: 'admin::provider-login.read', subject: null }],
       read: [{ action: 'admin::provider-login.read', subject: null }],

package/ee/server/bootstrap.js

@@ -20,6 +20,19 @@ module.exports = async () => {
     await actionProvider.registerMany(actions.auditLogs);
   }
 
+  if (features.isEnabled('review-workflows')) {
+    await persistTablesWithPrefix('strapi_workflows');
+
+    const { bootstrap: rwBootstrap } = getService('review-workflows');
+
+    await rwBootstrap();
+    await actionProvider.registerMany(actions.reviewWorkflows);
+
+    // Decorate the entity service with review workflow logic
+    const { decorator } = getService('review-workflows-decorator');
+    strapi.entityService.decorate(decorator);
+  }
+
   await getService('seat-enforcement').seatEnforcementWorkflow();
 
   await executeCEBootstrap();

package/ee/server/config/admin-actions.js

@@ -29,4 +29,14 @@ module.exports = {
       subCategory: 'options',
     },
   ],
+  reviewWorkflows: [
+    {
+      uid: 'review-workflows.read',
+      displayName: 'Read',
+      pluginName: 'admin',
+      section: 'settings',
+      category: 'review workflows',
+      subCategory: 'options',
+    },
+  ],
 };

package/ee/server/constants/default-stages.json

@@ -0,0 +1,14 @@
+[
+  {
+    "name": "To do"
+  },
+  {
+    "name": "Ready to review"
+  },
+  {
+    "name": "In progress"
+  },
+  {
+    "name": "Reviewed"
+  }
+]

package/ee/server/constants/default-workflow.json

@@ -0,0 +1 @@
+{}

package/ee/server/constants/workflows.js

@@ -0,0 +1,8 @@
+'use strict';
+
+// TODO concatenate admin + content type singular name
+module.exports = {
+  WORKFLOW_MODEL_UID: 'admin::workflow',
+  STAGE_MODEL_UID: 'admin::workflow-stage',
+  ENTITY_STAGE_ATTRIBUTE: 'strapi_reviewWorkflows_stage',
+};

package/ee/server/content-types/index.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const workflow = require('./workflow');
+const workflowStage = require('./workflow-stage');
+
+module.exports = {
+  workflow,
+  'workflow-stage': workflowStage,
+};

package/ee/server/content-types/workflow/index.js

@@ -0,0 +1,31 @@
+'use strict';
+
+module.exports = {
+  schema: {
+    collectionName: 'strapi_workflows',
+    info: {
+      name: 'Workflow',
+      description: '',
+      singularName: 'workflow',
+      pluralName: 'workflows',
+      displayName: 'Workflow',
+    },
+    options: {},
+    pluginOptions: {
+      'content-manager': {
+        visible: false,
+      },
+      'content-type-builder': {
+        visible: false,
+      },
+    },
+    attributes: {
+      stages: {
+        type: 'relation',
+        target: 'admin::workflow-stage',
+        relation: 'oneToMany',
+        mappedBy: 'workflow',
+      },
+    },
+  },
+};

package/ee/server/content-types/workflow-stage/index.js

@@ -0,0 +1,36 @@
+'use strict';
+
+module.exports = {
+  schema: {
+    collectionName: 'strapi_workflows_stages',
+    info: {
+      name: 'Workflow Stage',
+      description: '',
+      singularName: 'workflow-stage',
+      pluralName: 'workflow-stages',
+      displayName: 'Stages',
+    },
+    options: {},
+    pluginOptions: {
+      'content-manager': {
+        visible: false,
+      },
+      'content-type-builder': {
+        visible: false,
+      },
+    },
+    attributes: {
+      name: {
+        type: 'string',
+        configurable: false,
+      },
+      workflow: {
+        type: 'relation',
+        target: 'admin::workflow',
+        relation: 'manyToOne',
+        inversedBy: 'stages',
+        configurable: false,
+      },
+    },
+  },
+};

package/ee/server/controllers/index.js

@@ -6,4 +6,6 @@ module.exports = {
   user: require('./user'),
   auditLogs: require('./audit-logs'),
   admin: require('./admin'),
+  workflows: require('./workflows'),
+  stages: require('./workflows/stages'),
 };

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

@@ -0,0 +1,36 @@
+'use strict';
+
+const { getService } = require('../../utils');
+
+module.exports = {
+  /**
+   * List all workflows
+   * @param {import('koa').BaseContext} ctx - koa context
+   */
+  async find(ctx) {
+    const { populate } = ctx.query;
+    const workflowService = getService('workflows');
+    const data = await workflowService.find({
+      populate,
+    });
+
+    ctx.body = {
+      data,
+    };
+  },
+  /**
+   * Get one workflow based on its id contained in request parameters
+   * @param {import('koa').BaseContext} ctx - koa context
+   */
+  async findById(ctx) {
+    const { id } = ctx.params;
+    const { populate } = ctx.query;
+
+    const workflowService = getService('workflows');
+    const data = await workflowService.findById(id, { populate });
+
+    ctx.body = {
+      data,
+    };
+  },
+};

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

@@ -0,0 +1,102 @@
+'use strict';
+
+const { ApplicationError } = require('@strapi/utils/lib/errors');
+const { getService } = require('../../../utils');
+const { hasReviewWorkflow } = require('../../../utils/review-workflows');
+const {
+  validateUpdateStages,
+  validateUpdateStageOnEntity,
+} = require('../../../validation/review-workflows');
+
+module.exports = {
+  /**
+   * List all stages
+   * @param {import('koa').BaseContext} ctx - koa context
+   */
+  async find(ctx) {
+    const { workflow_id: workflowId } = ctx.params;
+    const { populate } = ctx.query;
+    const stagesService = getService('stages');
+
+    const data = await stagesService.find({
+      workflowId,
+      populate,
+    });
+
+    ctx.body = {
+      data,
+    };
+  },
+  /**
+   * Get one stage
+   * @param {import('koa').BaseContext} ctx - koa context
+   */
+  async findById(ctx) {
+    const { id, workflow_id: workflowId } = ctx.params;
+    const { populate } = ctx.query;
+    const stagesService = getService('stages');
+
+    const data = await stagesService.findById(id, {
+      workflowId,
+      populate,
+    });
+
+    ctx.body = {
+      data,
+    };
+  },
+
+  /**
+   * 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
+   * @param {Object} ctx - The Koa context object.
+   * @param {Object} ctx.params - An object containing the parameters from the request URL.
+   * @param {string} ctx.params.model_uid - The model UID of the entity.
+   * @param {string} ctx.params.id - The ID of the entity to update.
+   * @param {Object} ctx.request.body.data - Optional data object containing the new stage ID for the entity.
+   * @param {string} ctx.request.body.data.id - The ID of the new stage for the entity.
+   * @throws {ApplicationError} If review workflows is not activated on the specified model UID.
+   * @throws {ValidationError} If the `data` object in the request body fails to pass validation.
+   * @returns {Promise<void>} A promise that resolves when the entity's stage has been updated.
+   */
+  async updateEntity(ctx) {
+    const stagesService = getService('stages');
+    const { model_uid: modelUID, id: entityIdString } = ctx.params;
+    const entityId = Number(entityIdString);
+
+    const { id: stageId } = await validateUpdateStageOnEntity(
+      ctx.request?.body?.data,
+      '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 data = await stagesService.updateEntity({ id: entityId, modelUID }, stageId);
+
+    ctx.body = { data };
+  },
+};

package/ee/server/index.js

@@ -2,6 +2,7 @@
 
 module.exports = {
   register: require('./register'),
+  contentTypes: require('./content-types'),
   bootstrap: require('./bootstrap'),
   destroy: require('./destroy'),
   routes: require('./routes'),

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

@@ -0,0 +1,40 @@
+'use strict';
+
+const { set } = require('lodash/fp');
+
+module.exports = {
+  contentTypeMiddleware,
+};
+
+/**
+ * A Strapi middleware function that adds support for review workflows.
+ *
+ * Why is it needed ?
+ * For now, the admin panel cannot have anything but top-level attributes in the content-type for options.
+ * But we need the CE part to be agnostics from Review Workflow (which is an EE feature).
+ * CE handle the `options` object, that's why we move the reviewWorkflows boolean to the options object.
+ *
+ * @param {object} strapi - The Strapi instance.
+ */
+function contentTypeMiddleware(strapi) {
+  /**
+   * A middleware function that moves the `reviewWorkflows` attribute from the top level of
+   * the request body to the `options` object within the request body.
+   *
+   * @param {object} ctx - The Koa context object.
+   */
+  const moveReviewWorkflowOption = (ctx) => {
+    // Move reviewWorkflows to options.reviewWorkflows
+    const { reviewWorkflows, ...contentType } = ctx.request.body.contentType;
+
+    if (typeof reviewWorkflows === 'boolean') {
+      ctx.request.body.contentType = set('options.reviewWorkflows', reviewWorkflows, contentType);
+    }
+  };
+  strapi.server.router.use('/content-type-builder/content-types/:uid?', (ctx, next) => {
+    if (ctx.method === 'PUT' || ctx.method === 'POST') {
+      moveReviewWorkflowOption(ctx);
+    }
+    return next();
+  });
+}

package/ee/server/register.js

@@ -1,8 +1,11 @@
 'use strict';
 
+const { features } = require('@strapi/strapi/lib/utils/ee');
 const executeCERegister = require('../../server/register');
 const migrateAuditLogsTable = require('./migrations/audit-logs-table');
 const createAuditLogsService = require('./services/audit-logs');
+const reviewWorkflowsMiddlewares = require('./middlewares/review-workflows');
+const { getService } = require('./utils');
 
 module.exports = async ({ strapi }) => {
   const auditLogsIsEnabled = strapi.config.get('admin.auditLogs.enabled', true);
@@ -13,6 +16,11 @@ module.exports = async ({ strapi }) => {
     strapi.container.register('audit-logs', auditLogsService);
     await auditLogsService.register();
   }
+  if (features.isEnabled('review-workflows')) {
+    const reviewWorkflowService = getService('review-workflows');
 
+    reviewWorkflowsMiddlewares.contentTypeMiddleware(strapi);
+    await reviewWorkflowService.register();
+  }
   await executeCERegister({ strapi });
 };

package/ee/server/routes/index.js

@@ -122,4 +122,108 @@ module.exports = [
       ],
     },
   },
+
+  // Review workflow
+  {
+    method: 'GET',
+    path: '/review-workflows/workflows',
+    handler: 'workflows.find',
+    config: {
+      middlewares: [enableFeatureMiddleware('review-workflows')],
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        {
+          name: 'admin::hasPermissions',
+          config: {
+            actions: ['admin::review-workflows.read'],
+          },
+        },
+      ],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/review-workflows/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: '/review-workflows/workflows/:workflow_id/stages',
+    handler: 'stages.find',
+    config: {
+      middlewares: [enableFeatureMiddleware('review-workflows')],
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        {
+          name: 'admin::hasPermissions',
+          config: {
+            actions: ['admin::review-workflows.read'],
+          },
+        },
+      ],
+    },
+  },
+  {
+    method: 'PUT',
+    path: '/review-workflows/workflows/:workflow_id/stages',
+    handler: 'stages.replace',
+    config: {
+      middlewares: [enableFeatureMiddleware('review-workflows')],
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        {
+          name: 'admin::hasPermissions',
+          config: {
+            actions: ['admin::review-workflows.read'],
+          },
+        },
+      ],
+    },
+  },
+  {
+    method: 'GET',
+    path: '/review-workflows/workflows/:workflow_id/stages/:id',
+    handler: 'stages.findById',
+    config: {
+      middlewares: [enableFeatureMiddleware('review-workflows')],
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        {
+          name: 'admin::hasPermissions',
+          config: {
+            actions: ['admin::review-workflows.read'],
+          },
+        },
+      ],
+    },
+  },
+  {
+    method: 'PUT',
+    path: '/content-manager/(collection|single)-types/:model_uid/:id/stage',
+    handler: 'stages.updateEntity',
+    config: {
+      middlewares: [enableFeatureMiddleware('review-workflows')],
+      policies: [
+        'admin::isAuthenticatedAdmin',
+        {
+          name: 'admin::hasPermissions',
+          config: {
+            actions: ['admin::review-workflows.read'],
+          },
+        },
+      ],
+    },
+  },
 ];

package/ee/server/services/index.js

@@ -5,4 +5,8 @@ module.exports = {
   role: require('./role'),
   user: require('./user'),
   'seat-enforcement': require('./seat-enforcement'),
+  workflows: require('./review-workflows/workflows'),
+  stages: require('./review-workflows/stages'),
+  'review-workflows': require('./review-workflows/review-workflows'),
+  'review-workflows-decorator': require('./review-workflows/entity-service-decorator'),
 };

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

@@ -0,0 +1,54 @@
+'use strict';
+
+const { isNil, isNull } = require('lodash/fp');
+const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+const { hasReviewWorkflow, getDefaultWorkflow } = require('../../utils/review-workflows');
+
+/**
+ * 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) => {
+  if (!isNil(ENTITY_STAGE_ATTRIBUTE, data)) {
+    const defaultWorkflow = await getDefaultWorkflow({ strapi });
+    return { ...data, [ENTITY_STAGE_ATTRIBUTE]: defaultWorkflow.stages[0].id };
+  }
+  return data;
+};
+
+/**
+ * Decorates the entity service with RW business logic
+ * @param {object} service - entity service
+ */
+const decorator = (service) => ({
+  async create(uid, opts = {}) {
+    const hasRW = hasReviewWorkflow({ strapi }, uid);
+
+    if (!hasRW) {
+      return service.create.call(this, uid, opts);
+    }
+
+    const data = await getDataWithStage(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])) {
+      delete data[ENTITY_STAGE_ATTRIBUTE];
+    }
+
+    return service.update.call(this, uid, entityId, { ...opts, data });
+  },
+});
+
+module.exports = () => ({
+  decorator,
+});