@akemona-org/strapi-admin 3.7.0

package/validation/common-validators.js

@@ -0,0 +1,217 @@
+'use strict';
+
+const { yup } = require('@akemona-org/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().min(1);
+
+const lastname = yup.string().min(1);
+
+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 updatePermissions = yup
+  .object()
+  .shape({
+    permissions: yup
+      .array()
+      .required()
+      .of(
+        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);
+                }
+              ),
+            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()
+      )
+      .test(
+        'duplicated-permissions',
+        'Some permissions are duplicated (same action and subject)',
+        checkNoDuplicatedPermissions
+      ),
+  })
+  .required()
+  .noUnknown();
+
+module.exports = {
+  email,
+  firstname,
+  lastname,
+  username,
+  password,
+  roles,
+  isAPluginName,
+  arrayOfConditionNames,
+  updatePermissions,
+};

package/validation/permission.js

@@ -0,0 +1,153 @@
+'use strict';
+
+const _ = require('lodash');
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+const { getService } = require('../utils');
+const { AUTHOR_CODE, PUBLISH_ACTION } = require('../services/constants');
+const {
+  BOUND_ACTIONS_FOR_FIELDS,
+  BOUND_ACTIONS,
+  getBoundActionsBySubject,
+} = require('../domain/role');
+const validators = require('./common-validators');
+
+const handleReject = (error) => Promise.reject(formatYupErrors(error));
+
+// validatedUpdatePermissionsInput
+
+const actionFieldsAreEqual = (a, b) => {
+  const aFields = a.properties.fields || [];
+  const bFields = b.properties.fields || [];
+
+  return _.isEqual(aFields.sort(), bFields.sort());
+};
+
+const haveSameFieldsAsOtherActions = (a, i, allActions) =>
+  allActions.slice(i + 1).every((b) => actionFieldsAreEqual(a, b));
+
+const checkPermissionsAreBound = (role) =>
+  function (permissions) {
+    const permsBySubject = _.groupBy(
+      permissions.filter((perm) => BOUND_ACTIONS.includes(perm.action)),
+      'subject'
+    );
+
+    for (const [subject, perms] of Object.entries(permsBySubject)) {
+      const boundActions = getBoundActionsBySubject(role, subject);
+      const missingActions =
+        _.xor(
+          perms.map((p) => p.action),
+          boundActions
+        ).length !== 0;
+      if (missingActions) return false;
+
+      const permsBoundByFields = perms.filter((p) => BOUND_ACTIONS_FOR_FIELDS.includes(p.action));
+      const everyActionsHaveSameFields = _.every(permsBoundByFields, haveSameFieldsAsOtherActions);
+      if (!everyActionsHaveSameFields) return false;
+    }
+
+    return true;
+  };
+
+const noPublishPermissionForAuthorRole = (role) =>
+  function (permissions) {
+    const isAuthor = role.code === AUTHOR_CODE;
+    const hasPublishPermission = permissions.some((perm) => perm.action === PUBLISH_ACTION);
+
+    return !(isAuthor && hasPublishPermission);
+  };
+
+const getUpdatePermissionsSchemas = (role) => [
+  validators.updatePermissions,
+  yup.object().shape({ permissions: actionsExistSchema.clone() }),
+  yup.object().shape({
+    permissions: yup
+      .array()
+      .test(
+        'author-no-publish',
+        'The author role cannot have the publish permission.',
+        noPublishPermissionForAuthorRole(role)
+      ),
+  }),
+  yup.object().shape({
+    permissions: yup
+      .array()
+      .test(
+        'are-bond',
+        'Permissions have to be defined all together for a subject field or not at all',
+        checkPermissionsAreBound(role)
+      ),
+  }),
+];
+
+const checkPermissionsSchema = yup.object().shape({
+  permissions: yup.array().of(
+    yup
+      .object()
+      .shape({
+        action: yup.string().required(),
+        subject: yup.string(),
+        field: yup.string(),
+      })
+      .noUnknown()
+  ),
+});
+
+const validateCheckPermissionsInput = (data) => {
+  return checkPermissionsSchema
+    .validate(data, { strict: true, abortEarly: false })
+    .catch(handleReject);
+};
+
+const validatedUpdatePermissionsInput = async (permissions, role) => {
+  try {
+    const schemas = getUpdatePermissionsSchemas(role);
+    for (const schema of schemas) {
+      await schema.validate(permissions, { strict: true, abortEarly: false });
+    }
+  } catch (e) {
+    return handleReject(e);
+  }
+};
+
+// validatePermissionsExist
+
+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);
+
+const validatePermissionsExist = (data) => {
+  return actionsExistSchema.validate(data, { strict: true, abortEarly: false }).catch(handleReject);
+};
+
+// exports
+
+module.exports = {
+  validatedUpdatePermissionsInput,
+  validatePermissionsExist,
+  validateCheckPermissionsInput,
+};

package/validation/policies/hasPermissions.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const _ = require('lodash');
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const hasPermissionsSchema = 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();
+    }
+
+    return yup.object().shape({
+      action: yup.string().required(),
+      subject: yup.string(),
+    });
+  })
+);
+
+const validateHasPermissionsInput = (data) => {
+  try {
+    return hasPermissionsSchema.validateSync(data, { strict: true, abortEarly: true });
+  } catch (e) {
+    throw new Error(formatYupErrors(e));
+  }
+};
+
+module.exports = {
+  validateHasPermissionsInput,
+};

