@strapi/admin 4.16.1 → 4.17.0

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

@@ -1,101 +0,0 @@
-'use strict';
-
-const { isNil } = require('lodash/fp');
-const { ENTITY_STAGE_ATTRIBUTE } = require('../../constants/workflows');
-const { WORKFLOW_UPDATE_STAGE } = require('../../constants/webhookEvents');
-const { getService } = require('../../utils');
-
-/**
- * Assigns the entity data to the default workflow stage if no stage is present in the data
- * @param {Object} data
- * @returns
- */
-const getDataWithStage = async (workflow, data) => {
-  if (!isNil(ENTITY_STAGE_ATTRIBUTE, data)) {
-    return { ...data, [ENTITY_STAGE_ATTRIBUTE]: workflow.stages[0].id };
-  }
-  return data;
-};
-
-/**
- * Get the stage information of an entity
- * @param {String} uid
- * @param {Number} id
- * @returns {Object}
- */
-const getEntityStage = async (uid, id) => {
-  const entity = await strapi.entityService.findOne(uid, id, {
-    populate: {
-      [ENTITY_STAGE_ATTRIBUTE]: {
-        populate: {
-          workflow: true,
-        },
-      },
-    },
-  });
-  return entity?.[ENTITY_STAGE_ATTRIBUTE] ?? {};
-};
-
-/**
- * Decorates the entity service with RW business logic
- * @param {object} service - entity service
- */
-const decorator = (service) => ({
-  async create(uid, opts = {}) {
-    const workflow = await getService('workflows').getAssignedWorkflow(uid, {
-      populate: 'stages',
-    });
-
-    if (!workflow) {
-      return service.create.call(this, uid, opts);
-    }
-
-    const data = await getDataWithStage(workflow, opts.data);
-    return service.create.call(this, uid, { ...opts, data });
-  },
-  async update(uid, entityId, opts = {}) {
-    // Prevents the stage from being set to null
-    const data = { ...opts.data };
-    if (isNil(data[ENTITY_STAGE_ATTRIBUTE])) {
-      delete data[ENTITY_STAGE_ATTRIBUTE];
-      return service.update.call(this, uid, entityId, { ...opts, data });
-    }
-
-    const previousStage = await getEntityStage(uid, entityId);
-
-    const updatedEntity = await service.update.call(this, uid, entityId, { ...opts, data });
-    const updatedStage = updatedEntity[ENTITY_STAGE_ATTRIBUTE];
-
-    // Stage might be null if field is not populated
-    if (updatedStage && previousStage?.id && previousStage.id !== updatedStage.id) {
-      const model = strapi.getModel(uid);
-
-      strapi.eventHub.emit(WORKFLOW_UPDATE_STAGE, {
-        model: model.modelName,
-        uid: model.uid,
-        entity: {
-          id: entityId,
-        },
-        workflow: {
-          id: previousStage.workflow.id,
-          stages: {
-            from: {
-              id: previousStage.id,
-              name: previousStage.name,
-            },
-            to: {
-              id: updatedStage.id,
-              name: updatedStage.name,
-            },
-          },
-        },
-      });
-    }
-
-    return updatedEntity;
-  },
-});
-
-module.exports = () => ({
-  decorator,
-});

package/ee/server/services/review-workflows/metrics/__tests__/weekly-metrics.test.js

