@strapi/admin 4.16.1 → 4.17.0

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

@@ -1,236 +0,0 @@
-'use strict';
-
-const localProvider = require('@strapi/provider-audit-logs-local');
-const { scheduleJob } = require('node-schedule');
-const { features } = require('@strapi/strapi/dist/utils/ee');
-
-const DEFAULT_RETENTION_DAYS = 90;
-
-const defaultEvents = [
-  'entry.create',
-  'entry.update',
-  'entry.delete',
-  'entry.publish',
-  'entry.unpublish',
-  'media.create',
-  'media.update',
-  'media.delete',
-  'media-folder.create',
-  'media-folder.update',
-  'media-folder.delete',
-  'user.create',
-  'user.update',
-  'user.delete',
-  'admin.auth.success',
-  'admin.logout',
-  'content-type.create',
-  'content-type.update',
-  'content-type.delete',
-  'component.create',
-  'component.update',
-  'component.delete',
-  'role.create',
-  'role.update',
-  'role.delete',
-  'permission.create',
-  'permission.update',
-  'permission.delete',
-];
-
-const getSanitizedUser = (user) => {
-  let displayName = user.email;
-
-  if (user.username) {
-    displayName = user.username;
-  } else if (user.firstname && user.lastname) {
-    displayName = `${user.firstname} ${user.lastname}`;
-  }
-
-  return {
-    id: user.id,
-    email: user.email,
-    displayName,
-  };
-};
-
-const getEventMap = (defaultEvents) => {
-  const getDefaultPayload = (...args) => args[0];
-
-  // Use the default payload for all default events
-  return defaultEvents.reduce((acc, event) => {
-    acc[event] = getDefaultPayload;
-    return acc;
-  }, {});
-};
-
-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;
-
-    // Ignore events with auth strategies different from admin
-    const isUsingAdminAuth = requestState?.auth?.strategy.name === 'admin';
-    const user = requestState?.user;
-
-    if (!isUsingAdminAuth || !user) {
-      return null;
-    }
-
-    const getPayload = eventMap[name];
-
-    // Ignore the event if it's not in the map
-    if (!getPayload) {
-      return null;
-    }
-
-    // Ignore some events based on payload
-    const ignoredUids = ['plugin::upload.file', 'plugin::upload.folder'];
-    if (ignoredUids.includes(args[0]?.uid)) {
-      return null;
-    }
-
-    return {
-      action: name,
-      date: new Date().toISOString(),
-      payload: getPayload(...args) || {},
-      userId: user.id,
-    };
-  };
-
-  async function handleEvent(name, ...args) {
-    const processedEvent = processEvent(name, ...args);
-
-    if (processedEvent) {
-      // This stores the event when after the transaction is committed,
-      // so it's not stored if the transaction is rolled back
-      await strapi.db.transaction(({ onCommit }) => {
-        onCommit(() => state.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 expirationDate = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000);
-        state.provider.deleteExpiredEvents(expirationDate);
-      });
-
-      return this;
-    },
-
-    async findMany(query) {
-      const { results, pagination } = await state.provider.findMany(query);
-
-      const sanitizedResults = results.map((result) => {
-        const { user, ...rest } = result;
-        return {
-          ...rest,
-          user: user ? getSanitizedUser(user) : null,
-        };
-      });
-
-      return {
-        results: sanitizedResults,
-        pagination,
-      };
-    },
-
-    async findOne(id) {
-      const result = await state.provider.findOne(id);
-
-      if (!result) {
-        return null;
-      }
-
-      const { user, ...rest } = result;
-      return {
-        ...rest,
-        user: user ? getSanitizedUser(user) : null,
-      };
-    },
-
-    unsubscribe() {
-      if (state.eeDisableUnsubscribe) {
-        state.eeDisableUnsubscribe();
-      }
-
-      if (state.eventHubUnsubscribe) {
-        state.eventHubUnsubscribe();
-      }
-
-      if (state.deleteExpiredJob) {
-        state.deleteExpiredJob.cancel();
-      }
-
-      return this;
-    },
-
-    destroy() {
-      return this.unsubscribe();
-    },
-  };
-};
-
-module.exports = createAuditLogsService;

package/ee/server/services/auth.js

@@ -1,75 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { getAbsoluteAdminUrl } = require('@strapi/utils');
-const { ApplicationError } = require('@strapi/utils').errors;
-const { getService } = require('../utils');
-const { isSsoLocked } = require('../utils/sso-lock');
-
-/**
- * Send an email to the user if it exists and is not locked to SSO
- * If those conditions are not met, nothing happens
- *
- * @param {Object} param params
- * @param {string} param.email user email for which to reset the password
- */
-const forgotPassword = async ({ email } = {}) => {
-  const user = await strapi.query('admin::user').findOne({ where: { email, isActive: true } });
-
-  if (!user || (await isSsoLocked(user))) {
-    return;
-  }
-
-  const resetPasswordToken = getService('token').createToken();
-  await getService('user').updateById(user.id, { resetPasswordToken });
-
-  // Send an email to the admin.
-  const url = `${getAbsoluteAdminUrl(
-    strapi.config
-  )}/auth/reset-password?code=${resetPasswordToken}`;
-  return strapi
-    .plugin('email')
-    .service('email')
-    .sendTemplatedEmail(
-      {
-        to: user.email,
-        from: strapi.config.get('admin.forgotPassword.from'),
-        replyTo: strapi.config.get('admin.forgotPassword.replyTo'),
-      },
-      strapi.config.get('admin.forgotPassword.emailTemplate'),
-      {
-        url,
-        user: _.pick(user, ['email', 'firstname', 'lastname', 'username']),
-      }
-    )
-    .catch((err) => {
-      // log error server side but do not disclose it to the user to avoid leaking informations
-      strapi.log.error(err);
-    });
-};
-
-/**
- * Reset a user password
- * @param {Object} param params
- * @param {string} param.resetPasswordToken token generated to request a password reset
- * @param {string} param.password new user password
- */
-const resetPassword = async ({ resetPasswordToken, password } = {}) => {
-  const matchingUser = await strapi
-    .query('admin::user')
-    .findOne({ where: { resetPasswordToken, isActive: true } });
-
-  if (!matchingUser || (await isSsoLocked(matchingUser))) {
-    throw new ApplicationError();
-  }
-
-  return getService('user').updateById(matchingUser.id, {
-    password,
-    resetPasswordToken: null,
-  });
-};
-
-module.exports = {
-  forgotPassword,
-  resetPassword,
-};

