@strapi/admin 4.16.2 → 4.18.0

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

@@ -1,211 +0,0 @@
-'use strict';
-
-const { omit } = require('lodash/fp');
-const { WORKFLOW_UPDATE_STAGE } = require('../../../constants/webhookEvents');
-const { ENTITY_STAGE_ATTRIBUTE } = require('../../../constants/workflows');
-const { decorator } = require('../entity-service-decorator')();
-const utils = require('../../../utils');
-
-jest.mock('../../../utils', () => {
-  const workflowsMock = {
-    getAssignedWorkflow: jest.fn(() => ({ id: 1, stages: [{ id: 1, name: 'To Do' }] })),
-  };
-
-  return {
-    getService: jest.fn(() => workflowsMock),
-  };
-});
-
-const rwModel = {
-  options: {
-    reviewWorkflows: true,
-  },
-};
-
-const model = {
-  options: {
-    reviewWorkflows: false,
-  },
-};
-
-const models = {
-  'test-model': rwModel,
-  'non-rw-model': model,
-};
-
-describe('Entity service decorator', () => {
-  beforeAll(() => {
-    global.strapi = {
-      getModel(uid) {
-        return models[uid || 'test-model'];
-      },
-      query: () => ({
-        findOne: () => ({
-          id: 1,
-          stages: [{ id: 1 }],
-        }),
-      }),
-      entityService: {
-        findOne: jest.fn(),
-      },
-    };
-  });
-
-  describe('Create', () => {
-    test('Calls original create for non review workflow content types', async () => {
-      utils.getService().getAssignedWorkflow.mockReturnValueOnce(null);
-      const entry = {
-        id: 1,
-      };
-
-      const defaultService = {
-        create: jest.fn(() => Promise.resolve(entry)),
-      };
-
-      const service = decorator(defaultService);
-
-      const input = { data: { title: 'title ' } };
-      await service.create('non-rw-model', input);
-
-      expect(defaultService.create).toHaveBeenCalledWith('non-rw-model', input);
-    });
-
-    test('Assigns default stage to new review workflow entity', async () => {
-      const entry = {
-        id: 1,
-      };
-
-      const defaultService = {
-        create: jest.fn(() => Promise.resolve(entry)),
-      };
-
-      const service = decorator(defaultService);
-
-      const input = { data: { title: 'title ' } };
-      await service.create('test-model', input);
-
-      expect(defaultService.create).toHaveBeenCalledWith('test-model', {
-        ...input,
-        data: {
-          ...input.data,
-          [ENTITY_STAGE_ATTRIBUTE]: 1,
-        },
-      });
-    });
-  });
-
-  describe('Update', () => {
-    const uid = 'test-model';
-
-    test('Calls original update for non review workflow content types', async () => {
-      const entry = {
-        id: 1,
-      };
-
-      const defaultService = {
-        update: jest.fn(() => Promise.resolve(entry)),
-      };
-
-      const service = decorator(defaultService);
-
-      const id = 1;
-      const input = { data: { title: 'title ' } };
-      await service.update('non-rw-model', id, input);
-
-      expect(defaultService.update).toHaveBeenCalledWith('non-rw-model', id, input);
-    });
-
-    test('Assigns a stage to new review workflow entity', async () => {
-      const entityId = 10;
-      const workflowId = 1;
-      const stageFromId = 2;
-      const stageToId = 3;
-
-      const defaultService = {
-        update: jest.fn(() =>
-          Promise.resolve({
-            id: entityId,
-            [ENTITY_STAGE_ATTRIBUTE]: {
-              id: stageToId,
-              name: `Stage ${stageToId}`,
-              workflow: { id: workflowId },
-            },
-          })
-        ),
-      };
-
-      const emit = jest.fn();
-      global.strapi = {
-        ...global.strapi,
-        entityService: {
-          findOne: jest.fn(() => {
-            return {
-              [ENTITY_STAGE_ATTRIBUTE]: {
-                id: stageFromId,
-                name: `Stage ${stageFromId}`,
-                workflow: { id: workflowId },
-              },
-            };
-          }),
-          emitEvent: jest.fn(),
-        },
-        getModel: jest.fn(() => ({
-          modelName: uid,
-          uid,
-        })),
-        eventHub: {
-          emit,
-        },
-      };
-
-      const service = decorator(defaultService);
-
-      const input = { data: { title: 'title ', [ENTITY_STAGE_ATTRIBUTE]: stageToId } };
-      await service.update(uid, entityId, input);
-
-      expect(defaultService.update).toHaveBeenCalledWith(uid, entityId, input);
-
-      expect(emit).toHaveBeenCalledWith(WORKFLOW_UPDATE_STAGE, {
-        entity: { id: entityId },
-        model: uid,
-        uid,
-        workflow: {
-          id: workflowId,
-          stages: {
-            from: {
-              id: stageFromId,
-              name: `Stage ${stageFromId}`,
-            },
-            to: {
-              id: stageToId,
-              name: `Stage ${stageToId}`,
-            },
-          },
-        },
-      });
-    });
-
-    test('Can not assign a null stage to new review workflow entity', async () => {
-      const entry = {
-        id: 1,
-      };
-
-      const defaultService = {
-        update: jest.fn(() => Promise.resolve(entry)),
-      };
-
-      const service = decorator(defaultService);
-
-      const id = 1;
-      const input = { data: { title: 'title ', [ENTITY_STAGE_ATTRIBUTE]: null } };
-      await service.update(uid, id, input);
-
-      expect(defaultService.update).toHaveBeenCalledWith(uid, id, {
-        ...input,
-        data: {
-          ...omit(ENTITY_STAGE_ATTRIBUTE, input.data),
-        },
-      });
-    });
-  });
-});

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

