@strapi/admin 4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8 → 4.10.0-beta.0

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,42 @@
+'use strict';
+
+const { isNil } = 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,
+    });
+  },
+});
+
+module.exports = () => ({
+  decorator,
+});

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

@@ -0,0 +1,175 @@
+'use strict';
+
+const { set, get, forEach, keys, pickBy, pipe } = require('lodash/fp');
+const { mapAsync } = require('@strapi/utils');
+const { getService } = require('../../utils');
+
+const defaultStages = require('../../constants/default-stages.json');
+const defaultWorkflow = require('../../constants/default-workflow.json');
+const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+
+const {
+  disableOnContentTypes: disableReviewWorkflows,
+} = require('../../migrations/review-workflows');
+const { getDefaultWorkflow } = require('../../utils/review-workflows');
+
+const getContentTypeUIDsWithActivatedReviewWorkflows = pipe([
+  // Pick only content-types with reviewWorkflows options set to true
+  pickBy(get('options.reviewWorkflows')),
+  // Get UIDs
+  keys,
+]);
+
+/**
+ * Map every stage in the array to be ordered in the relation
+ * @param {Object[]} stages
+ * @param {number} stages.id
+ * @return {Object[]}
+ */
+function buildStagesConnectArray(stages) {
+  return stages.map((stage, index) => {
+    const connect = {
+      id: stage.id,
+      position: {},
+    };
+
+    if (index === 0) {
+      connect.position.start = true;
+    } else {
+      connect.position.after = stages[index - 1].id;
+    }
+    return connect;
+  });
+}
+
+async function initDefaultWorkflow({ workflowsService, stagesService, strapi }) {
+  const wfCount = await workflowsService.count();
+  const stagesCount = await stagesService.count();
+
+  // Check if there is nothing about review-workflow in DB
+  // If any, the feature has already been initialized with a workflow and stages
+  if (wfCount === 0 && stagesCount === 0) {
+    const stages = await stagesService.createMany(defaultStages, { fields: ['id'] });
+    const workflow = {
+      ...defaultWorkflow,
+      stages: {
+        connect: buildStagesConnectArray(stages),
+      },
+    };
+
+    await workflowsService.create(workflow);
+    // If there is any manually activated RW on content-types, we want to migrate the related entities
+    await enableReviewWorkflow({ strapi })({ contentTypes: strapi.contentTypes });
+  }
+}
+
+const setStageAttribute = set(`attributes.${ENTITY_STAGE_ATTRIBUTE}`, {
+  writable: true,
+  private: false,
+  configurable: false,
+  visible: false,
+  type: 'relation',
+  relation: 'morphOne',
+  target: 'admin::workflow-stage',
+  morphBy: 'related',
+});
+
+function extendReviewWorkflowContentTypes({ strapi }) {
+  const extendContentType = (contentTypeUID) => {
+    strapi.container.get('content-types').extend(contentTypeUID, setStageAttribute);
+  };
+  pipe([
+    getContentTypeUIDsWithActivatedReviewWorkflows,
+    // Iterate over UIDs to extend the content-type
+    forEach(extendContentType),
+  ])(strapi.contentTypes);
+}
+
+/**
+ * Enables the review workflow for the given content types.
+ * @param {Object} strapi - Strapi instance
+ */
+function enableReviewWorkflow({ strapi }) {
+  /**
+   * @param {Array<string>} contentTypes - Content type UIDs to enable the review workflow for.
+   * @returns {Promise<void>} - Promise that resolves when the review workflow is enabled.
+   */
+  return async ({ contentTypes }) => {
+    const defaultWorkflow = await getDefaultWorkflow({ strapi });
+    // This is possible if this is the first start of EE, there won't be any workflow in DB before bootstrap
+    if (!defaultWorkflow) {
+      return;
+    }
+    const firstStage = defaultWorkflow.stages[0];
+
+    const up = async (contentTypeUID) => {
+      const contentTypeMetadata = strapi.db.metadata.get(contentTypeUID);
+      const { target, morphBy } = contentTypeMetadata.attributes[ENTITY_STAGE_ATTRIBUTE];
+      const { joinTable } = strapi.db.metadata.get(target).attributes[morphBy];
+      const { idColumn, typeColumn } = joinTable.morphColumn;
+
+      // Execute an SQL query to insert records into the join table mapping the specified content type with the first stage of the default workflow.
+      // Only entities that do not have a record in the join table yet are selected.
+      const selectStatement = strapi.db
+        .getConnection()
+        .select({
+          [idColumn.name]: 'entity.id',
+          field: strapi.db.connection.raw('?', [ENTITY_STAGE_ATTRIBUTE]),
+          order: 1,
+          [joinTable.joinColumn.name]: firstStage.id,
+          [typeColumn.name]: strapi.db.connection.raw('?', [contentTypeUID]),
+        })
+        .leftJoin(`${joinTable.name} AS jointable`, function joinFunc() {
+          this.on('entity.id', '=', `jointable.${idColumn.name}`).andOn(
+            `jointable.${typeColumn.name}`,
+            '=',
+            strapi.db.connection.raw('?', [contentTypeUID])
+          );
+        })
+        .where(`jointable.${idColumn.name}`, null)
+        .from(`${contentTypeMetadata.tableName} AS entity`)
+        .toSQL();
+
+      const columnsToInsert = [
+        idColumn.name,
+        'field',
+        strapi.db.connection.raw('??', ['order']),
+        joinTable.joinColumn.name,
+        typeColumn.name,
+      ];
+
+      // Insert rows for all entries of the content type that do not have a
+      // default stage
+      await strapi.db
+        .getConnection(joinTable.name)
+        .insert(
+          strapi.db.connection.raw(
+            `(${columnsToInsert.join(',')})  ${selectStatement.sql}`,
+            selectStatement.bindings
+          )
+        );
+    };
+
+    return pipe([
+      getContentTypeUIDsWithActivatedReviewWorkflows,
+      // Iterate over UIDs to extend the content-type
+      (contentTypesUIDs) => mapAsync(contentTypesUIDs, up),
+    ])(contentTypes);
+  };
+}
+
+module.exports = ({ strapi }) => {
+  const workflowsService = getService('workflows', { strapi });
+  const stagesService = getService('stages', { strapi });
+
+  return {
+    async bootstrap() {
+      await initDefaultWorkflow({ workflowsService, stagesService, strapi });
+    },
+    async register() {
+      extendReviewWorkflowContentTypes({ strapi });
+      strapi.hook('strapi::content-types.afterSync').register(enableReviewWorkflow({ strapi }));
+      strapi.hook('strapi::content-types.afterSync').register(disableReviewWorkflows);
+    },
+  };
+};

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

