@strapi/admin 4.16.2 → 4.17.1

package/server/utils/index.d.ts

@@ -1,25 +0,0 @@
-import * as role from '../services/role';
-import * as user from '../services/user';
-import * as permission from '../services/permission';
-import * as contentType from '../services/content-type';
-import * as metrics from '../services/metrics';
-import * as token from '../services/token';
-import * as auth from '../services/auth';
-import * as apiToken from '../services/api-token';
-import * as projectSettings from '../services/project-settings';
-import * as transfer from '../services/transfer';
-
-type S = {
-  role: typeof role;
-  user: typeof user;
-  permission: typeof permission;
-  'content-type': typeof contentType;
-  token: typeof token;
-  auth: typeof auth;
-  metrics: typeof metrics;
-  'api-token': typeof apiToken;
-  'project-settings': typeof projectSettings;
-  transfer: typeof transfer;
-};
-
-export function getService<T extends keyof S>(name: T): S[T];

package/server/utils/index.js

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

package/server/validation/__tests__/common-functions.test.js

@@ -1,54 +0,0 @@
-'use strict';
-
-const {
-  checkFieldsAreCorrectlyNested,
-  checkFieldsDontHaveDuplicates,
-} = require('../common-functions');
-
-describe('Common validation functions', () => {
-  describe('checkFieldsAreCorrectlyNested', () => {
-    const tests = [
-      [['name'], true],
-      [['name', 'description'], true],
-      [['name.firstname'], true],
-      [['name.firstname', 'name.lastname'], true],
-      [['name.firstname.french'], true],
-      [['name.firstname.french', 'firstname'], true],
-      [['name.firstname.french', 'french'], true],
-      [['name.firstname.french', 'firstname.french'], true],
-      [['name', 'name.firstname'], false],
-      [['name', 'name.firstname.french'], false],
-      [['name.firstname', 'name.firstname.french'], false],
-      [['address', 'addresses'], true],
-      [[], true],
-      [undefined, true],
-      [null, true],
-      ['', false],
-      [3, false],
-    ];
-
-    test.each(tests)('%p to be %p', (fields, expectedResult) => {
-      const result = checkFieldsAreCorrectlyNested(fields);
-      expect(result).toBe(expectedResult);
-    });
-  });
-
-  describe('checkFieldsDontHaveDuplicates', () => {
-    const tests = [
-      [['name'], true],
-      [['name', 'description'], true],
-      [['name', 'description', 'name'], false],
-      [['name.firstname', 'name.lastname'], true],
-      [[], true],
-      [undefined, true],
-      [null, true],
-      ['', false],
-      [3, false],
-    ];
-
-    test.each(tests)('%p to be %p', (fields, expectedResult) => {
-      const result = checkFieldsDontHaveDuplicates(fields);
-      expect(result).toBe(expectedResult);
-    });
-  });
-});

package/server/validation/action-provider.js

@@ -1,67 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchemaSync } = require('@strapi/utils');
-const validators = require('./common-validators');
-
-const registerProviderActionSchema = yup
-  .array()
-  .required()
-  .of(
-    yup
-      .object()
-      .shape({
-        uid: yup
-          .string()
-          .matches(
-            /^[a-z]([a-z|.|-]+)[a-z]$/,
-            (v) => `${v.path}: The id can only contain lowercase letters, dots and hyphens.`
-          )
-          .required(),
-        section: yup.string().oneOf(['contentTypes', 'plugins', 'settings', 'internal']).required(),
-        pluginName: yup.mixed().when('section', {
-          is: 'plugins',
-          then: validators.isAPluginName.required(),
-          otherwise: validators.isAPluginName,
-        }),
-        subjects: yup.mixed().when('section', {
-          is: 'contentTypes',
-          then: yup.array().of(yup.string()).required(),
-          otherwise: yup
-            .mixed()
-            .oneOf([undefined], 'subjects should only be defined for the "contentTypes" section'),
-        }),
-        displayName: yup.string().required(),
-        category: yup.mixed().when('section', {
-          is: 'settings',
-          then: yup.string().required(),
-          otherwise: yup
-            .mixed()
-            .test(
-              'settingsCategory',
-              'category should only be defined for the "settings" section',
-              (cat) => cat === undefined
-            ),
-        }),
-        subCategory: yup.mixed().when('section', {
-          is: (section) => ['settings', 'plugins'].includes(section),
-          then: yup.string(),
-          otherwise: yup
-            .mixed()
-            .test(
-              'settingsSubCategory',
-              'subCategory should only be defined for "plugins" and "settings" sections',
-              (subCat) => {
-                return subCat === undefined;
-              }
-            ),
-        }),
-        options: yup.object({
-          applyToProperties: yup.array().of(yup.string()),
-        }),
-      })
-      .noUnknown()
-  );
-
-module.exports = {
-  validateRegisterProviderAction: validateYupSchemaSync(registerProviderActionSchema),
-};