@@ -1,65 +0,0 @@
-'use strict';
-
-const weeklyMetrics = require('../weekly-metrics');
-
-jest.mock('../../../../../../server/utils', () => {
-  return {
-    getService: jest.fn(() => {
-      const workflowsMock = {
-        find: jest.fn(() => [
-          {
-            id: 1,
-            stages: [{ id: 1, name: 'To Do' }],
-            contentTypes: [{ uid: 'test-model' }],
-          },
-          {
-            id: 2,
-            stages: [
-              { id: 2, name: 'To Do' },
-              { id: 3, name: 'In Progress' },
-            ],
-            contentTypes: [{ uid: 'test-model-1' }],
-          },
-          {
-            id: 3,
-            stages: [
-              { id: 4, name: 'To Do' },
-              { id: 5, name: 'In Progress' },
-              { id: 6, name: 'Ready to Review' },
-            ],
-          },
-          {
-            id: 4,
-            stages: [
-              { id: 7, name: 'To Do' },
-              { id: 8, name: 'In Progress' },
-              { id: 9, name: 'Ready to Review' },
-              { id: 10, name: 'Reviewed' },
-            ],
-            contentTypes: [{ uid: 'test-model-2' }],
-          },
-        ]),
-      };
-
-      return {
-        ...workflowsMock,
-      };
-    }),
-  };
-});
-
-describe('Review workflows - Weekly Metrics', () => {
-  describe('computeMetrics', () => {
-    test('Computes the correct workflow metrics', async () => {
-      const service = weeklyMetrics({ strapi: {} });
-
-      const metrics = await service.computeMetrics();
-      expect(metrics).toEqual({
-        numberOfActiveWorkflows: 4,
-        avgStagesCount: 2.5,
-        maxStagesCount: 4,
-        activatedContentTypes: 3,
-      });
-    });
-  });
-});

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

@@ -1,56 +0,0 @@
-'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', {});
-};
-
-const sendDidCreateWorkflow = async () => {
-  strapi.telemetry.send('didCreateWorkflow', {});
-};
-
-const sendDidEditWorkflow = async () => {
-  strapi.telemetry.send('didEditWorkflow', {});
-};
-
-const sendDidEditAssignee = async (fromId, toId) => {
-  strapi.telemetry.send('didEditAssignee', { from: fromId, to: toId });
-};
-
-const sendDidSendReviewWorkflowPropertiesOnceAWeek = async (
-  numberOfActiveWorkflows,
-  avgStagesCount,
-  maxStagesCount,
-  activatedContentTypes
-) => {
-  strapi.telemetry.send('didSendReviewWorkflowPropertiesOnceAWeek', {
-    groupProperties: {
-      numberOfActiveWorkflows,
-      avgStagesCount,
-      maxStagesCount,
-      activatedContentTypes,
-    },
-  });
-};
-
-module.exports = {
-  sendDidCreateStage,
-  sendDidEditStage,
-  sendDidDeleteStage,
-  sendDidChangeEntryStage,
-  sendDidCreateWorkflow,
-  sendDidEditWorkflow,
-  sendDidSendReviewWorkflowPropertiesOnceAWeek,
-  sendDidEditAssignee,
-};

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