@@ -0,0 +1,148 @@
+'use strict';
+
+const {
+  mapAsync,
+  errors: { ApplicationError },
+} = require('@strapi/utils');
+
+const { STAGE_MODEL_UID, ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+const { getService } = require('../../utils');
+
+module.exports = ({ strapi }) => {
+  const workflowsService = getService('workflows', { strapi });
+
+  return {
+    find({ workflowId, populate }) {
+      const params = {
+        filters: { workflow: workflowId },
+        populate,
+      };
+      return strapi.entityService.findMany(STAGE_MODEL_UID, params);
+    },
+
+    findById(id, { workflowId, populate }) {
+      const params = {
+        filters: { workflow: workflowId },
+        populate,
+      };
+      return strapi.entityService.findOne(STAGE_MODEL_UID, id, params);
+    },
+
+    createMany(stagesList, { fields }) {
+      const params = {
+        select: fields,
+      };
+      return Promise.all(
+        stagesList.map((stage) =>
+          strapi.entityService.create(STAGE_MODEL_UID, { data: stage, ...params })
+        )
+      );
+    },
+
+    update(stageId, stageData) {
+      return strapi.entityService.update(STAGE_MODEL_UID, stageId, { data: stageData });
+    },
+
+    delete(stageId) {
+      return strapi.entityService.delete(STAGE_MODEL_UID, stageId);
+    },
+
+    count() {
+      return strapi.entityService.count(STAGE_MODEL_UID);
+    },
+
+    async replaceWorkflowStages(workflowId, stages) {
+      const workflow = await workflowsService.findById(workflowId, { populate: ['stages'] });
+
+      const { created, updated, deleted } = getDiffBetweenStages(workflow.stages, stages);
+
+      assertAtLeastOneStageRemain(workflow.stages, { created, deleted });
+
+      return strapi.db.transaction(async () => {
+        const newStages = await this.createMany(created, { fields: ['id'] });
+        const stagesIds = stages.map((stage) => stage.id ?? newStages.shift().id);
+
+        await mapAsync(updated, (stage) => this.update(stage.id, stage));
+        await mapAsync(deleted, (stage) => this.delete(stage.id));
+        return workflowsService.update(workflowId, {
+          stages: stagesIds,
+        });
+      });
+    },
+
+    /**
+     * 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
+     */
+    updateEntity(entityInfo, stageId) {
+      return strapi.entityService.update(entityInfo.modelUID, entityInfo.id, {
+        data: { [ENTITY_STAGE_ATTRIBUTE]: stageId },
+        populate: [ENTITY_STAGE_ATTRIBUTE],
+      });
+    },
+  };
+};
+
+/**
+ * Compares two arrays of stages and returns an object indicating the differences.
+ *
+ * The function compares the `id` properties of each stage in `sourceStages` and `comparisonStages` to determine if the stage is present in both arrays.
+ * If a stage with the same `id` is found in both arrays but the `name` property is different, the stage is considered updated.
+ * If a stage with a particular `id` is only found in `comparisonStages`, it is considered created.
+ * If a stage with a particular `id` is only found in `sourceStages`, it is considered deleted.
+ *
+ * @typedef {{id: Number, name: String, workflow: Number}} Stage
+ * @typedef {{created: Stage[], updated: Stage[], deleted: Stage[]}} DiffStages
+ *
+ * The DiffStages object has three properties: `created`, `updated`, and `deleted`.
+ * `created` is an array of stages that are in `comparisonStages` but not in `sourceStages`.
+ * `updated` is an array of stages that have different names in `comparisonStages` and `sourceStages`.
+ * `deleted` is an array of stages that are in `sourceStages` but not in `comparisonStages`.
+ *
+ * @param {Stage[]} sourceStages
+ * @param {Stage[]} comparisonStages
+ * @returns { DiffStages }
+ */
+function getDiffBetweenStages(sourceStages, comparisonStages) {
+  const result = comparisonStages.reduce(
+    (acc, stageToCompare) => {
+      const srcStage = sourceStages.find((stage) => stage.id === stageToCompare.id);
+
+      if (!srcStage) {
+        acc.created.push(stageToCompare);
+      } else if (srcStage.name !== stageToCompare.name) {
+        acc.updated.push(stageToCompare);
+      }
+      return acc;
+    },
+    { created: [], updated: [] }
+  );
+
+  result.deleted = sourceStages.filter(
+    (srcStage) => !comparisonStages.some((cmpStage) => cmpStage.id === srcStage.id)
+  );
+
+  return result;
+}
+
+/**
+ * Asserts that at least one stage remains in the workflow after applying deletions and additions.
+ *
+ * @param {Array} workflowStages - An array of stages in the current workflow.
+ * @param {Object} diffStages - An object containing the stages to be deleted and created.
+ * @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.
+ */
+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.');
+  }
+}

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

