@strapi/admin 4.9.2 → 4.10.0-beta.1

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

@@ -0,0 +1,111 @@
+'use strict';
+
+const { set, forEach, pipe } = require('lodash/fp');
+const { mapAsync } = require('@strapi/utils');
+const { getService } = require('../../utils');
+const { getContentTypeUIDsWithActivatedReviewWorkflows } = require('../../utils/review-workflows');
+
+const defaultStages = require('../../constants/default-stages.json');
+const defaultWorkflow = require('../../constants/default-workflow.json');
+const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+
+const { getDefaultWorkflow } = require('../../utils/review-workflows');
+const { persistTable, removePersistedTablesWithSuffix } = require('../../utils/persisted-tables');
+
+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: stages.map((stage) => stage.id),
+      },
+    };
+
+    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 });
+  }
+}
+
+function extendReviewWorkflowContentTypes({ strapi }) {
+  const extendContentType = (contentTypeUID) => {
+    const setStageAttribute = set(`attributes.${ENTITY_STAGE_ATTRIBUTE}`, {
+      writable: true,
+      private: false,
+      configurable: false,
+      visible: false,
+      useJoinTable: true, // We want a join table to persist data when downgrading to CE
+      type: 'relation',
+      relation: 'oneToOne',
+      target: 'admin::workflow-stage',
+    });
+    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 stagesService = getService('stages', { strapi });
+
+    const up = async (contentTypeUID) => {
+      // Persist the stage join table
+      const { attributes, tableName } = strapi.db.metadata.get(contentTypeUID);
+      const joinTableName = attributes[ENTITY_STAGE_ATTRIBUTE].joinTable.name;
+      await persistTable(joinTableName, [tableName]);
+
+      // Update CT entities stage
+      return stagesService.updateEntitiesStage(contentTypeUID, {
+        fromStageId: null,
+        toStageId: firstStage.id,
+      });
+    };
+
+    await removePersistedTablesWithSuffix('_strapi_review_workflows_stage_links');
+
+    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 }));
+    },
+  };
+};

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