@@ -1,76 +0,0 @@
-'use strict';
-
-const { flow, map, sum, size, mean, max, defaultTo } = require('lodash/fp');
-const { add } = require('date-fns');
-const { getService } = require('../../../../../server/utils');
-
-const ONE_WEEK = 7 * 24 * 60 * 60 * 1000;
-
-const getWeeklyCronScheduleAt = (date) =>
-  `${date.getSeconds()} ${date.getMinutes()} ${date.getHours()} * * ${date.getDay()}`;
-
-const getMetricsStoreValue = async () => {
-  const value = await strapi.store.get({ type: 'plugin', name: 'ee', key: 'metrics' });
-  return defaultTo({}, value);
-};
-
-const setMetricsStoreValue = (value) =>
-  strapi.store.set({ type: 'plugin', name: 'ee', key: 'metrics', value });
-
-module.exports = ({ strapi }) => {
-  const metrics = getService('review-workflows-metrics', { strapi });
-  const workflowsService = getService('workflows', { strapi });
-
-  return {
-    async computeMetrics() {
-      // There will never be more than 200 workflow, so we can safely fetch them all
-      const workflows = await workflowsService.find({ populate: 'stages' });
-
-      const stagesCount = flow(
-        map('stages'), // Number of stages per workflow
-        map(size)
-      )(workflows);
-
-      const contentTypesCount = flow(
-        map('contentTypes'), // Number of content types per workflow
-        map(size)
-      )(workflows);
-
-      return {
-        numberOfActiveWorkflows: size(workflows),
-        avgStagesCount: mean(stagesCount),
-        maxStagesCount: max(stagesCount),
-        activatedContentTypes: sum(contentTypesCount),
-      };
-    },
-
-    async sendMetrics() {
-      const computedMetrics = await this.computeMetrics();
-      metrics.sendDidSendReviewWorkflowPropertiesOnceAWeek(computedMetrics);
-
-      const metricsInfoStored = await getMetricsStoreValue();
-      await setMetricsStoreValue({ ...metricsInfoStored, lastWeeklyUpdate: new Date().getTime() });
-    },
-
-    async ensureWeeklyStoredCronSchedule() {
-      const metricsInfoStored = await getMetricsStoreValue();
-      const { weeklySchedule: currentSchedule, lastWeeklyUpdate } = metricsInfoStored;
-
-      const now = new Date();
-      let weeklySchedule = currentSchedule;
-
-      if (!currentSchedule || !lastWeeklyUpdate || lastWeeklyUpdate + ONE_WEEK < now.getTime()) {
-        weeklySchedule = getWeeklyCronScheduleAt(add(now, { seconds: 10 }));
-        await setMetricsStoreValue({ ...metricsInfoStored, weeklySchedule });
-      }
-
-      return weeklySchedule;
-    },
-
-    async registerCron() {
-      const weeklySchedule = await this.ensureWeeklyStoredCronSchedule();
-
-      strapi.cron.add({ [weeklySchedule]: this.sendMetrics.bind(this) });
-    },
-  };
-};

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

