@strapi/admin 4.16.2 → 4.17.0

package/ee/server/utils/__tests__/sso-lock.test.js

@@ -1,84 +0,0 @@
-'use strict';
-
-const { isSsoLocked } = require('../sso-lock');
-
-// allow toggling the feature within tests
-let ssoEnabled = true;
-
-jest.mock('@strapi/strapi/dist/utils/ee', () => {
-  return {
-    features: {
-      isEnabled() {
-        return ssoEnabled;
-      },
-    },
-  };
-});
-
-describe('isSsoLocked', () => {
-  const lockedRoles = ['1', '2'];
-
-  const userWithLoadedLockedRoles = {
-    id: 1,
-    email: 'test@example.com',
-    password: '123',
-  };
-  const userWithLockedRoles = {
-    id: 1,
-    email: 'test@example.com',
-    password: '123',
-    roles: [{ id: 1 }, { id: 3 }],
-  };
-  const userWithUnlockedRoles = {
-    id: 1,
-    email: 'test@example.com',
-    password: '123',
-    roles: [{ id: 3 }, { id: 4 }],
-  };
-
-  global.strapi = {
-    query: jest.fn(() => {
-      return {
-        load: jest.fn(async () => {
-          return [{ id: 2 }];
-        }),
-      };
-    }),
-    store: jest.fn(() => {
-      return {
-        get: jest.fn(() => {
-          return {
-            providers: {
-              ssoLockedRoles: lockedRoles,
-            },
-          };
-        }),
-      };
-    }),
-  };
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('returns true for user with a locked role', async () => {
-    ssoEnabled = true;
-    expect(await isSsoLocked(userWithLockedRoles)).toBe(true);
-  });
-
-  it('returns false for user without a locked role', async () => {
-    ssoEnabled = true;
-    expect(await isSsoLocked(userWithUnlockedRoles)).toBe(false);
-  });
-
-  it('returns false for user with a locked role when SSO is not enabled', async () => {
-    ssoEnabled = false;
-    expect(await isSsoLocked(userWithLockedRoles)).toBe(false);
-  });
-
-  it('queries for roles when user object does not have it populated', async () => {
-    ssoEnabled = true;
-    expect(await isSsoLocked(userWithLoadedLockedRoles)).toBe(true);
-    expect(global.strapi.query).toHaveBeenCalledTimes(1);
-  });
-});

package/ee/server/utils/index.js

@@ -1,8 +0,0 @@
-'use strict';
-
-const getService = (name, { strapi } = { strapi: global.strapi }) => {
-  return strapi.service(`admin::${name}`);
-};
-module.exports = {
-  getService,
-};

package/ee/server/utils/persisted-tables.js