@@ -0,0 +1,25 @@
+'use strict';
+
+const { WORKFLOW_MODEL_UID } = require('../../constants/workflows');
+
+module.exports = ({ strapi }) => ({
+  find(opts) {
+    return strapi.entityService.findMany(WORKFLOW_MODEL_UID, opts);
+  },
+
+  findById(id, opts) {
+    return strapi.entityService.findOne(WORKFLOW_MODEL_UID, id, opts);
+  },
+
+  create(workflowData) {
+    return strapi.entityService.create(WORKFLOW_MODEL_UID, { data: workflowData });
+  },
+
+  count() {
+    return strapi.entityService.count(WORKFLOW_MODEL_UID);
+  },
+
+  update(id, workflowData) {
+    return strapi.entityService.update(WORKFLOW_MODEL_UID, id, { data: workflowData });
+  },
+});

package/ee/server/utils/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+const getService = (name, { strapi } = { strapi: global.strapi }) => {
+  return strapi.service(`admin::${name}`);
+};
+module.exports = {
+  getService,
+};

package/ee/server/utils/persisted-tables.js

@@ -0,0 +1,49 @@
+'use strict';
+
+/**
+ * Finds all tables in the database that start with a prefix
+ * @param {string} prefix
+ * @returns {Array}
+ */
+const findTablesThatStartWithPrefix = async (prefix) => {
+  const tables = await strapi.db.dialect.schemaInspector.getTables();
+  return tables.filter((tableName) => tableName.startsWith(prefix));
+};
+
+/**
+ * Get all reserved table names from the core store
+ * @returns {Array}
+ */
+const getPersistedTables = async () =>
+  (await strapi.store.get({
+    type: 'core',
+    key: 'persisted_tables',
+  })) ?? [];
+
+/**
+ * Add all table names that start with a prefix to the reserved tables in
+ * core store
+ * @param {string} tableNamePrefix
+ */
+
+const persistTablesWithPrefix = async (tableNamePrefix) => {
+  const persistedTables = await getPersistedTables();
+  const tableNames = await findTablesThatStartWithPrefix(tableNamePrefix);
+  const notReservedTableNames = tableNames.filter((name) => !persistedTables.includes(name));
+
+  if (!notReservedTableNames.length) {
+    return;
+  }
+
+  persistedTables.push(...notReservedTableNames);
+  await strapi.store.set({
+    type: 'core',
+    key: 'persisted_tables',
+    value: persistedTables,
+  });
+};
+
+module.exports = {
+  persistTablesWithPrefix,
+  findTablesThatStartWithPrefix,
+};

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