@@ -0,0 +1,249 @@
+'use strict';
+
+const {
+  mapAsync,
+  errors: { ApplicationError },
+} = require('@strapi/utils');
+const { map } = require('lodash/fp');
+
+const { STAGE_MODEL_UID, ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
+const { getService } = require('../../utils');
+const { getContentTypeUIDsWithActivatedReviewWorkflows } = require('../../utils/review-workflows');
+
+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, { populate } = {}) {
+      const params = {
+        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 ({ trx }) => {
+        // Create the new stages
+        const createdStages = await this.createMany(created, { fields: ['id'] });
+        // Put all the newly created stages ids
+        const createdStagesIds = map('id', createdStages);
+        const stagesIds = stages.map((stage) => stage.id ?? createdStagesIds.shift());
+        const contentTypes = getContentTypeUIDsWithActivatedReviewWorkflows(strapi.contentTypes);
+
+        // Update the workflow stages
+        await mapAsync(updated, (stage) => this.update(stage.id, stage));
+
+        // Delete the stages that are not in the new stages list
+        await mapAsync(deleted, async (stage) => {
+          // Find the nearest stage in the workflow and newly created stages
+          // that is not deleted, prioritizing the previous stages
+          const nearestStage = findNearestMatchingStage(
+            [...workflow.stages, ...createdStages],
+            workflow.stages.findIndex((s) => s.id === stage.id),
+            (targetStage) => {
+              return !deleted.find((s) => s.id === targetStage.id);
+            }
+          );
+
+          // Assign the new stage to entities that had the deleted stage
+          await mapAsync(contentTypes, (contentTypeUID) => {
+            this.updateEntitiesStage(contentTypeUID, {
+              fromStageId: stage.id,
+              toStageId: nearestStage.id,
+              trx,
+            });
+          });
+
+          return 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
+     */
+    async updateEntity(entityInfo, stageId) {
+      const stage = await this.findById(stageId);
+
+      if (!stage) {
+        throw new ApplicationError(`Selected stage does not exist`);
+      }
+
+      return strapi.entityService.update(entityInfo.modelUID, entityInfo.id, {
+        data: { [ENTITY_STAGE_ATTRIBUTE]: stageId },
+        populate: [ENTITY_STAGE_ATTRIBUTE],
+      });
+    },
+
+    /**
+     * Updates the stage of all entities of a content type that are in a specific stage
+     * @param {string} contentTypeUID
+     * @param {number} fromStageId
+     * @param {number} toStageId
+     * @param {KnexTransaction} trx
+     * @returns
+     */
+    async updateEntitiesStage(contentTypeUID, { fromStageId, toStageId, trx = null }) {
+      const { attributes, tableName } = strapi.db.metadata.get(contentTypeUID);
+      const joinTable = attributes[ENTITY_STAGE_ATTRIBUTE].joinTable;
+      const joinColumn = joinTable.joinColumn.name;
+      const invJoinColumn = joinTable.inverseJoinColumn.name;
+
+      const selectStatement = strapi.db
+        .getConnection()
+        .select({ [joinColumn]: 't1.id', [invJoinColumn]: toStageId })
+        .from(`${tableName} as t1`)
+        .leftJoin(`${joinTable.name} as t2`, `t1.id`, `t2.${joinColumn}`)
+        .where(`t2.${invJoinColumn}`, fromStageId)
+        .toSQL();
+
+      // Insert rows for all entries of the content type that do not have a
+      // default stage
+      const query = strapi.db
+        .getConnection(joinTable.name)
+        .insert(
+          strapi.db.connection.raw(
+            `(${joinColumn}, ${invJoinColumn})  ${selectStatement.sql}`,
+            selectStatement.bindings
+          )
+        );
+
+      if (trx) {
+        query.transacting(trx);
+      }
+
+      return query;
+    },
+  };
+};
+
+/**
+ * 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.');
+  }
+}
+
+/**
+ * Find the id of the nearest object in an array that matches a condition.
+ * Used for searching for the nearest stage that is not deleted.
+ * Starts by searching the elements before the index, then the remaining elements in the array.
+ *
+ * @param {Array} stages
+ * @param {Number} startIndex the index to start searching from
+ * @param {Function} condition must evaluate to true for the object to be considered a match
+ * @returns {Object} stage
+ */
+function findNearestMatchingStage(stages, startIndex, condition) {
+  // Start by searching the elements before the startIndex
+  for (let i = startIndex; i >= 0; i -= 1) {
+    if (condition(stages[i])) {
+      return stages[i];
+    }
+  }
+
+  // If no matching element is found before the startIndex,
+  // search the remaining elements in the array
+  const remainingArray = stages.slice(startIndex + 1);
+  const nearestObject = remainingArray.filter(condition)[0];
+  return nearestObject;
+}

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

@@ -1,49 +1,141 @@
 'use strict';
 
+const { differenceWith, isEqual } = require('lodash/fp');
+
 /**
- * Finds all tables in the database that start with a prefix
- * @param {string} prefix
- * @returns {Array}
+ * Transform table name to the object format
+ * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }>} table
+ * @returns Array<{ table: string; dependsOn?: Array<{ table: string;}> }>
  */
-const findTablesThatStartWithPrefix = async (prefix) => {
-  const tables = await strapi.db.dialect.schemaInspector.getTables();
-  return tables.filter((tableName) => tableName.startsWith(prefix));
+const transformTableName = (table) => {
+  if (typeof table === 'string') {
+    return { name: table };
+  }
+  return table;
 };
 
 /**
- * Get all reserved table names from the core store
- * @returns {Array}
+ * Finds all tables in the database matching the regular expression
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @param {RegExp} regex
+ * @returns {Promise<string[]>}
  */
-const getPersistedTables = async () =>
-  (await strapi.store.get({
+async function findTables({ strapi }, regex) {
+  const tables = await strapi.db.dialect.schemaInspector.getTables();
+  return tables.filter((tableName) => regex.test(tableName));
+}
+
+/**
+ * Add tables name to the reserved tables in core store
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }>} tableNames
+ * @return {Promise<void>}
+ */
+async function addPersistTables({ strapi }, tableNames) {
+  const persistedTables = await getPersistedTables({ strapi });
+  const tables = tableNames.map(transformTableName);
+
+  // Get new tables to be persisted, remove tables if they already were persisted
+  const notPersistedTableNames = differenceWith(isEqual, tables, persistedTables);
+  // Remove tables that are going to be changed
+  const tablesToPersist = differenceWith(
+    (t1, t2) => t1.name === t2.name,
+    persistedTables,
+    notPersistedTableNames
+  );
+
+  if (!notPersistedTableNames.length) {
+    return;
+  }
+
+  tablesToPersist.push(...notPersistedTableNames);
+  await strapi.store.set({
     type: 'core',
     key: 'persisted_tables',
-  })) ?? [];
+    value: tablesToPersist,
+  });
+}
 
 /**
- * Add all table names that start with a prefix to the reserved tables in
- * core store
- * @param {string} tableNamePrefix
+ * Remove tables name from the reserved tables in core store
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @param {Array<string>} tableNames
+ * @return {Promise<void>}
  */
+async function removePersistedTables({ strapi }, tableNames) {
+  const persistedTables = await getPersistedTables({ strapi });
 
-const persistTablesWithPrefix = async (tableNamePrefix) => {
-  const persistedTables = await getPersistedTables();
-  const tableNames = await findTablesThatStartWithPrefix(tableNamePrefix);
-  const notReservedTableNames = tableNames.filter((name) => !persistedTables.includes(name));
+  // Get new tables to be persisted, remove tables if they already were persisted
+  const newPersistedTables = differenceWith(
+    (t1, t2) => t1.name === t2,
+    persistedTables,
+    tableNames
+  );
 
-  if (!notReservedTableNames.length) {
+  if (newPersistedTables.length === persistedTables.length) {
     return;
   }
 
-  persistedTables.push(...notReservedTableNames);
   await strapi.store.set({
     type: 'core',
     key: 'persisted_tables',
-    value: persistedTables,
+    value: newPersistedTables,
   });
+}
+
+/**
+ * Get all reserved table names from the core store
+ * @param {Object} ctx
+ * @param {Strapi} ctx.strapi
+ * @returns {Promise<string[]>}
+ */
+
+async function getPersistedTables({ strapi }) {
+  const persistedTables = await strapi.store.get({
+    type: 'core',
+    key: 'persisted_tables',
+  });
+
+  return (persistedTables || []).map(transformTableName);
+}
+
+/**
+ * Add all table names that start with a prefix to the reserved tables in
+ * core store
+ * @param {string} tableNamePrefix
+ * @return {Promise<void>}
+ */
+
+const persistTablesWithPrefix = async (tableNamePrefix) => {
+  const tableNameRegex = new RegExp(`^${tableNamePrefix}.*`);
+  const tableNames = await findTables({ strapi }, tableNameRegex);
+
+  await addPersistTables({ strapi }, tableNames);
+};
+
+/**
+ * Remove all table names that end with a suffix from the reserved tables in core store
+ * @param {string} tableNameSuffix
+ * @return {Promise<void>}
+ */
+const removePersistedTablesWithSuffix = async (tableNameSuffix) => {
+  const tableNameRegex = new RegExp(`.*${tableNameSuffix}$`);
+  const tableNames = await findTables({ strapi }, tableNameRegex);
+  await removePersistedTables({ strapi }, tableNames);
+};
+
+const persistTable = async (tableName, dependsOn) => {
+  await addPersistTables({ strapi }, [
+    { name: tableName, dependsOn: dependsOn?.map((depTableName) => ({ name: depTableName })) },
+  ]);
 };
 
 module.exports = {
   persistTablesWithPrefix,
-  findTablesThatStartWithPrefix,
+  removePersistedTablesWithSuffix,
+  persistTable,
+  findTables,
 };

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

@@ -0,0 +1,34 @@
+'use strict';
+
+const { get, keys, pickBy, pipe } = require('lodash/fp');
+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'] });
+
+const getContentTypeUIDsWithActivatedReviewWorkflows = pipe([
+  // Pick only content-types with reviewWorkflows options set to true
+  pickBy(get('options.reviewWorkflows')),
+  // Get UIDs
+  keys,
+]);
+
+module.exports = {
+  hasReviewWorkflow,
+  getDefaultWorkflow,
+  getContentTypeUIDsWithActivatedReviewWorkflows,
+};

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.2",
+  "version": "4.10.0-beta.1",
   "description": "Strapi Admin",
   "repository": {
     "type": "git",
@@ -48,15 +48,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.2",
-    "@strapi/data-transfer": "4.9.2",
+    "@strapi/babel-plugin-switch-ee-ce": "4.10.0-beta.1",
+    "@strapi/data-transfer": "4.10.0-beta.1",
     "@strapi/design-system": "1.6.6",
-    "@strapi/helper-plugin": "4.9.2",
+    "@strapi/helper-plugin": "4.10.0-beta.1",
     "@strapi/icons": "1.6.6",
-    "@strapi/permissions": "4.9.2",
-    "@strapi/provider-audit-logs-local": "4.9.2",
-    "@strapi/typescript-utils": "4.9.2",
-    "@strapi/utils": "4.9.2",
+    "@strapi/permissions": "4.10.0-beta.1",
+    "@strapi/provider-audit-logs-local": "4.10.0-beta.1",
+    "@strapi/typescript-utils": "4.10.0-beta.1",
+    "@strapi/utils": "4.10.0-beta.1",
     "axios": "1.3.4",
     "babel-loader": "^9.1.2",
     "babel-plugin-styled-components": "2.0.2",
@@ -168,5 +168,5 @@
       }
     }
   },
-  "gitHead": "91e0be2708e4d1e8ec731c75e73e54c0dfacb67d"
+  "gitHead": "95d581b31bee464af42e5d8db408fa578d8532c7"
 }