@@ -1,139 +0,0 @@
-'use strict';
-
-const { differenceWith, isEqual } = require('lodash/fp');
-
-/**
- * Transform table name to the object format
- * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }>} table
- * @returns Array<{ table: string; dependsOn?: Array<{ table: string;}> }>
- */
-const transformTableName = (table) => {
-  if (typeof table === 'string') {
-    return { name: table };
-  }
-  return table;
-};
-
-/**
- * Finds all tables in the database matching the regular expression
- * @param {Object} ctx
- * @param {Strapi} ctx.strapi
- * @param {RegExp} regex
- * @returns {Promise<string[]>}
- */
-async function findTables({ strapi }, regex) {
-  const tables = await strapi.db.dialect.schemaInspector.getTables();
-  return tables.filter((tableName) => regex.test(tableName));
-}
-
-/**
- * Add tables name to the reserved tables in core store
- * @param {Object} ctx
- * @param {Strapi} ctx.strapi
- * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }>} tableNames
- * @return {Promise<void>}
- */
-async function addPersistTables({ strapi }, tableNames) {
-  const persistedTables = await getPersistedTables({ strapi });
-  const tables = tableNames.map(transformTableName);
-
-  // Get new tables to be persisted, remove tables if they already were persisted
-  const notPersistedTableNames = differenceWith(isEqual, tables, persistedTables);
-  // Remove tables that are going to be changed
-  const tablesToPersist = differenceWith(
-    (t1, t2) => t1.name === t2.name,
-    persistedTables,
-    notPersistedTableNames
-  );
-
-  if (!notPersistedTableNames.length) {
-    return;
-  }
-
-  tablesToPersist.push(...notPersistedTableNames);
-  await strapi.store.set({
-    type: 'core',
-    key: 'persisted_tables',
-    value: tablesToPersist,
-  });
-}
-
-/**
- * Get all reserved table names from the core store
- * @param {Object} ctx
- * @param {Strapi} ctx.strapi
- * @param {RegExp} regex
- * @returns {Promise<string[]>}
- */
-
-async function getPersistedTables({ strapi }) {
-  const persistedTables = await strapi.store.get({
-    type: 'core',
-    key: 'persisted_tables',
-  });
-
-  return (persistedTables || []).map(transformTableName);
-}
-
-/**
- * Set all reserved table names in the core store
- * @param {Object} ctx
- * @param {Strapi} ctx.strapi
- * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }>} tableNames
- * @returns {Promise<void>}
- */
-async function setPersistedTables({ strapi }, tableNames) {
-  await strapi.store.set({
-    type: 'core',
-    key: 'persisted_tables',
-    value: tableNames,
-  });
-}
-/**
- * Add all table names that start with a prefix to the reserved tables in
- * core store
- * @param {string} tableNamePrefix
- * @return {Promise<void>}
- */
-
-const persistTablesWithPrefix = async (tableNamePrefix) => {
-  const tableNameRegex = new RegExp(`^${tableNamePrefix}.*`);
-  const tableNames = await findTables({ strapi }, tableNameRegex);
-
-  await addPersistTables({ strapi }, tableNames);
-};
-
-/**
- * Remove all table names that end with a suffix from the reserved tables in core store
- * @param {string} tableNameSuffix
- * @return {Promise<void>}
- */
-const removePersistedTablesWithSuffix = async (tableNameSuffix) => {
-  const tableNameRegex = new RegExp(`.*${tableNameSuffix}$`);
-  const persistedTables = await getPersistedTables({ strapi });
-
-  const filteredPersistedTables = persistedTables.filter((table) => {
-    return !tableNameRegex.test(table.name);
-  });
-
-  if (filteredPersistedTables.length === persistedTables.length) {
-    return;
-  }
-
-  await setPersistedTables({ strapi }, filteredPersistedTables);
-};
-
-/**
- * Add tables to the reserved tables in core store
- * @param {Array<string|{ table: string; dependsOn?: Array<{ table: string;}> }} tables
- */
-const persistTables = async (tables) => {
-  await addPersistTables({ strapi }, tables);
-};
-
-module.exports = {
-  persistTablesWithPrefix,
-  removePersistedTablesWithSuffix,
-  persistTables,
-  findTables,
-};

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

@@ -1,39 +0,0 @@
-'use strict';
-
-const { getOr, keys, pickBy, pipe, has, clamp } = require('lodash/fp');
-const {
-  ENTITY_STAGE_ATTRIBUTE,
-  MAX_WORKFLOWS,
-  MAX_STAGES_PER_WORKFLOW,
-} = require('../constants/workflows');
-
-const getVisibleContentTypesUID = pipe([
-  // Pick only content-types visible in the content-manager and option is not false
-  pickBy(
-    (value) =>
-      getOr(true, 'pluginOptions.content-manager.visible', value) &&
-      !getOr(false, 'options.noStageAttribute', value)
-  ),
-  // Get UIDs
-  keys,
-]);
-
-const hasStageAttribute = has(['attributes', ENTITY_STAGE_ATTRIBUTE]);
-
-const getWorkflowContentTypeFilter = ({ strapi }, contentType) => {
-  if (strapi.db.dialect.supportsOperator('$jsonSupersetOf')) {
-    return { $jsonSupersetOf: JSON.stringify([contentType]) };
-  }
-  return { $contains: `"${contentType}"` };
-};
-
-const clampMaxWorkflows = clamp(1, MAX_WORKFLOWS);
-const clampMaxStagesPerWorkflow = clamp(1, MAX_STAGES_PER_WORKFLOW);
-
-module.exports = {
-  clampMaxWorkflows,
-  clampMaxStagesPerWorkflow,
-  getVisibleContentTypesUID,
-  hasStageAttribute,
-  getWorkflowContentTypeFilter,
-};