package/server/validation/api-tokens.js

@@ -1,32 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-const constants = require('../services/constants');
-
-const apiTokenCreationSchema = yup
-  .object()
-  .shape({
-    name: yup.string().min(1).required(),
-    description: yup.string().optional(),
-    type: yup.string().oneOf(Object.values(constants.API_TOKEN_TYPE)).required(),
-    permissions: yup.array().of(yup.string()).nullable(),
-    lifespan: yup.number().min(1).oneOf(Object.values(constants.API_TOKEN_LIFESPANS)).nullable(),
-  })
-  .noUnknown()
-  .strict();
-
-const apiTokenUpdateSchema = yup
-  .object()
-  .shape({
-    name: yup.string().min(1).notNull(),
-    description: yup.string().nullable(),
-    type: yup.string().oneOf(Object.values(constants.API_TOKEN_TYPE)).notNull(),
-    permissions: yup.array().of(yup.string()).nullable(),
-  })
-  .noUnknown()
-  .strict();
-
-module.exports = {
-  validateApiTokenCreationInput: validateYupSchema(apiTokenCreationSchema),
-  validateApiTokenUpdateInput: validateYupSchema(apiTokenUpdateSchema),
-};

package/server/validation/authentication/forgot-password.js

@@ -1,14 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-const validators = require('../common-validators');
-
-const forgotPasswordSchema = yup
-  .object()
-  .shape({
-    email: validators.email.required(),
-  })
-  .required()
-  .noUnknown();
-
-module.exports = validateYupSchema(forgotPasswordSchema);

package/server/validation/authentication/index.js

@@ -1,19 +0,0 @@
-'use strict';
-
-const {
-  validateRegistrationInput,
-  validateAdminRegistrationInput,
-  validateRegistrationInfoQuery,
-} = require('./register');
-const validateForgotPasswordInput = require('./forgot-password');
-const validateResetPasswordInput = require('./reset-password');
-const validateRenewTokenInput = require('./renew-token');
-
-module.exports = {
-  validateRegistrationInput,
-  validateAdminRegistrationInput,
-  validateRegistrationInfoQuery,
-  validateForgotPasswordInput,
-  validateResetPasswordInput,
-  validateRenewTokenInput,
-};

package/server/validation/authentication/register.js

@@ -1,45 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-const validators = require('../common-validators');
-
-const registrationSchema = yup
-  .object()
-  .shape({
-    registrationToken: yup.string().required(),
-    userInfo: yup
-      .object()
-      .shape({
-        firstname: validators.firstname.required(),
-        lastname: validators.lastname.nullable(),
-        password: validators.password.required(),
-      })
-      .required()
-      .noUnknown(),
-  })
-  .noUnknown();
-
-const registrationInfoQuerySchema = yup
-  .object()
-  .shape({
-    registrationToken: yup.string().required(),
-  })
-  .required()
-  .noUnknown();
-
-const adminRegistrationSchema = yup
-  .object()
-  .shape({
-    email: validators.email.required(),
-    firstname: validators.firstname.required(),
-    lastname: validators.lastname.nullable(),
-    password: validators.password.required(),
-  })
-  .required()
-  .noUnknown();
-
-module.exports = {
-  validateRegistrationInput: validateYupSchema(registrationSchema),
-  validateRegistrationInfoQuery: validateYupSchema(registrationInfoQuerySchema),
-  validateAdminRegistrationInput: validateYupSchema(adminRegistrationSchema),
-};

package/server/validation/authentication/renew-token.js

@@ -1,7 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-
-const renewToken = yup.object().shape({ token: yup.string().required() }).required().noUnknown();
-
-module.exports = validateYupSchema(renewToken);

package/server/validation/authentication/reset-password.js

@@ -1,15 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-const validators = require('../common-validators');
-
-const resetPasswordSchema = yup
-  .object()
-  .shape({
-    resetPasswordToken: yup.string().required(),
-    password: validators.password.required(),
-  })
-  .required()
-  .noUnknown();
-
-module.exports = validateYupSchema(resetPasswordSchema);

package/server/validation/common-functions/check-fields-are-correctly-nested.js

@@ -1,28 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-const checkFieldsAreCorrectlyNested = (fields) => {
-  if (_.isNil(fields)) {
-    // Only check if the fields exist
-    return true;
-  }
-  if (!Array.isArray(fields)) {
-    return false;
-  }
-
-  let failed = false;
-  for (let indexA = 0; indexA < fields.length; indexA += 1) {
-    failed = fields
-      .slice(indexA + 1)
-      .some(
-        (fieldB) =>
-          fieldB.startsWith(`${fields[indexA]}.`) || fields[indexA].startsWith(`${fieldB}.`)
-      );
-    if (failed) break;
-  }
-
-  return !failed;
-};
-
-module.exports = checkFieldsAreCorrectlyNested;

