@strapi/admin 4.9.0 → 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/audit-logs.js

@@ -63,37 +63,16 @@ 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 requestState = strapi.requestContext.get()?.state;
+    const state = strapi.requestContext.get()?.state;
 
     // Ignore events with auth strategies different from admin
-    const isUsingAdminAuth = requestState?.auth?.strategy.name === 'admin';
-    const user = requestState?.user;
+    const isUsingAdminAuth = state?.auth?.strategy.name === 'admin';
+    const user = state?.user;
 
     if (!isUsingAdminAuth || !user) {
       return null;
@@ -124,60 +103,26 @@ const createAuditLogsService = (strapi) => {
     const processedEvent = processEvent(name, ...args);
 
     if (processedEvent) {
-      await state.provider.saveEvent(processedEvent);
+      await this._provider.saveEvent(processedEvent);
     }
   }
 
   return {
     async register() {
-      // 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 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 * * *', () => {
         const expirationDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
-        state.provider.deleteExpiredEvents(expirationDate);
+        this._provider.deleteExpiredEvents(expirationDate);
       });
 
       return this;
     },
 
     async findMany(query) {
-      const { results, pagination } = await state.provider.findMany(query);
+      const { results, pagination } = await this._provider.findMany(query);
 
       const sanitizedResults = results.map((result) => {
         const { user, ...rest } = result;
@@ -194,7 +139,7 @@ const createAuditLogsService = (strapi) => {
     },
 
     async findOne(id) {
-      const result = await state.provider.findOne(id);
+      const result = await this._provider.findOne(id);
 
       if (!result) {
         return null;
@@ -208,16 +153,12 @@ const createAuditLogsService = (strapi) => {
     },
 
     unsubscribe() {
-      if (state.eeDisableUnsubscribe) {
-        state.eeDisableUnsubscribe();
-      }
-
-      if (state.eventHubUnsubscribe) {
-        state.eventHubUnsubscribe();
+      if (this._eventHubUnsubscribe) {
+        this._eventHubUnsubscribe();
       }
 
-      if (state.deleteExpiredJob) {
-        state.deleteExpiredJob.cancel();
+      if (this._deleteExpiredJob) {
+        this._deleteExpiredJob.cancel();
       }
 
       return this;

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/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,
+};