package/validation/role.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+
+const handleReject = (error) => Promise.reject(formatYupErrors(error));
+
+const roleUpdateSchema = yup
+  .object()
+  .shape({
+    name: yup.string().min(1),
+    description: yup.string().nullable(),
+  })
+  .noUnknown();
+
+const validateRoleUpdateInput = (data) => {
+  return roleUpdateSchema.validate(data, { strict: true, abortEarly: false }).catch(handleReject);
+};
+
+module.exports = {
+  validateRoleUpdateInput,
+};

package/validation/user.js

@@ -0,0 +1,85 @@
+'use strict';
+
+const { isUndefined } = require('lodash/fp');
+const { yup, formatYupErrors } = require('@akemona-org/strapi-utils');
+const validators = require('./common-validators');
+
+const handleReject = (error) => Promise.reject(formatYupErrors(error));
+
+const userCreationSchema = yup
+  .object()
+  .shape({
+    email: validators.email.required(),
+    firstname: validators.firstname.required(),
+    lastname: validators.lastname.required(),
+    roles: validators.roles.min(1),
+    preferedLanguage: yup.string().nullable(),
+  })
+  .noUnknown();
+
+const validateUserCreationInput = (data) => {
+  return userCreationSchema.validate(data, { strict: true, abortEarly: false }).catch(handleReject);
+};
+
+const profileUpdateSchema = yup
+  .object()
+  .shape({
+    email: validators.email.notNull(),
+    firstname: validators.firstname.notNull(),
+    lastname: validators.lastname.notNull(),
+    username: validators.username.nullable(),
+    password: validators.password.notNull(),
+    currentPassword: yup
+      .string()
+      .when('password', (password, schema) => (!isUndefined(password) ? schema.required() : schema))
+      .notNull(),
+    preferedLanguage: yup.string().nullable(),
+  })
+  .noUnknown();
+
+const validateProfileUpdateInput = (data) => {
+  return profileUpdateSchema
+    .validate(data, { strict: true, abortEarly: false })
+    .catch(handleReject);
+};
+
+const userUpdateSchema = yup
+  .object()
+  .shape({
+    email: validators.email.notNull(),
+    firstname: validators.firstname.notNull(),
+    lastname: validators.lastname.notNull(),
+    username: validators.username.nullable(),
+    password: validators.password.notNull(),
+    isActive: yup.bool().notNull(),
+    roles: validators.roles.min(1).notNull(),
+  })
+  .noUnknown();
+
+const validateUserUpdateInput = (data) => {
+  return userUpdateSchema.validate(data, { strict: true, abortEarly: false }).catch(handleReject);
+};
+
+const usersDeleteSchema = yup
+  .object()
+  .shape({
+    ids: yup.array().of(yup.strapiID()).min(1).required(),
+  })
+  .noUnknown();
+
+const validateUsersDeleteInput = async (data) => {
+  return usersDeleteSchema.validate(data, { strict: true, abortEarly: false }).catch(handleReject);
+};
+
+module.exports = {
+  validateUserCreationInput,
+  validateProfileUpdateInput,
+  validateUserUpdateInput,
+  validateUsersDeleteInput,
+
+  schemas: {
+    userCreationSchema,
+    usersDeleteSchema,
+    userUpdateSchema,
+  },
+};

package/webpack.alias.js

@@ -0,0 +1,64 @@
+'use strict';
+
+const path = require('path');
+
+const alias = [
+  'object-assign',
+  'whatwg-fetch',
+  '@babel/polyfill',
+  '@fortawesome/fontawesome-svg-core',
+  '@fortawesome/free-solid-svg-icons',
+  '@buffetjs/core',
+  '@buffetjs/custom',
+  '@buffetjs/custom',
+  '@buffetjs/utils',
+  '@buffetjs/icons',
+  '@buffetjs/hooks',
+  'classnames',
+  'history',
+  'hoist-non-react-statics',
+  'immer',
+  'immutable',
+  'invariant',
+  'moment',
+  'qs',
+  'react',
+  'react-copy-to-clipboard',
+  'react-dnd',
+  'react-dnd-html5-backend',
+  'react-dom',
+  'react-error-boundary',
+  'react-fast-compare',
+  'react-helmet',
+  'react-is',
+  'react-intl',
+  'react-loadable',
+  'react-redux',
+  'react-router',
+  'react-router-dom',
+  'react-transition-group',
+  'react-tooltip',
+  'react-virtualized',
+  'reactstrap',
+  'react-select',
+  'redux',
+  'redux-immutable',
+  'reselect',
+  'styled-components',
+  'yup',
+];
+
+module.exports = alias.reduce(
+  (acc, curr) => {
+    acc[`${curr}$`] = require.resolve(curr);
+    return acc;
+  },
+  {
+    'react-select/animated': require.resolve('react-select/animated'),
+    'react-select/async': require.resolve('react-select/async'),
+    'react-select/async-creatable': require.resolve('react-select/async-creatable'),
+    'react-select/base': require.resolve('react-select/base'),
+    'react-select/creatable': require.resolve('react-select/creatable'),
+    ee_else_ce: path.resolve(__dirname),
+  }
+);