@@ -1,133 +0,0 @@
-'use strict';
-
-const { filter, set, forEach, pipe, map, stubTrue, cond, defaultsDeep } = require('lodash/fp');
-const { getService } = require('../../utils');
-const { getVisibleContentTypesUID, hasStageAttribute } = require('../../utils/review-workflows');
-
-const defaultStages = require('../../constants/default-stages.json');
-const defaultWorkflow = require('../../constants/default-workflow.json');
-const {
-  ENTITY_STAGE_ATTRIBUTE,
-  ENTITY_ASSIGNEE_ATTRIBUTE,
-  STAGE_MODEL_UID,
-  MAX_WORKFLOWS,
-  MAX_STAGES_PER_WORKFLOW,
-} = require('../../constants/workflows');
-
-const { persistTables, removePersistedTablesWithSuffix } = require('../../utils/persisted-tables');
-const webhookEvents = require('../../constants/webhookEvents');
-
-const MAX_DB_TABLE_NAME_LEN = 63; // Postgres limit
-// The longest index name that Strapi can create is prefixed with '_strapi_stage_links_inv_fk', so the content type name  should be no longer than this.
-const MAX_JOIN_TABLE_NAME_SUFFIX =
-  1 /* _ */ + ENTITY_STAGE_ATTRIBUTE.length + '_links_inv_fk'.length;
-const MAX_CONTENT_TYPE_NAME_LEN = MAX_DB_TABLE_NAME_LEN - MAX_JOIN_TABLE_NAME_SUFFIX;
-
-const DEFAULT_OPTIONS = {
-  numberOfWorkflows: MAX_WORKFLOWS,
-  stagesPerWorkflow: MAX_STAGES_PER_WORKFLOW,
-};
-
-async function initDefaultWorkflow({ workflowsService, stagesService }) {
-  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 workflow = {
-      ...defaultWorkflow,
-      stages: defaultStages,
-    };
-
-    await workflowsService.create({ data: workflow });
-  }
-}
-
-function extendReviewWorkflowContentTypes({ strapi }) {
-  const extendContentType = (contentTypeUID) => {
-    const assertContentTypeCompatibility = (contentType) =>
-      contentType.collectionName.length <= MAX_CONTENT_TYPE_NAME_LEN;
-    const incompatibleContentTypeAlert = (contentType) => {
-      strapi.log.warn(
-        `Review Workflow cannot be activated for the content type with the name '${contentType.info.displayName}' because the name exceeds the maximum length of ${MAX_CONTENT_TYPE_NAME_LEN} characters.`
-      );
-      return contentType;
-    };
-
-    const setRelation = (path, target) =>
-      set(path, {
-        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,
-      });
-
-    const setReviewWorkflowAttributes = pipe([
-      setRelation(`attributes.${ENTITY_STAGE_ATTRIBUTE}`, STAGE_MODEL_UID),
-      setRelation(`attributes.${ENTITY_ASSIGNEE_ATTRIBUTE}`, 'admin::user'),
-    ]);
-
-    const extendContentTypeIfCompatible = cond([
-      [assertContentTypeCompatibility, setReviewWorkflowAttributes],
-      [stubTrue, incompatibleContentTypeAlert],
-    ]);
-    strapi.container.get('content-types').extend(contentTypeUID, extendContentTypeIfCompatible);
-  };
-
-  pipe([
-    getVisibleContentTypesUID,
-    // Iterate over UIDs to extend the content-type
-    forEach(extendContentType),
-  ])(strapi.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([
-      getVisibleContentTypesUID,
-      filter((uid) => hasStageAttribute(contentTypes[uid])),
-      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_stage_links');
-    await persistTables(joinTablesToPersist);
-  };
-}
-
-const registerWebhookEvents = async ({ strapi }) =>
-  Object.entries(webhookEvents).forEach(([eventKey, event]) =>
-    strapi.webhookStore.addAllowedEvent(eventKey, event)
-  );
-
-module.exports = ({ strapi }) => {
-  const workflowsService = getService('workflows', { strapi });
-  const stagesService = getService('stages', { strapi });
-  const workflowsValidationService = getService('review-workflows-validation', { strapi });
-
-  return {
-    async bootstrap() {
-      await registerWebhookEvents({ strapi });
-      await initDefaultWorkflow({ workflowsService, stagesService, strapi });
-    },
-    async register({ options } = { options: {} }) {
-      extendReviewWorkflowContentTypes({ strapi });
-      strapi.hook('strapi::content-types.afterSync').register(persistStagesJoinTables({ strapi }));
-
-      const reviewWorkflowsOptions = defaultsDeep(DEFAULT_OPTIONS, options);
-      workflowsValidationService.register(reviewWorkflowsOptions);
-    },
-  };
-};

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

@@ -1,60 +0,0 @@
-'use strict';
-
-const { prop } = require('lodash/fp');
-const {
-  mapAsync,
-  errors: { ApplicationError },
-} = require('@strapi/utils');
-const { getService } = require('../../utils');
-const { STAGE_TRANSITION_UID } = require('../../constants/workflows');
-
-const validActions = [STAGE_TRANSITION_UID];
-
-module.exports = ({ strapi }) => {
-  const roleService = getService('role');
-  const permissionService = getService('permission');
-
-  return {
-    async register({ roleId, action, fromStage }) {
-      if (!validActions.includes(action)) {
-        throw new ApplicationError(`Invalid action ${action}`);
-      }
-      const permissions = await roleService.addPermissions(roleId, [
-        {
-          action,
-          actionParameters: {
-            from: fromStage,
-          },
-        },
-      ]);
-
-      // TODO: Filter response
-      return permissions;
-    },
-    async registerMany(permissions) {
-      return mapAsync(permissions, this.register);
-    },
-    async unregister(permissions) {
-      const permissionIds = permissions.map(prop('id'));
-      await permissionService.deleteByIds(permissionIds);
-    },
-    can(action, fromStage) {
-      const requestState = strapi.requestContext.get()?.state;
-
-      if (!requestState) {
-        return false;
-      }
-
-      // Override permissions for super admin
-      const userRoles = requestState.user?.roles;
-      if (userRoles?.some((role) => role.code === 'strapi-super-admin')) {
-        return true;
-      }
-
-      return requestState.userAbility.can({
-        name: action,
-        params: { from: fromStage },
-      });
-    },
-  };
-};