@@ -1,54 +0,0 @@
-'use strict';
-
-const { ApplicationError } = require('@strapi/utils').errors;
-const { isNil } = require('lodash/fp');
-const { ENTITY_ASSIGNEE_ATTRIBUTE } = require('../../constants/workflows');
-const { getService } = require('../../utils');
-
-module.exports = ({ strapi }) => {
-  const metrics = getService('review-workflows-metrics', { strapi });
-
-  return {
-    async findEntityAssigneeId(id, model) {
-      const entity = await strapi.entityService.findOne(model, id, {
-        populate: [ENTITY_ASSIGNEE_ATTRIBUTE],
-        fields: [],
-      });
-
-      return entity?.[ENTITY_ASSIGNEE_ATTRIBUTE]?.id ?? null;
-    },
-
-    /**
-     * Update the assignee of an entity
-     */
-    async updateEntityAssignee(id, model, assigneeId) {
-      if (isNil(assigneeId)) {
-        return this.deleteEntityAssignee(id, model);
-      }
-
-      const userExists = await getService('user', { strapi }).exists({ id: assigneeId });
-
-      if (!userExists) {
-        throw new ApplicationError(`Selected user does not exist`);
-      }
-
-      metrics.sendDidEditAssignee(await this.findEntityAssigneeId(id, model), assigneeId);
-
-      return strapi.entityService.update(model, id, {
-        data: { [ENTITY_ASSIGNEE_ATTRIBUTE]: assigneeId },
-        populate: [ENTITY_ASSIGNEE_ATTRIBUTE],
-        fields: [],
-      });
-    },
-
-    async deleteEntityAssignee(id, model) {
-      metrics.sendDidEditAssignee(await this.findEntityAssigneeId(id, model), null);
-
-      return strapi.entityService.update(model, id, {
-        data: { [ENTITY_ASSIGNEE_ATTRIBUTE]: null },
-        populate: [ENTITY_ASSIGNEE_ATTRIBUTE],
-        fields: [],
-      });
-    },
-  };
-};

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);
-    },
-  };
-};