@@ -0,0 +1,25 @@
+'use strict';
+
+const { WORKFLOW_MODEL_UID } = 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'] });
+
+module.exports = {
+  hasReviewWorkflow,
+  getDefaultWorkflow,
+};

package/ee/server/utils/test.js

@@ -0,0 +1,11 @@
+'use strict';
+
+/**
+ * Execute a test suite only if the condition is true
+ * @return Jest.Describe
+ */
+const describeOnCondition = (bool) => (bool ? describe : describe.skip);
+
+module.exports = {
+  describeOnCondition,
+};

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

@@ -0,0 +1,24 @@
+'use strict';
+
+const { yup, validateYupSchema } = require('@strapi/utils');
+
+const stageObject = yup.object().shape({
+  id: yup.number().integer().min(1),
+  name: yup.string().max(255).required(),
+});
+
+const validateUpdateStagesSchema = yup.array().of(stageObject).required();
+const validateUpdateStageOnEntity = yup
+  .object()
+  .shape({
+    id: yup.number().integer().min(1).required(),
+  })
+  .required();
+
+module.exports = {
+  validateUpdateStages: validateYupSchema(validateUpdateStagesSchema, {
+    strict: false,
+    stripUnknown: true,
+  }),
+  validateUpdateStageOnEntity: validateYupSchema(validateUpdateStageOnEntity),
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/admin",
-  "version": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
+  "version": "4.10.0-beta.0",
   "description": "Strapi Admin",
   "repository": {
     "type": "git",
@@ -46,15 +46,15 @@
     "@casl/ability": "^5.4.3",
     "@fingerprintjs/fingerprintjs": "3.3.6",
     "@pmmmwh/react-refresh-webpack-plugin": "0.5.10",
-    "@strapi/babel-plugin-switch-ee-ce": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
-    "@strapi/data-transfer": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
-    "@strapi/design-system": "1.6.5",
-    "@strapi/helper-plugin": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
-    "@strapi/icons": "1.6.5",
-    "@strapi/permissions": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
-    "@strapi/provider-audit-logs-local": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
-    "@strapi/typescript-utils": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
-    "@strapi/utils": "4.9.0-exp.90df253ba90fd6879eb56a720a1f80d04ff745b8",
+    "@strapi/babel-plugin-switch-ee-ce": "4.10.0-beta.0",
+    "@strapi/data-transfer": "4.10.0-beta.0",
+    "@strapi/design-system": "1.6.6",
+    "@strapi/helper-plugin": "4.10.0-beta.0",
+    "@strapi/icons": "1.6.6",
+    "@strapi/permissions": "4.10.0-beta.0",
+    "@strapi/provider-audit-logs-local": "4.10.0-beta.0",
+    "@strapi/typescript-utils": "4.10.0-beta.0",
+    "@strapi/utils": "4.10.0-beta.0",
     "axios": "1.3.4",
     "babel-loader": "^9.1.2",
     "babel-plugin-styled-components": "2.0.2",
@@ -115,7 +115,7 @@
     "react-error-boundary": "3.1.4",
     "react-fast-compare": "^3.2.0",
     "react-helmet": "^6.1.0",
-    "react-intl": "6.2.8",
+    "react-intl": "6.3.2",
     "react-is": "^17.0.2",
     "react-query": "3.24.3",
     "react-redux": "8.0.5",
@@ -134,7 +134,7 @@
     "typescript": "4.6.2",
     "webpack": "^5.76.0",
     "webpack-cli": "^5.0.1",
-    "webpack-dev-server": "^4.11.1",
+    "webpack-dev-server": "^4.13.1",
     "webpackbar": "^5.0.2",
     "yup": "^0.32.9"
   },
@@ -166,5 +166,5 @@
       }
     }
   },
-  "gitHead": "366eb8a0d0f06935914854c6d9c4b3fe859468e0"
+  "gitHead": "1519ef0e56d27b738f24fc88223797651ad47aaf"
 }