@strapi/admin 4.10.0-beta.0 → 4.10.0

package/ee/admin/pages/SettingsPage/pages/AuditLogs/ListView/utils/getDisplayedFilters.js

@@ -12,27 +12,7 @@ const customOperators = [
   },
 ];
 
-const getDisplayedFilters = ({ formatMessage, users }) => {
-  const getDisplaynameFromUser = (user) => {
-    if (user.username) {
-      return user.username;
-    }
-    if (user.firstname && user.lastname) {
-      return formatMessage(
-        {
-          id: 'Settings.permissions.auditLogs.user.fullname',
-          defaultMessage: '{firstname} {lastname}',
-        },
-        {
-          firstname: user.firstname,
-          lastname: user.lastname,
-        }
-      );
-    }
-
-    return user.email;
-  };
-
+const getDisplayedFilters = ({ formatMessage, users, canReadUsers }) => {
   const actionOptions = Object.keys(actionTypes).map((action) => {
     return {
       label: formatMessage(
@@ -46,17 +26,7 @@ const getDisplayedFilters = ({ formatMessage, users }) => {
     };
   });
 
-  const userOptions =
-    users &&
-    users.results.map((user) => {
-      return {
-        label: getDisplaynameFromUser(user),
-        // Combobox expects a string value
-        customValue: user.id.toString(),
-      };
-    });
-
-  return [
+  const filters = [
     {
       name: 'action',
       metadatas: {
@@ -80,20 +50,57 @@ const getDisplayedFilters = ({ formatMessage, users }) => {
       },
       fieldSchema: { type: 'datetime' },
     },
-    {
-      name: 'user',
-      metadatas: {
-        customOperators,
-        label: formatMessage({
-          id: 'Settings.permissions.auditLogs.user',
-          defaultMessage: 'User',
-        }),
-        options: userOptions,
-        customInput: ComboboxFilter,
-      },
-      fieldSchema: { type: 'relation', mainField: { name: 'id' } },
-    },
   ];
+
+  if (canReadUsers && users) {
+    const getDisplayNameFromUser = (user) => {
+      if (user.username) {
+        return user.username;
+      }
+
+      if (user.firstname && user.lastname) {
+        return formatMessage(
+          {
+            id: 'Settings.permissions.auditLogs.user.fullname',
+            defaultMessage: '{firstname} {lastname}',
+          },
+          {
+            firstname: user.firstname,
+            lastname: user.lastname,
+          }
+        );
+      }
+
+      return user.email;
+    };
+
+    const userOptions = users.results.map((user) => {
+      return {
+        label: getDisplayNameFromUser(user),
+        // Combobox expects a string value
+        customValue: user.id.toString(),
+      };
+    });
+
+    return [
+      ...filters,
+      {
+        name: 'user',
+        metadatas: {
+          customOperators,
+          label: formatMessage({
+            id: 'Settings.permissions.auditLogs.user',
+            defaultMessage: 'User',
+          }),
+          options: userOptions,
+          customInput: ComboboxFilter,
+        },
+        fieldSchema: { type: 'relation', mainField: { name: 'id' } },
+      },
+    ];
+  }
+
+  return filters;
 };
 
 export default getDisplayedFilters;

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

@@ -86,10 +86,10 @@ export function ReviewWorkflowsPage() {
   };
 
   const submitForm = async () => {
-    setIsConfirmDeleteDialogOpen(false);
-
     await updateWorkflowStages(currentWorkflow.id, currentWorkflow.stages);
-    refetchWorkflow();
+    await refetchWorkflow();
+
+    setIsConfirmDeleteDialogOpen(false);
   };
 
   const handleConfirmDeleteDialog = async () => {
@@ -122,7 +122,8 @@ export function ReviewWorkflowsPage() {
 
   useEffect(() => {
     trackUsage('didViewWorkflow');
-  }, [trackUsage]);
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   return (
     <CheckPagePermissions permissions={adminPermissions.settings['review-workflows'].main}>
@@ -143,6 +144,9 @@ export function ReviewWorkflowsPage() {
                     type="submit"
                     size="M"
                     disabled={!currentWorkflowIsDirty}
+                    // if the confirm dialog is open the loading state is on
+                    // the confirm button already
+                    loading={!isConfirmDeleteDialogOpen && isLoading}
                   >
                     {formatMessage({
                       id: 'global.save',
@@ -181,7 +185,7 @@ export function ReviewWorkflowsPage() {
             bodyText={{
               id: 'Settings.review-workflows.page.delete.confirm.body',
               defaultMessage:
-                'All entries assigned to deleted stages will be moved to the first stage. Are you sure you want to save this?',
+                'All entries assigned to deleted stages will be moved to the previous stage. Are you sure you want to save?',
             }}
             isConfirmButtonLoading={isLoading}
             isOpen={isConfirmDeleteDialogOpen}

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/authentication/middlewares.js

@@ -95,13 +95,14 @@ const redirectWithAuth = (ctx) => {
     params: { provider },
   } = ctx;
   const redirectUrls = utils.getPrefixedRedirectUrls();
+  const domain = strapi.config.get('server.admin.auth.domain');
   const { user } = ctx.state;
 
   const jwt = getService('token').createJwtToken(user);
 
   const isProduction = strapi.config.get('environment') === 'production';
 
-  const cookiesOptions = { httpOnly: false, secure: isProduction, overwrite: true };
+  const cookiesOptions = { httpOnly: false, secure: isProduction, overwrite: true, domain };
 
   const sanitizedUser = getService('user').sanitizeUser(user);
   strapi.eventHub.emit('admin.auth.success', { user: sanitizedUser, provider });

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/index.js

@@ -9,4 +9,5 @@ module.exports = {
   stages: require('./review-workflows/stages'),
   'review-workflows': require('./review-workflows/review-workflows'),
   'review-workflows-decorator': require('./review-workflows/entity-service-decorator'),
+  'review-workflows-metrics': require('./review-workflows/metrics'),
 };

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/metrics.js

@@ -0,0 +1,24 @@
+'use strict';
+
+const sendDidCreateStage = async () => {
+  strapi.telemetry.send('didCreateStage', {});
+};
+
+const sendDidEditStage = async () => {
+  strapi.telemetry.send('didEditStage', {});
+};
+
+const sendDidDeleteStage = async () => {
+  strapi.telemetry.send('didDeleteStage', {});
+};
+
+const sendDidChangeEntryStage = async () => {
+  strapi.telemetry.send('didChangeEntryStage', {});
+};
+
+module.exports = {
+  sendDidCreateStage,
+  sendDidEditStage,
+  sendDidDeleteStage,
+  sendDidChangeEntryStage,
+};

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, map } = 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 { persistTables, 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,63 +70,44 @@ function enableReviewWorkflow({ strapi }) {
       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
-          )
-        );
+    const stagesService = getService('stages', { strapi });
+
+    const updateEntitiesStage = async (contentTypeUID) => {
+      // Update CT entities stage
+      return stagesService.updateEntitiesStage(contentTypeUID, {
+        fromStageId: null,
+        toStageId: firstStage.id,
+      });
     };
 
     return pipe([
       getContentTypeUIDsWithActivatedReviewWorkflows,
       // Iterate over UIDs to extend the content-type
-      (contentTypesUIDs) => mapAsync(contentTypesUIDs, up),
+      (contentTypesUIDs) => mapAsync(contentTypesUIDs, updateEntitiesStage),
     ])(contentTypes);
   };
 }
 
+function persistStagesJoinTables({ strapi }) {
+  return async ({ contentTypes }) => {
+    const getStageTableToPersist = (contentTypeUID) => {
+      // Persist the stage join table
+      const { attributes, tableName } = strapi.db.metadata.get(contentTypeUID);
+      const joinTableName = attributes[ENTITY_STAGE_ATTRIBUTE].joinTable.name;
+      return { name: joinTableName, dependsOn: { name: tableName } };
+    };
+
+    const joinTablesToPersist = pipe([
+      getContentTypeUIDsWithActivatedReviewWorkflows,
+      map(getStageTableToPersist),
+    ])(contentTypes);
+
+    // TODO: Instead of removing all the tables, we should only remove the ones that are not in the joinTablesToPersist
+    await removePersistedTablesWithSuffix('_strapi_review_workflows_stage_links');
+    await persistTables(joinTablesToPersist);
+  };
+}
+
 module.exports = ({ strapi }) => {
   const workflowsService = getService('workflows', { strapi });
   const stagesService = getService('stages', { strapi });
@@ -169,7 +119,7 @@ module.exports = ({ strapi }) => {
     async register() {
       extendReviewWorkflowContentTypes({ strapi });
       strapi.hook('strapi::content-types.afterSync').register(enableReviewWorkflow({ strapi }));
-      strapi.hook('strapi::content-types.afterSync').register(disableReviewWorkflows);
+      strapi.hook('strapi::content-types.afterSync').register(persistStagesJoinTables({ strapi }));
     },
   };
 };