package/ee/server/utils/sso-lock.js

@@ -1,42 +0,0 @@
-'use strict';
-
-const { features } = require('@strapi/strapi/dist/utils/ee');
-const { isEmpty } = require('lodash/fp');
-
-const isSsoLocked = async (user) => {
-  if (!features.isEnabled('sso')) {
-    return false;
-  }
-
-  if (!user) {
-    throw new Error('Missing user object');
-  }
-
-  // check if any roles are locked
-  const adminStore = await strapi.store({ type: 'core', name: 'admin' });
-  const { providers } = await adminStore.get({ key: 'auth' });
-  const lockedRoles = providers.ssoLockedRoles ?? [];
-  if (isEmpty(lockedRoles)) {
-    return false;
-  }
-
-  const roles =
-    // If the roles are pre-loaded for the given user, then use them
-    user.roles ??
-    // Otherwise, try to load the role based on the given user ID
-    (await strapi.query('admin::user').load(user, 'roles', { roles: { fields: ['id'] } })) ??
-    // If the query fails somehow, default to an empty array
-    [];
-
-  // Check if any of the user's roles are in lockedRoles
-  const isLocked = lockedRoles.some((lockedId) =>
-    // lockedRoles will be a string to avoid issues with frontend and bigints
-    roles.some((role) => lockedId === role.id.toString())
-  );
-
-  return isLocked;
-};
-
-module.exports = {
-  isSsoLocked,
-};

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

@@ -1,18 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-
-const ALLOWED_SORT_STRINGS = ['action:ASC', 'action:DESC', 'date:ASC', 'date:DESC'];
-
-const validateFindManySchema = yup
-  .object()
-  .shape({
-    page: yup.number().integer().min(1),
-    pageSize: yup.number().integer().min(1).max(100),
-    sort: yup.mixed().oneOf(ALLOWED_SORT_STRINGS),
-  })
-  .required();
-
-module.exports = {
-  validateFindMany: validateYupSchema(validateFindManySchema, { strict: false }),
-};

package/ee/server/validation/authentication.js

@@ -1,36 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-
-const providerOptionsUpdateSchema = yup.object().shape({
-  autoRegister: yup.boolean().required(),
-  defaultRole: yup
-    .strapiID()
-    .when('autoRegister', (value, initSchema) => {
-      return value ? initSchema.required() : initSchema.nullable();
-    })
-    .test('is-valid-role', 'You must submit a valid default role', (roleId) => {
-      if (roleId === null) {
-        return true;
-      }
-      return strapi.admin.services.role.exists({ id: roleId });
-    }),
-  ssoLockedRoles: yup
-    .array()
-    .nullable()
-    .of(
-      yup
-        .strapiID()
-        .test(
-          'is-valid-role',
-          'You must submit a valid role for the SSO Locked roles',
-          (roleId) => {
-            return strapi.admin.services.role.exists({ id: roleId });
-          }
-        )
-    ),
-});
-
-module.exports = {
-  validateProviderOptionsUpdate: validateYupSchema(providerOptionsUpdateSchema),
-};

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

