@strapi/admin 4.10.0-beta.0 → 4.10.0-beta.1

package/ee/admin/pages/SettingsPage/pages/ReviewWorkflows/components/Stages/Stage/Stage.js

@@ -45,7 +45,7 @@ function Stage({ id, name, index, canDelete, isOpen: isOpenDefault = false }) {
         action={
           canDelete ? (
             <IconButton
-              backgroundColor="transparent"
+              background="transparent"
               noBorder
               onClick={() => dispatch(deleteStage(id))}
               label={formatMessage({
@@ -57,7 +57,7 @@ function Stage({ id, name, index, canDelete, isOpen: isOpenDefault = false }) {
           ) : null
         }
       />
-      <AccordionContent padding={6} background="neutral0">
+      <AccordionContent padding={6} background="neutral0" hasRadius>
         <Grid gap={4}>
           <GridItem col={6}>
             <TextInput

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

@@ -22,8 +22,8 @@ export function useReviewWorkflows(workflowId) {
     }
   }
 
-  function refetchWorkflow() {
-    client.refetchQueries(workflowQueryKey);
+  async function refetchWorkflow() {
+    await client.refetchQueries(workflowQueryKey);
   }
 
   const workflows = useQuery(workflowQueryKey, fetchWorkflows);

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

@@ -35,6 +35,7 @@ export function reducer(state = initialState, action) {
           draft.serverState.workflows = workflows;
           draft.serverState.currentWorkflow = defaultWorkflow;
           draft.clientState.currentWorkflow.data = defaultWorkflow;
+          draft.clientState.currentWorkflow.hasDeletedServerStages = false;
         }
         break;
       }
@@ -97,7 +98,7 @@ export function reducer(state = initialState, action) {
     if (state.clientState.currentWorkflow.data) {
       draft.clientState.currentWorkflow.isDirty = !isEqual(
         current(draft.clientState.currentWorkflow).data,
-        state.serverState.currentWorkflow
+        draft.serverState.currentWorkflow
       );
     }
   });

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

@@ -20,9 +20,6 @@ module.exports = {
       },
     },
     attributes: {
-      uid: {
-        type: 'string',
-      },
       stages: {
         type: 'relation',
         target: 'admin::workflow-stage',

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

@@ -31,11 +31,6 @@ module.exports = {
         inversedBy: 'stages',
         configurable: false,
       },
-      related: {
-        type: 'relation',
-        relation: 'morphToMany',
-        configurable: false,
-      },
     },
   },
 };

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

@@ -46,6 +46,11 @@ module.exports = {
     };
   },
 
