@strapi/admin 4.9.0 → 4.10.0-beta.0

package/ee/admin/pages/SettingsPage/pages/ReviewWorkflows/hooks/useReviewWorkflows.js

@@ -0,0 +1,35 @@
+import { useQuery, useQueryClient } from 'react-query';
+import { useFetchClient } from '@strapi/helper-plugin';
+
+const QUERY_BASE_KEY = 'review-workflows';
+const API_BASE_URL = '/admin/review-workflows';
+
+export function useReviewWorkflows(workflowId) {
+  const { get } = useFetchClient();
+  const client = useQueryClient();
+  const workflowQueryKey = [QUERY_BASE_KEY, workflowId ?? 'default'];
+
+  async function fetchWorkflows({ params = { populate: 'stages' } }) {
+    try {
+      const {
+        data: { data },
+      } = await get(`${API_BASE_URL}/workflows/${workflowId ?? ''}`, { params });
+
+      return data;
+    } catch (err) {
+      // silence
+      return null;
+    }
+  }
+
+  function refetchWorkflow() {
+    client.refetchQueries(workflowQueryKey);
+  }
+
+  const workflows = useQuery(workflowQueryKey, fetchWorkflows);
+
+  return {
+    workflows,
+    refetchWorkflow,
+  };
+}

package/ee/admin/pages/SettingsPage/pages/ReviewWorkflows/index.js

@@ -0,0 +1,3 @@
+import { ReviewWorkflowsPage } from './ReviewWorkflows';
+
+export default ReviewWorkflowsPage;

package/ee/admin/pages/SettingsPage/pages/ReviewWorkflows/reducer/index.js

@@ -0,0 +1,121 @@
+import { current, produce } from 'immer';
+import isEqual from 'lodash/isEqual';
+
+import {
+  ACTION_SET_WORKFLOWS,
+  ACTION_DELETE_STAGE,
+  ACTION_ADD_STAGE,
+  ACTION_UPDATE_STAGE,
+} from '../constants';
+
+export const initialState = {
+  status: 'loading',
+  serverState: {
+    currentWorkflow: null,
+    workflows: [],
+  },
+  clientState: {
+    currentWorkflow: { data: null, isDirty: false, hasDeletedServerStages: false },
+  },
+};
+
+export function reducer(state = initialState, action) {
+  return produce(state, (draft) => {
+    const { payload } = action;
+
+    switch (action.type) {
+      case ACTION_SET_WORKFLOWS: {
+        const { status, workflows } = payload;
+
+        draft.status = status;
+
+        if (workflows) {
+          const defaultWorkflow = workflows[0];
+
+          draft.serverState.workflows = workflows;
+          draft.serverState.currentWorkflow = defaultWorkflow;
+          draft.clientState.currentWorkflow.data = defaultWorkflow;
+        }
+        break;
+      }
+
+      case ACTION_DELETE_STAGE: {
+        const { stageId } = payload;
+        const { currentWorkflow } = state.clientState;
+
+        draft.clientState.currentWorkflow.data.stages = currentWorkflow.data.stages.filter(
+          (stage) => (stage?.id ?? stage.__temp_key__) !== stageId
+        );
+
+        if (!currentWorkflow.hasDeletedServerStages) {
+          draft.clientState.currentWorkflow.hasDeletedServerStages =
+            !!state.serverState.currentWorkflow.stages.find((stage) => stage.id === stageId);
+        }
+
+        break;
+      }
+
+      case ACTION_ADD_STAGE: {
+        const { currentWorkflow } = state.clientState;
+
+        if (!currentWorkflow.data) {
+          draft.clientState.currentWorkflow.data = {
+            stages: [],
+          };
+        }
+
+        const newTempKey = getMaxTempKey(draft.clientState.currentWorkflow.data.stages);
+
+        draft.clientState.currentWorkflow.data.stages.push({
+          ...payload,
+          __temp_key__: newTempKey,
+        });
+
+        break;
+      }
+
+      case ACTION_UPDATE_STAGE: {
+        const { currentWorkflow } = state.clientState;
+        const { stageId, ...modified } = payload;
+
+        draft.clientState.currentWorkflow.data.stages = currentWorkflow.data.stages.map((stage) =>
+          (stage.id ?? stage.__temp_key__) === stageId
+            ? {
+                ...stage,
+                ...modified,
+              }
+            : stage
+        );
+
+        break;
+      }
+
+      default:
+        break;
+    }
+
+    if (state.clientState.currentWorkflow.data) {
+      draft.clientState.currentWorkflow.isDirty = !isEqual(
+        current(draft.clientState.currentWorkflow).data,
+        state.serverState.currentWorkflow
+      );
+    }
+  });
+}
+
+/**
+ * @type {(stages: Array<{id?: number; __temp_key__: number}>) => number}
+ */
+const getMaxTempKey = (stages = []) => {
+  /**
+   * We check if there are ids or __temp_key__ because you may add a stage to a list of stages
+   * already in the DB, alternatively you might add multiple new stages at once.
+   */
+  const ids = stages.map((stage) => stage.id ?? stage.__temp_key__);
+
+  /**
+   * If there are no ids it will return 0 as the max value
+   * because the max value is -1.
+   */
+  return Math.max(...ids, -1) + 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,34 @@
+'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: {
+      uid: {
+        type: 'string',
+      },
+      stages: {
+        type: 'relation',
+        target: 'admin::workflow-stage',
+        relation: 'oneToMany',
+        mappedBy: 'workflow',
+      },
+    },
+  },
+};

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

@@ -0,0 +1,41 @@
+'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,
+      },
+      related: {
+        type: 'relation',
+        relation: 'morphToMany',
+        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,95 @@
+'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,
+    };
+  },
+
+  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
+
+    ctx.body = await stagesService.updateEntity({ id: entityId, modelUID }, stageId);
+  },
+};

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/migrations/review-workflows.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { hasReviewWorkflow } = require('../utils/review-workflows');
+
+/**
+ * Remove all stage information for all content types that have had review workflows disabled
+ */
+/* eslint-disable no-continue */
+const disableOnContentTypes = async ({ oldContentTypes, contentTypes }) => {
+  const uidsToRemove = [];
+  for (const uid in contentTypes) {
+    if (!oldContentTypes || !oldContentTypes[uid]) {
+      continue;
+    }
+
+    const oldContentType = oldContentTypes[uid];
+    const contentType = contentTypes?.[uid];
+
+    if (
+      hasReviewWorkflow({ strapi }, oldContentType) &&
+      !hasReviewWorkflow({ strapi }, contentType)
+    ) {
+      // If review workflows has been turned off on a content type
+      // remove stage information from all entities within this CT
+      uidsToRemove.push(uid);
+    }
+  }
+
+  if (uidsToRemove.length === 0) {
+    return;
+  }
+
+  await strapi.db
+    .connection('strapi_workflows_stages_related_morphs')
+    .whereIn('related_type', uidsToRemove)
+    .del();
+};
+
+module.exports = { disableOnContentTypes };

package/ee/server/register.js

@@ -1,18 +1,24 @@
 '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);
-
-  if (auditLogsIsEnabled) {
+  if (features.isEnabled('audit-logs')) {
     strapi.hook('strapi::content-types.beforeSync').register(migrateAuditLogsTable);
     const auditLogsService = createAuditLogsService(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 });
 };