package/server/validation/common-functions/check-fields-dont-have-duplicates.js

@@ -1,17 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-
-const checkFieldsDontHaveDuplicates = (fields) => {
-  if (_.isNil(fields)) {
-    // Only check if the fields exist
-    return true;
-  }
-  if (!Array.isArray(fields)) {
-    return false;
-  }
-
-  return _.uniq(fields).length === fields.length;
-};
-
-module.exports = checkFieldsDontHaveDuplicates;

package/server/validation/common-functions/index.js

@@ -1,9 +0,0 @@
-'use strict';
-
-const checkFieldsAreCorrectlyNested = require('./check-fields-are-correctly-nested');
-const checkFieldsDontHaveDuplicates = require('./check-fields-dont-have-duplicates');
-
-module.exports = {
-  checkFieldsAreCorrectlyNested,
-  checkFieldsDontHaveDuplicates,
-};

package/server/validation/common-validators.js

@@ -1,209 +0,0 @@
-'use strict';
-
-const { yup } = require('@strapi/utils');
-const _ = require('lodash');
-const { isEmpty, has, isNil, isArray } = require('lodash/fp');
-const { getService } = require('../utils');
-const actionDomain = require('../domain/action');
-const {
-  checkFieldsAreCorrectlyNested,
-  checkFieldsDontHaveDuplicates,
-} = require('./common-functions');
-
-const getActionFromProvider = (actionId) => {
-  return getService('permission').actionProvider.get(actionId);
-};
-
-const email = yup.string().email().lowercase();
-
-const firstname = yup.string().trim().min(1);
-
-const lastname = yup.string();
-
-const username = yup.string().min(1);
-
-const password = yup
-  .string()
-  .min(8)
-  .matches(/[a-z]/, '${path} must contain at least one lowercase character')
-  .matches(/[A-Z]/, '${path} must contain at least one uppercase character')
-  .matches(/\d/, '${path} must contain at least one number');
-
-const roles = yup.array(yup.strapiID()).min(1);
-
-const isAPluginName = yup
-  .string()
-  .test('is-a-plugin-name', 'is not a plugin name', function (value) {
-    return [undefined, 'admin', ...Object.keys(strapi.plugins)].includes(value)
-      ? true
-      : this.createError({ path: this.path, message: `${this.path} is not an existing plugin` });
-  });
-
-const arrayOfConditionNames = yup
-  .array()
-  .of(yup.string())
-  .test('is-an-array-of-conditions', 'is not a plugin name', function (value) {
-    const ids = strapi.admin.services.permission.conditionProvider.keys();
-    return _.isUndefined(value) || _.difference(value, ids).length === 0
-      ? true
-      : this.createError({ path: this.path, message: `contains conditions that don't exist` });
-  });
-
-const permissionsAreEquals = (a, b) =>
-  a.action === b.action && (a.subject === b.subject || (_.isNil(a.subject) && _.isNil(b.subject)));
-
-const checkNoDuplicatedPermissions = (permissions) =>
-  !Array.isArray(permissions) ||
-  permissions.every((permA, i) =>
-    permissions.slice(i + 1).every((permB) => !permissionsAreEquals(permA, permB))
-  );
-
-const checkNilFields = (action) =>
-  function (fields) {
-    // If the parent has no action field, then we ignore this test
-    if (isNil(action)) {
-      return true;
-    }
-
-    return actionDomain.appliesToProperty('fields', action) || isNil(fields);
-  };
-
-const fieldsPropertyValidation = (action) =>
-  yup
-    .array()
-    .of(yup.string())
-    .nullable()
-    .test(
-      'field-nested',
-      'Fields format are incorrect (bad nesting).',
-      checkFieldsAreCorrectlyNested
-    )
-    .test(
-      'field-nested',
-      'Fields format are incorrect (duplicates).',
-      checkFieldsDontHaveDuplicates
-    )
-    .test(
-      'fields-restriction',
-      'The permission at ${path} must have fields set to null or undefined',
-      checkNilFields(action)
-    );
-
-const permission = yup
-  .object()
-  .shape({
-    action: yup
-      .string()
-      .required()
-      .test('action-validity', 'action is not an existing permission action', function (actionId) {
-        // If the action field is Nil, ignore the test and let the required check handle the error
-        if (isNil(actionId)) {
-          return true;
-        }
-
-        return !!getActionFromProvider(actionId);
-      }),
-    actionParameters: yup.object().nullable(),
-    subject: yup
-      .string()
-      .nullable()
-      .test('subject-validity', 'Invalid subject submitted', function (subject) {
-        const action = getActionFromProvider(this.options.parent.action);
-
-        if (!action) {
-          return true;
-        }
-
-        if (isNil(action.subjects)) {
-          return isNil(subject);
-        }
-
-        if (isArray(action.subjects)) {
-          return action.subjects.includes(subject);
-        }
-
-        return false;
-      }),
-    properties: yup
-      .object()
-      .test('properties-structure', 'Invalid property set at ${path}', function (properties) {
-        const action = getActionFromProvider(this.options.parent.action);
-        const hasNoProperties = isEmpty(properties) || isNil(properties);
-
-        if (!has('options.applyToProperties', action)) {
-          return hasNoProperties;
-        }
-
-        if (hasNoProperties) {
-          return true;
-        }
-
-        const { applyToProperties } = action.options;
-
-        if (!isArray(applyToProperties)) {
-          return false;
-        }
-
-        return Object.keys(properties).every((property) => applyToProperties.includes(property));
-      })
-      .test(
-        'fields-property',
-        'Invalid fields property at ${path}',
-        async function (properties = {}) {
-          const action = getActionFromProvider(this.options.parent.action);
-
-          if (!action || !properties) {
-            return true;
-          }
-
-          if (!actionDomain.appliesToProperty('fields', action)) {
-            return true;
-          }
-
-          try {
-            await fieldsPropertyValidation(action).validate(properties.fields, {
-              strict: true,
-              abortEarly: false,
-            });
-            return true;
-          } catch (e) {
-            // Propagate fieldsPropertyValidation error with updated path
-            throw this.createError({
-              message: e.message,
-              path: `${this.path}.fields`,
-            });
-          }
-        }
-      ),
-    conditions: yup.array().of(yup.string()),
-  })
-  .noUnknown();
-
-const updatePermissions = yup
-  .object()
-  .shape({
-    permissions: yup
-      .array()
-      .required()
-      .of(permission)
-      .test(
-        'duplicated-permissions',
-        'Some permissions are duplicated (same action and subject)',
-        checkNoDuplicatedPermissions
-      ),
-  })
-  .required()
-  .noUnknown();
-
-module.exports = {
-  email,
-  firstname,
-  lastname,
-  username,
-  password,
-  roles,
-  isAPluginName,
-  arrayOfConditionNames,
-  permission,
-  updatePermissions,
-};