@@ -1,92 +0,0 @@
-'use strict';
-
-/* eslint-disable func-names */
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-const { hasStageAttribute } = require('../utils/review-workflows');
-const { STAGE_TRANSITION_UID } = require('../constants/workflows');
-
-const stageObject = yup.object().shape({
-  id: yup.number().integer().min(1),
-  name: yup.string().max(255).required(),
-  color: yup.string().matches(/^#(?:[0-9a-fA-F]{3}){1,2}$/i), // hex color
-  permissions: yup.array().of(
-    yup.object().shape({
-      role: yup.number().integer().min(1).required(),
-      action: yup.string().oneOf([STAGE_TRANSITION_UID]).required(),
-      actionParameters: yup.object().shape({
-        from: yup.number().integer().min(1).required(),
-        to: yup.number().integer().min(1),
-      }),
-    })
-  ),
-});
-
-const validateUpdateStageOnEntity = yup
-  .object()
-  .shape({
-    id: yup.number().integer().min(1).required(),
-  })
-  .required();
-
-const validateContentTypes = yup.array().of(
-  yup
-    .string()
-    .test({
-      name: 'content-type-exists',
-      message: (value) => `Content type ${value.originalValue} does not exist`,
-      test(uid) {
-        // Warning; we use the strapi global - to avoid that, it would need to refactor how
-        // we generate validation function by using a factory with the strapi instance as parameter.
-        return strapi.getModel(uid);
-      },
-    })
-    .test({
-      name: 'content-type-review-workflow-enabled',
-      message: (value) =>
-        `Content type ${value.originalValue} does not have review workflow enabled`,
-      test(uid) {
-        const model = strapi.getModel(uid);
-
-        // It's not a valid content type if it doesn't have the stage attribute
-        return hasStageAttribute(model);
-      },
-    })
-);
-
-const validateWorkflowCreateSchema = yup.object().shape({
-  name: yup.string().max(255).min(1, 'Workflow name can not be empty').required(),
-  stages: yup
-    .array()
-    .of(stageObject)
-    .uniqueProperty('name', 'Stage name must be unique')
-    .min(1, 'Can not create a workflow without stages')
-    .max(200, 'Can not have more than 200 stages')
-    .required('Can not create a workflow without stages'),
-  contentTypes: validateContentTypes,
-});
-
-const validateWorkflowUpdateSchema = yup.object().shape({
-  name: yup.string().max(255).min(1, 'Workflow name can not be empty'),
-  stages: yup
-    .array()
-    .of(stageObject)
-    .uniqueProperty('name', 'Stage name must be unique')
-    .min(1, 'Can not update a workflow without stages')
-    .max(200, 'Can not have more than 200 stages'),
-  contentTypes: validateContentTypes,
-});
-
-const validateUpdateAssigneeOnEntity = yup
-  .object()
-  .shape({
-    id: yup.number().integer().min(1).nullable(),
-  })
-  .required();
-
-module.exports = {
-  validateWorkflowCreate: validateYupSchema(validateWorkflowCreateSchema),
-  validateUpdateStageOnEntity: validateYupSchema(validateUpdateStageOnEntity),
-  validateUpdateAssigneeOnEntity: validateYupSchema(validateUpdateAssigneeOnEntity),
-  validateWorkflowUpdate: validateYupSchema(validateWorkflowUpdateSchema),
-};

package/ee/server/validation/role.js

@@ -1,68 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-// eslint-disable-next-line node/no-extraneous-require
-const { features } = require('@strapi/strapi/dist/utils/ee');
-
-const roleCreateSchema = yup
-  .object()
-  .shape({
-    name: yup.string().min(1).required(),
-    description: yup.string().nullable(),
-  })
-  .noUnknown();
-
-const rolesDeleteSchema = yup
-  .object()
-  .shape({
-    ids: yup
-      .array()
-      .of(yup.strapiID())
-      .min(1)
-      .required()
-      .test(
-        'roles-deletion-checks',
-        'Roles deletion checks have failed',
-        async function rolesDeletionChecks(ids) {
-          try {
-            await strapi.admin.services.role.checkRolesIdForDeletion(ids);
-
-            if (features.isEnabled('sso')) {
-              await strapi.admin.services.role.ssoCheckRolesIdForDeletion(ids);
-            }
-          } catch (e) {
-            return this.createError({ path: 'ids', message: e.message });
-          }
-
-          return true;
-        }
-      ),
-  })
-  .noUnknown();
-
-const roleDeleteSchema = yup
-  .strapiID()
-  .required()
-  .test(
-    'no-admin-single-delete',
-    'Role deletion checks have failed',
-    async function noAdminSingleDelete(id) {
-      try {
-        await strapi.admin.services.role.checkRolesIdForDeletion([id]);
-
-        if (features.isEnabled('sso')) {
-          await strapi.admin.services.role.ssoCheckRolesIdForDeletion([id]);
-        }
-      } catch (e) {
-        return this.createError({ path: 'id', message: e.message });
-      }
-
-      return true;
-    }
-  );
-
-module.exports = {
-  validateRoleCreateInput: validateYupSchema(roleCreateSchema),
-  validateRolesDeleteInput: validateYupSchema(rolesDeleteSchema),
-  validateRoleDeleteInput: validateYupSchema(roleDeleteSchema),
-};

package/ee/server/validation/user.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-// eslint-disable-next-line node/no-extraneous-require
-const { features } = require('@strapi/strapi/dist/utils/ee');
-const { schemas } = require('../../../server/validation/user');
-
-const ssoUserCreationInputExtension = yup
-  .object()
-  .shape({
-    useSSORegistration: yup.boolean(),
-  })
-  .noUnknown();
-
-const validateUserCreationInput = (data) => {
-  let schema = schemas.userCreationSchema;
-
-  if (features.isEnabled('sso')) {
-    schema = schema.concat(ssoUserCreationInputExtension);
-  }
-
-  return validateYupSchema(schema)(data);
-};
-
-module.exports = {
-  validateUserCreationInput,
-};

package/ee/strapi-server.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('./server');

package/server/bootstrap.js

@@ -1,101 +0,0 @@
-'use strict';
-
-const { merge, map, difference, uniq } = require('lodash/fp');
-const { pipeAsync } = require('@strapi/utils');
-const { getService } = require('./utils');
-const adminActions = require('./config/admin-actions');
-const adminConditions = require('./config/admin-conditions');
-
-const defaultAdminAuthSettings = {
-  providers: {
-    autoRegister: false,
-    defaultRole: null,
-    ssoLockedRoles: null,
-  },
-};
-
-const registerPermissionActions = async () => {
-  await getService('permission').actionProvider.registerMany(adminActions.actions);
-};
-
-const registerAdminConditions = async () => {
-  await getService('permission').conditionProvider.registerMany(adminConditions.conditions);
-};
-
-const registerModelHooks = () => {
-  const { sendDidChangeInterfaceLanguage } = getService('metrics');
-
-  strapi.db.lifecycles.subscribe({
-    models: ['admin::user'],
-    afterCreate: sendDidChangeInterfaceLanguage,
-    afterDelete: sendDidChangeInterfaceLanguage,
-    afterUpdate({ params }) {
-      if (params.data.preferedLanguage) {
-        sendDidChangeInterfaceLanguage();
-      }
-    },
-  });
-};
-
-const syncAuthSettings = async () => {
-  const adminStore = await strapi.store({ type: 'core', name: 'admin' });
-  const adminAuthSettings = await adminStore.get({ key: 'auth' });
-  const newAuthSettings = merge(defaultAdminAuthSettings, adminAuthSettings);
-
-  const roleExists = await getService('role').exists({
-    id: newAuthSettings.providers.defaultRole,
-  });
-
-  // Reset the default SSO role if it has been deleted manually
-  if (!roleExists) {
-    newAuthSettings.providers.defaultRole = null;
-  }
-
-  await adminStore.set({ key: 'auth', value: newAuthSettings });
-};
-
-const syncAPITokensPermissions = async () => {
-  const validPermissions = strapi.contentAPI.permissions.providers.action.keys();
-  const permissionsInDB = await pipeAsync(
-    strapi.query('admin::api-token-permission').findMany,
-    map('action')
-  )();
-
-  const unknownPermissions = uniq(difference(permissionsInDB, validPermissions));
-
-  if (unknownPermissions.length > 0) {
-    await strapi
-      .query('admin::api-token-permission')
-      .deleteMany({ where: { action: { $in: unknownPermissions } } });
-  }
-};
-
-module.exports = async ({ strapi }) => {
-  await registerAdminConditions();
-  await registerPermissionActions();
-  registerModelHooks();
-
-  const permissionService = getService('permission');
-  const userService = getService('user');
-  const roleService = getService('role');
-  const apiTokenService = getService('api-token');
-  const transferService = getService('transfer');
-  const tokenService = getService('token');
-
-  await roleService.createRolesIfNoneExist();
-  await roleService.resetSuperAdminPermissions();
-  await roleService.displayWarningIfNoSuperAdmin();
-
-  await permissionService.cleanPermissionsInDatabase();
-
-  await userService.displayWarningIfUsersDontHaveRole();
-
-  await syncAuthSettings();
-  await syncAPITokensPermissions();
-
-  getService('metrics').startCron(strapi);
-
-  apiTokenService.checkSaltIsDefined();
-  transferService.token.checkSaltIsDefined();
-  tokenService.checkSecretIsDefined();
-};