+  /**
+   * 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');
@@ -90,6 +95,8 @@ module.exports = {
     // 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);
+    const data = await stagesService.updateEntity({ id: entityId, modelUID }, stageId);
+
+    ctx.body = { data };
   },
 };

package/ee/server/register.js

@@ -8,7 +8,9 @@ const reviewWorkflowsMiddlewares = require('./middlewares/review-workflows');
 const { getService } = require('./utils');
 
 module.exports = async ({ strapi }) => {
-  if (features.isEnabled('audit-logs')) {
+  const auditLogsIsEnabled = strapi.config.get('admin.auditLogs.enabled', true);
+
+  if (auditLogsIsEnabled) {
     strapi.hook('strapi::content-types.beforeSync').register(migrateAuditLogsTable);
     const auditLogsService = createAuditLogsService(strapi);
     strapi.container.register('audit-logs', auditLogsService);

package/ee/server/services/audit-logs.js

@@ -63,16 +63,37 @@ const getEventMap = (defaultEvents) => {
   }, {});
 };
 
+const getRetentionDays = (strapi) => {
+  const licenseRetentionDays = features.get('audit-logs')?.options.retentionDays;
+  const userRetentionDays = strapi.config.get('admin.auditLogs.retentionDays');
+
+  // For enterprise plans, use 90 days by default, but allow users to override it
+  if (licenseRetentionDays == null) {
+    return userRetentionDays ?? DEFAULT_RETENTION_DAYS;
+  }
+
+  // Allow users to override the license retention days, but not to increase it
+  if (userRetentionDays && userRetentionDays < licenseRetentionDays) {
+    return userRetentionDays;
+  }
+
+  // User didn't provide a retention days value, use the license one
+  return licenseRetentionDays;
+};
+
 const createAuditLogsService = (strapi) => {
+  // Manage internal service state privately
+  const state = {};
+
   // NOTE: providers should be able to replace getEventMap to add or remove events
   const eventMap = getEventMap(defaultEvents);
 
   const processEvent = (name, ...args) => {
-    const state = strapi.requestContext.get()?.state;
+    const requestState = strapi.requestContext.get()?.state;
 
     // Ignore events with auth strategies different from admin
-    const isUsingAdminAuth = state?.auth?.strategy.name === 'admin';
-    const user = state?.user;
+    const isUsingAdminAuth = requestState?.auth?.strategy.name === 'admin';
+    const user = requestState?.user;
 
     if (!isUsingAdminAuth || !user) {
       return null;
@@ -103,26 +124,60 @@ const createAuditLogsService = (strapi) => {
     const processedEvent = processEvent(name, ...args);
 
     if (processedEvent) {
-      await this._provider.saveEvent(processedEvent);
+      await state.provider.saveEvent(processedEvent);
     }
   }
 
   return {
     async register() {
-      const retentionDays =
-        features.get('audit-logs')?.options.retentionDays ?? DEFAULT_RETENTION_DAYS;
-      this._provider = await localProvider.register({ strapi });
-      this._eventHubUnsubscribe = strapi.eventHub.subscribe(handleEvent.bind(this));
-      this._deleteExpiredJob = scheduleJob('0 0 * * *', () => {
+      // Handle license being enabled
+      if (!state.eeEnableUnsubscribe) {
+        state.eeEnableUnsubscribe = strapi.eventHub.on('ee.enable', () => {
+          // Recreate the service to use the new license info
+          this.destroy();
+          this.register();
+        });
+      }
+
+      // Handle license being updated
+      if (!state.eeUpdateUnsubscribe) {
+        state.eeUpdateUnsubscribe = strapi.eventHub.on('ee.update', () => {
+          // Recreate the service to use the new license info
+          this.destroy();
+          this.register();
+        });
+      }
+
+      // Handle license being disabled
+      state.eeDisableUnsubscribe = strapi.eventHub.on('ee.disable', () => {
+        // Turn off service when the license gets disabled
+        // Only ee.enable and ee.update listeners remain active to recreate the service
+        this.destroy();
+      });
+
+      // Register the provider now because collections can't be added later at runtime
+      state.provider = await localProvider.register({ strapi });
+
+      // Check current state of license
+      if (!features.isEnabled('audit-logs')) {
+        return this;
+      }
+
+      // Start saving events
+      state.eventHubUnsubscribe = strapi.eventHub.subscribe(handleEvent.bind(this));
+
+      // Manage audit logs auto deletion
+      const retentionDays = getRetentionDays(strapi);
+      state.deleteExpiredJob = scheduleJob('0 0 * * *', () => {
         const expirationDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
-        this._provider.deleteExpiredEvents(expirationDate);
+        state.provider.deleteExpiredEvents(expirationDate);
       });
 
       return this;
     },
 
     async findMany(query) {
-      const { results, pagination } = await this._provider.findMany(query);
+      const { results, pagination } = await state.provider.findMany(query);
 
       const sanitizedResults = results.map((result) => {
         const { user, ...rest } = result;
@@ -139,7 +194,7 @@ const createAuditLogsService = (strapi) => {
     },
 
     async findOne(id) {
-      const result = await this._provider.findOne(id);
+      const result = await state.provider.findOne(id);
 
       if (!result) {
         return null;
@@ -153,12 +208,16 @@ const createAuditLogsService = (strapi) => {
     },
 
     unsubscribe() {
-      if (this._eventHubUnsubscribe) {
-        this._eventHubUnsubscribe();
+      if (state.eeDisableUnsubscribe) {
+        state.eeDisableUnsubscribe();
+      }
+
+      if (state.eventHubUnsubscribe) {
+        state.eventHubUnsubscribe();
       }
 
-      if (this._deleteExpiredJob) {
-        this._deleteExpiredJob.cancel();
+      if (state.deleteExpiredJob) {
+        state.deleteExpiredJob.cancel();
       }
 
       return this;

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

@@ -1,6 +1,6 @@
 'use strict';
 
-const { isNil } = require('lodash/fp');
+const { isNil, isNull } = require('lodash/fp');
 const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
 const { hasReviewWorkflow, getDefaultWorkflow } = require('../../utils/review-workflows');
 
@@ -30,10 +30,22 @@ const decorator = (service) => ({
     }
 
     const data = await getDataWithStage(opts.data);
-    return service.create.call(this, uid, {
-      ...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 });
   },
 });
 

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

@@ -1,46 +1,16 @@
 'use strict';
 
-const { set, get, forEach, keys, pickBy, pipe } = require('lodash/fp');
+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 {
-  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;
-  });
-}
+const { persistTable, removePersistedTablesWithSuffix } = require('../../utils/persisted-tables');
 
 async function initDefaultWorkflow({ workflowsService, stagesService, strapi }) {
   const wfCount = await workflowsService.count();
@@ -53,7 +23,7 @@ async function initDefaultWorkflow({ workflowsService, stagesService, strapi })
     const workflow = {
       ...defaultWorkflow,
       stages: {
-        connect: buildStagesConnectArray(stages),
+        connect: stages.map((stage) => stage.id),
       },
     };
 
@@ -63,19 +33,18 @@ async function initDefaultWorkflow({ workflowsService, stagesService, strapi })
   }
 }
 
-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) => {
+    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([
@@ -101,55 +70,23 @@ function enableReviewWorkflow({ strapi }) {
       return;
     }
     const firstStage = defaultWorkflow.stages[0];
+    const stagesService = getService('stages', { strapi });
 
     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
-          )
-        );
+      // 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
@@ -169,7 +106,6 @@ module.exports = ({ 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

@@ -4,9 +4,11 @@ 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 });
@@ -20,9 +22,8 @@ module.exports = ({ strapi }) => {
       return strapi.entityService.findMany(STAGE_MODEL_UID, params);
     },
 
-    findById(id, { workflowId, populate }) {
+    findById(id, { populate } = {}) {
       const params = {
-        filters: { workflow: workflowId },
         populate,
       };
       return strapi.entityService.findOne(STAGE_MODEL_UID, id, params);
@@ -58,12 +59,41 @@ module.exports = ({ strapi }) => {
 
       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);
+      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));
-        await mapAsync(deleted, (stage) => this.delete(stage.id));
+
+        // 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,
         });
@@ -78,12 +108,58 @@ module.exports = ({ strapi }) => {
      * @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) {
+    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;
+    },
   };
 };
 
@@ -146,3 +222,28 @@ function assertAtLeastOneStageRemain(workflowStages, diffStages) {
     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;
+}