package/server/validation/permission.js

@@ -1,53 +0,0 @@
-'use strict';
-
-const { yup, validateYupSchema } = require('@strapi/utils');
-const { getService } = require('../utils');
-const validators = require('./common-validators');
-
-const checkPermissionsSchema = yup.object().shape({
-  permissions: yup.array().of(
-    yup
-      .object()
-      .shape({
-        action: yup.string().required(),
-        subject: yup.string().nullable(),
-        field: yup.string(),
-      })
-      .noUnknown()
-  ),
-});
-
-const checkPermissionsExist = function (permissions) {
-  const existingActions = getService('permission').actionProvider.values();
-  const failIndex = permissions.findIndex(
-    (permission) =>
-      !existingActions.some(
-        (action) =>
-          action.actionId === permission.action &&
-          (action.section !== 'contentTypes' || action.subjects.includes(permission.subject))
-      )
-  );
-
-  return failIndex === -1
-    ? true
-    : this.createError({
-        path: 'permissions',
-        message: `[${failIndex}] is not an existing permission action`,
-      });
-};
-
-const actionsExistSchema = yup
-  .array()
-  .of(
-    yup.object().shape({
-      conditions: yup.array().of(yup.string()),
-    })
-  )
-  .test('actions-exist', '', checkPermissionsExist);
-
-// exports
-module.exports = {
-  validatedUpdatePermissionsInput: validateYupSchema(validators.updatePermissions),
-  validatePermissionsExist: validateYupSchema(actionsExistSchema),
-  validateCheckPermissionsInput: validateYupSchema(checkPermissionsSchema),
-};

package/server/validation/policies/hasPermissions.js

@@ -1,27 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { yup, validateYupSchema } = require('@strapi/utils');
-
-const hasPermissionsSchema = yup.object({
-  actions: yup.array().of(
-    yup.lazy((val) => {
-      if (_.isArray(val)) {
-        return yup.array().of(yup.string()).min(1).max(2);
-      }
-
-      if (_.isString(val)) {
-        return yup.string().required();
-      }
-
-      return yup.object().shape({
-        action: yup.string().required(),
-        subject: yup.string(),
-      });
-    })
-  ),
-});
-
-module.exports = {
-  validateHasPermissionsInput: validateYupSchema(hasPermissionsSchema),
-};