package/ee/server/services/index.js

@@ -1,18 +0,0 @@
-'use strict';
-
-module.exports = {
-  auth: require('./auth'),
-  passport: require('./passport'),
-  role: require('./role'),
-  user: require('./user'),
-  'seat-enforcement': require('./seat-enforcement'),
-  workflows: require('./review-workflows/workflows'),
-  stages: require('./review-workflows/stages'),
-  'stage-permissions': require('./review-workflows/stage-permissions'),
-  assignees: require('./review-workflows/assignees'),
-  'review-workflows': require('./review-workflows/review-workflows'),
-  'review-workflows-validation': require('./review-workflows/validation'),
-  'review-workflows-decorator': require('./review-workflows/entity-service-decorator'),
-  'review-workflows-metrics': require('./review-workflows/metrics'),
-  'review-workflows-weekly-metrics': require('./review-workflows/metrics/weekly-metrics'),
-};

package/ee/server/services/passport/provider-registry.js

@@ -1,27 +0,0 @@
-'use strict';
-
-module.exports = () => {
-  const registry = new Map();
-
-  Object.assign(registry, {
-    register(provider) {
-      if (strapi.isLoaded) {
-        throw new Error(`You can't register new provider after the bootstrap`);
-      }
-
-      this.set(provider.uid, provider);
-    },
-
-    registerMany(providers) {
-      providers.forEach((provider) => {
-        this.register(provider);
-      });
-    },
-
-    getAll() {
-      return Array.from(this.values());
-    },
-  });
-
-  return registry;
-};

package/ee/server/services/passport/sso.js

@@ -1,37 +0,0 @@
-'use strict';
-
-const ee = require('@strapi/strapi/dist/utils/ee');
-const { authEventsMapper } = require('../../../../server/services/passport');
-const createProviderRegistry = require('./provider-registry');
-
-const providerRegistry = createProviderRegistry();
-const errorMessage = 'SSO is disabled. Its functionnalities cannot be accessed.';
-
-const getStrategyCallbackURL = (providerName) => {
-  if (!ee.features.isEnabled('sso')) {
-    throw new Error(errorMessage);
-  }
-
-  return `/admin/connect/${providerName}`;
-};
-
-const syncProviderRegistryWithConfig = () => {
-  if (!ee.features.isEnabled('sso')) {
-    throw new Error(errorMessage);
-  }
-
-  const { providers = [] } = strapi.config.get('admin.auth', {});
-
-  providerRegistry.registerMany(providers);
-};
-
-const SSOAuthEventsMapper = {
-  onSSOAutoRegistration: 'admin.auth.autoRegistration',
-};
-
-module.exports = {
-  providerRegistry,
-  getStrategyCallbackURL,
-  syncProviderRegistryWithConfig,
-  authEventsMapper: { ...authEventsMapper, ...SSOAuthEventsMapper },
-};

package/ee/server/services/passport.js

@@ -1,46 +0,0 @@
-'use strict';
-
-// eslint-disable-next-line node/no-extraneous-require
-const { features } = require('@strapi/strapi/dist/utils/ee');
-
-const { UnauthorizedError } = require('@strapi/utils').errors;
-const createLocalStrategy = require('../../../server/services/passport/local-strategy');
-const sso = require('./passport/sso');
-const { isSsoLocked } = require('../utils/sso-lock');
-
-const localStrategyMiddleware = async ([error, user, message], done) => {
-  // if we got a user, we need to check that it's not sso locked
-  if (user && !error && (await isSsoLocked(user))) {
-    return done(
-      new UnauthorizedError('Login not allowed, please contact your administrator', {
-        code: 'LOGIN_NOT_ALLOWED',
-      }),
-      user,
-      message
-    );
-  }
-
-  return done(error, user, message);
-};
-
-const getPassportStrategies = () => {
-  if (!features.isEnabled('sso')) {
-    return [createLocalStrategy(strapi)];
-  }
-
-  const localStrategy = createLocalStrategy(strapi, localStrategyMiddleware);
-
-  if (!strapi.isLoaded) {
-    sso.syncProviderRegistryWithConfig();
-  }
-
-  const providers = sso.providerRegistry.getAll();
-  const strategies = providers.map((provider) => provider.createStrategy(strapi));
-
-  return [localStrategy, ...strategies];
-};
-
-module.exports = {
-  getPassportStrategies,
-  ...sso,
-};

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