@punch-in/strapi-admin 3.6.8

package/domain/action/index.js

@@ -0,0 +1,142 @@
+'use strict';
+
+const { curry, pipe, merge, set, pick, omit, includes, isArray, prop } = require('lodash/fp');
+
+/**
+ * Domain representation of an Action (RBAC)
+ * @typedef {Object} Action
+ * @property {string} actionId - The unique identifier of the action
+ * @property {string} section - The section linked to the action
+ * @property {string} displayName - The human readable name of an action
+ * @property {string} category - The main category of an action
+ * @property {string} [subCategory] - The secondary category of an action (only for settings and plugins section)
+ * @property {string} [pluginName] - The plugin which provide the action
+ * @property {string[]} [subjects] - A list of subjects on which the action can be applied
+ * @property {Object} options - The options of an action
+ * @property {string[]} options.applyToProperties - The list of properties that can be associated with an action
+ */
+
+/**
+ * Set of attributes used to create a new {@link Action} object
+ * @typedef {Action, { uid: string }} CreateActionPayload
+ */
+
+/**
+ * Return the default attributes of a new {@link Action}
+ * @return Partial<Action>
+ */
+const getDefaultActionAttributes = () => ({
+  options: {
+    applyToProperties: null,
+  },
+});
+
+/**
+ * Get the list of all the valid attributes of an {@link Action}
+ * @return {string[]}
+ */
+const actionFields = [
+  'section',
+  'displayName',
+  'category',
+  'subCategory',
+  'pluginName',
+  'subjects',
+  'options',
+  'actionId',
+];
+
+/**
+ * Remove unwanted attributes from an {@link Action}
+ * @type {function(action: Action | CreateActionPayload): Action}
+ */
+const sanitizeActionAttributes = pick(actionFields);
+
+/**
+ * Create and return an identifier for an {@link CreateActionPayload}.
+ * The format is based on the action's source ({@link CreateActionPayload.pluginName} or 'application') and {@link CreateActionPayload.uid}.
+ * @param {CreateActionPayload} attributes
+ * @return {string}
+ */
+const computeActionId = attributes => {
+  const { pluginName, uid } = attributes;
+
+  if (!pluginName) {
+    return `application::${uid}`;
+  }
+
+  if (pluginName === 'admin') {
+    return `admin::${uid}`;
+  }
+
+  return `plugins::${pluginName}.${uid}`;
+};
+
+/**
+ * Assign an actionId attribute to an {@link CreateActionPayload} object
+ * @param {CreateActionPayload} attrs - Payload used to create an action
+ * @return {CreateActionPayload}
+ */
+const assignActionId = attrs => set('actionId', computeActionId(attrs), attrs);
+
+/**
+ * Transform an action by adding or removing the {@link Action.subCategory} attribute
+ * @param {Action} action - The action to process
+ * @return {Action}
+ */
+const assignOrOmitSubCategory = action => {
+  const shouldHaveSubCategory = ['settings', 'plugins'].includes(action.section);
+
+  return shouldHaveSubCategory
+    ? set('subCategory', action.subCategory || 'general', action)
+    : omit('subCategory', action);
+};
+
+/**
+ * Check if a property can be applied to an {@link Action}
+ * @type (function(property: string, action: Action): boolean) | (function(property: string): (function(action: Action): boolean))
+ * @return {boolean} Return true if the property can be applied for the given action
+ */
+const appliesToProperty = curry((property, action) => {
+  return pipe(prop('options.applyToProperties'), includes(property))(action);
+});
+
+/**
+ * Check if an action applies to a subject
+ * @param {string} subject
+ * @param {Action} action
+ * @return {boolean}
+ */
+const appliesToSubject = curry((subject, action) => {
+  return isArray(action.subjects) && includes(subject, action.subjects);
+});
+
+/**
+ * Transform the given attributes into a domain representation of an Action
+ * @type (function(payload: CreateActionPayload): Action)
+ * @param {CreateActionPayload} payload - The action payload containing the attributes needed to create an {@link Action}
+ * @return {Action} A newly created {@link Action}
+ */
+const create = pipe(
+  // Create and assign an action identifier to the action
+  // (need to be done before the sanitizeActionAttributes since we need the uid here)
+  assignActionId,
+  // Add or remove the sub category field based on the pluginName attribute
+  assignOrOmitSubCategory,
+  // Remove unwanted attributes from the payload
+  sanitizeActionAttributes,
+  // Complete the action creation by adding default values for some attributes
+  merge(getDefaultActionAttributes())
+);
+
+module.exports = {
+  actionFields,
+  appliesToProperty,
+  appliesToSubject,
+  assignActionId,
+  assignOrOmitSubCategory,
+  create,
+  computeActionId,
+  getDefaultActionAttributes,
+  sanitizeActionAttributes,
+};

package/domain/action/provider.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { providerFactory, hooks } = require('strapi-utils');
+const { validateRegisterProviderAction } = require('../../validation/action-provider');
+const domain = require('./index');
+
+/**
+ * @typedef ActionProviderOverride
+ * @property {function(CreateActionPayload)} register
+ * @property {function(attributes CreateActionPayload[]): Promise<this>} registerMany
+ */
+
+/**
+ * Creates a new instance of an action provider
+ * @return {Provider & ActionProviderOverride}
+ */
+const createActionProvider = options => {
+  const provider = providerFactory(options);
+  const actionHooks = {
+    appliesPropertyToSubject: hooks.createAsyncParallelHook(),
+  };
+
+  return {
+    ...provider,
+
+    hooks: {
+      ...provider.hooks,
+      ...actionHooks,
+    },
+
+    async register(actionAttributes) {
+      if (strapi.isLoaded) {
+        throw new Error(`You can't register new actions outside of the bootstrap function.`);
+      }
+
+      validateRegisterProviderAction([actionAttributes]);
+
+      const action = domain.create(actionAttributes);
+
+      return provider.register(action.actionId, action);
+    },
+
+    async registerMany(actionsAttributes) {
+      validateRegisterProviderAction(actionsAttributes);
+
+      for (const attributes of actionsAttributes) {
+        await this.register(attributes);
+      }
+
+      return this;
+    },
+
+    async appliesToProperty(property, actionId, subject) {
+      const action = provider.get(actionId);
+      const appliesToAction = domain.appliesToProperty(property, action);
+
+      // If the property isn't valid for this action, ignore the rest of the checks
+      if (!appliesToAction) {
+        return false;
+      }
+
+      // If the property is valid for this action and there isn't any subject
+      if (!subject) {
+        return true;
+      }
+
+      // If the property is valid for this action and the subject is not handled by the action
+      if (!domain.appliesToSubject(subject, action)) {
+        return false;
+      }
+
+      const results = await actionHooks.appliesPropertyToSubject.call({
+        property,
+        action,
+        subject,
+      });
+
+      return results.every(result => result !== false);
+    },
+  };
+};
+
+module.exports = createActionProvider;

package/domain/condition/index.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const { pipe, merge, set, pick } = require('lodash/fp');
+
+/**
+ * The handler of a {@link Condition}
+ * @typedef {(function(user: Object, options: Object): Object | boolean)} ConditionHandler
+ */
+/**
+ * Domain representation of a Condition (RBAC)
+ * @typedef {Object} Condition
+ * @property {string} id - The identifier of the condition
+ * @property {string} displayName - The display name of a condition
+ * @property {string} name - The name of a condition
+ * @property {string} [plugin] - The plugin which provide the condition
+ * @property {string} [category] - The main category of a condition
+ * @property {ConditionHandler} handler - The handler of a condition
+ */
+
+/**
+ * Set of attributes used to create a new {@link Action} object
+ * @typedef {Condition, { uid: string }} CreateConditionPayload
+ */
+
+const DEFAULT_CATEGORY = 'default';
+
+/**
+ * Get the default value used for every condition
+ * @return {Condition}
+ */
+const getDefaultConditionAttributes = () => ({
+  category: DEFAULT_CATEGORY,
+});
+
+/**
+ * Get the list of all the valid attributes of a {@link Condition}
+ * @return {string[]}
+ */
+const conditionFields = ['id', 'displayName', 'handler', 'plugin', 'category'];
+
+/**
+ * Remove unwanted attributes from a {@link Condition}
+ * @type {function(action: Condition | CreateConditionPayload): Condition}
+ */
+const sanitizeConditionAttributes = pick(conditionFields);
+
+/**
+ *
+ * @param condition
+ * @return {string}
+ */
+const computeConditionId = condition => {
+  const { name, plugin } = condition;
+
+  if (!plugin) {
+    return `application::${name}`;
+  }
+
+  if (plugin === 'admin') {
+    return `admin::${name}`;
+  }
+
+  return `plugins::${plugin}.${name}`;
+};
+
+/**
+ * Assign an id attribute to a {@link CreateConditionPayload} object
+ * @param {CreateConditionPayload} attrs - Payload used to create a condition
+ * @return {CreateConditionPayload}
+ */
+const assignConditionId = attrs => set('id', computeConditionId(attrs), attrs);
+
+/**
+ * Transform the given attributes into a domain representation of a Condition
+ * @type (function(CreateConditionPayload): Condition)
+ * @param {CreateConditionPayload} payload - The condition payload containing the attributes needed to create a {@link Condition}
+ * @return {Condition}
+ */
+const create = pipe(
+  assignConditionId,
+  sanitizeConditionAttributes,
+  merge(getDefaultConditionAttributes())
+);
+
+module.exports = {
+  assignConditionId,
+  computeConditionId,
+  conditionFields,
+  create,
+  getDefaultConditionAttributes,
+  sanitizeConditionAttributes,
+};

package/domain/condition/provider.js

@@ -0,0 +1,42 @@
+'use strict';
+
+const { providerFactory } = require('strapi-utils');
+const domain = require('./');
+
+/**
+ * @typedef ConditionProviderOverride
+ * @property {function(CreateConditionPayload)} register
+ * @property {function(attributes CreateConditionPayload[]): Promise<this>} registerMany
+ */
+
+/**
+ * Creates a new instance of a condition provider
+ * @return {Provider & ConditionProviderOverride}
+ */
+const createConditionProvider = () => {
+  const provider = providerFactory();
+
+  return {
+    ...provider,
+
+    async register(conditionAttributes) {
+      if (strapi.isLoaded) {
+        throw new Error(`You can't register new conditions outside of the bootstrap function.`);
+      }
+
+      const condition = domain.create(conditionAttributes);
+
+      return provider.register(condition.id, condition);
+    },
+
+    async registerMany(conditionsAttributes) {
+      for (const attributes of conditionsAttributes) {
+        await this.register(attributes);
+      }
+
+      return this;
+    },
+  };
+};
+
+module.exports = createConditionProvider;

package/domain/permission/index.js

@@ -0,0 +1,140 @@
+'use strict';
+
+const {
+  pipe,
+  set,
+  pick,
+  eq,
+  omit,
+  remove,
+  get,
+  uniq,
+  isArray,
+  map,
+  curry,
+  merge,
+} = require('lodash/fp');
+
+/**
+ * Domain representation of a Permission (RBAC)
+ * @typedef {Object} Permission
+ * @property {string} [id] - The unique identifier of the permission
+ * @property {string} [role] - The role associated to a permission
+ * @property {string} action - The human readable name of an action
+ * @property {string} properties - A set of properties used to define the permission with more granularity
+ * @property {string} conditions - Conditions to check when evaluating the permission
+ * @property {string} subject - The subject on which the permission should applies
+ */
+
+const permissionFields = ['id', 'action', 'subject', 'properties', 'conditions', 'role'];
+const sanitizedPermissionFields = ['id', 'action', 'subject', 'properties', 'conditions'];
+
+const sanitizePermissionFields = pick(sanitizedPermissionFields);
+
+/**
+ * Creates a permission with default values
+ * @return {Permission}
+ */
+const getDefaultPermission = () => ({
+  conditions: [],
+  properties: {},
+  subject: null,
+});
+
+/**
+ * Returns a new permission with the given condition
+ * @param {string} condition - The condition to add
+ * @param {Permission} permission - The permission on which we want to add the condition
+ * @return {Permission}
+ */
+const addCondition = curry((condition, permission) => {
+  const { conditions } = permission;
+  const newConditions = Array.isArray(conditions)
+    ? uniq(conditions.concat(condition))
+    : [condition];
+
+  return set('conditions', newConditions, permission);
+});
+
+/**
+ * Returns a new permission without the given condition
+ * @param {string} condition - The condition to remove
+ * @param {Permission} permission - The permission on which we want to remove the condition
+ * @return {Permission}
+ */
+const removeCondition = curry((condition, permission) => {
+  return set('conditions', remove(eq(condition), permission.conditions), permission);
+});
+
+/**
+ * Gets a property or a part of a property from a permission.
+ * @param {string} property - The property to get
+ * @param {Permission} permission - The permission on which we want to access the property
+ * @return {Permission}
+ */
+const getProperty = curry((property, permission) => get(`properties.${property}`, permission));
+
+/**
+ * Set a value for a given property on a new permission object
+ * @param {string} property - The name of the property
+ * @param {any} value - The value of the property
+ * @param {Permission} permission - The permission on which we want to set the property
+ * @return {Permission}
+ */
+const setProperty = (property, value, permission) => {
+  return set(`properties.${property}`, value, permission);
+};
+
+/**
+ * Returns a new permission without the given property name set
+ * @param {string} property - The name of the property to delete
+ * @param {Permission} permission - The permission on which we want to remove the property
+ * @return {Permission}
+ */
+const deleteProperty = (property, permission) => omit(`properties.${property}`, permission);
+
+/**
+ * Creates a new {@link Permission} object from raw attributes. Set default values for certain fields
+ * @param {Permission} attributes
+ * @return {Permission}
+ */
+const create = attributes => {
+  return pipe(pick(permissionFields), merge(getDefaultPermission()))(attributes);
+};
+
+/**
+ * Using the given condition provider, check and remove invalid condition from the permission's condition array.
+ * @param {object} provider - The condition provider used to do the checks
+ * @param {Permission} permission - The condition to sanitize
+ * @return {Permission}
+ */
+const sanitizeConditions = curry((provider, permission) => {
+  if (!isArray(permission.conditions)) {
+    return permission;
+  }
+
+  return permission.conditions
+    .filter(condition => !provider.has(condition))
+    .reduce((perm, condition) => removeCondition(condition, perm), permission);
+});
+
+/**
+ * Transform raw attributes into valid permissions using the create domain function.
+ * @param {object | object[]} payload - Can either be a single object of attributes or an array of those objects.
+ * @return {Permission | Permission[]}
+ */
+const toPermission = payload => (isArray(payload) ? map(create, payload) : create(payload));
+
+module.exports = {
+  addCondition,
+  removeCondition,
+  create,
+  deleteProperty,
+  permissionFields,
+  getProperty,
+  sanitizedPermissionFields,
+  sanitizeConditions,
+  sanitizePermissionFields,
+  setProperty,
+  toPermission,
+};

package/domain/role.js

@@ -0,0 +1,29 @@
+'use strict';
+
+const {
+  contentTypes: { hasDraftAndPublish },
+} = require('strapi-utils');
+const {
+  AUTHOR_CODE,
+  PUBLISH_ACTION,
+  DELETE_ACTION,
+  UPDATE_ACTION,
+  CREATE_ACTION,
+  READ_ACTION,
+} = require('../services/constants');
+
+const BOUND_ACTIONS = [READ_ACTION, CREATE_ACTION, UPDATE_ACTION, DELETE_ACTION, PUBLISH_ACTION];
+
+const BOUND_ACTIONS_FOR_FIELDS = [READ_ACTION, CREATE_ACTION, UPDATE_ACTION];
+
+const getBoundActionsBySubject = (role, subject) => {
+  const model = strapi.getModel(subject);
+
+  if (role.code === AUTHOR_CODE || !hasDraftAndPublish(model)) {
+    return [READ_ACTION, UPDATE_ACTION, CREATE_ACTION, DELETE_ACTION];
+  }
+
+  return BOUND_ACTIONS;
+};
+
+module.exports = { getBoundActionsBySubject, BOUND_ACTIONS, BOUND_ACTIONS_FOR_FIELDS };

package/domain/user.js

@@ -0,0 +1,25 @@
+'use strict';
+
+const { SUPER_ADMIN_CODE } = require('../services/constants');
+
+/**
+ * Create a new user model by merging default and specified attributes
+ * @param attributes A partial user object
+ */
+function createUser(attributes) {
+  return {
+    roles: [],
+    isActive: false,
+    username: null,
+    ...attributes,
+  };
+}
+
+const hasSuperAdminRole = user => {
+  return user.roles.filter(role => role.code === SUPER_ADMIN_CODE).length > 0;
+};
+
+module.exports = {
+  createUser,
+  hasSuperAdminRole,
+};

package/ee/LICENSE

@@ -0,0 +1,21 @@
+This Strapi Enterprise Edition (EE) supplemental license (this “EE Supplemental License”) governs the use of this software and documentation (collectively, the “EE Software”) by you and any entity you represent (collectively, “You”). If You have separately entered into the Strapi, Inc. Enterprise Agreement (the “Enterprise Agreement”), then this EE Supplemental License hereby incorporates by reference the Enterprise Agreement and modifies the Enterprise Agreement solely to the extent set forth herein. If You have separately entered into the Strapi, Inc. Subscription Agreement (the “Subscription Agreement”), then this EE Supplemental License hereby incorporates by reference the Agreement and modifies the Subscription Agreement solely to the extent set forth herein. If You have not entered into either the Enterprise Agreement or the Subscription Agreement, then You may use the EE Software solely as set forth in Section 2 below. 
+
+In the event of a direct conflict between the terms of this EE Supplemental License and the terms of the Enterprise Agreement or the Subscription Agreement, as applicable, the terms of this EE Supplemental License will control. Except to the extent modified by this EE Supplemental License, the Enterprise Agreement or the Subscription Agreement, as applicable, remain in full force and effect in accordance with its terms.
+
+By using the EE Software, You hereby agree to the below terms and conditions.
+
+1. Notwithstanding any terms to the contrary in the Enterprise Agreement or Subscription Agreement, You may copy, modify and publish patches to the EE Software in a production environment (such copies, “Production Copies,” such modifications, “Production Modifications” and such patches, “Production Patches”) if and only if (a) You have agreed to, and are in full compliance with, the Enterprise Agreement or Subscription Agreement, as applicable, and (b) You have a valid license to the EE Software for the correct number of projects. You agree that Strapi and/or its licensors (as applicable) will own all right, title and interest in and to all such Production Copies, Production Modifications and Production Patches. You may display and/or distribute such Production Copies, Production Modifications and Production Patches if and only if (i) You have a valid license to the EE Software for the correct number of projects and (ii) You are in compliance with the Enterprise Agreement or Subscription Agreement, as applicable. You hereby assign to Strapi all right, title and interest in and to all Production Copies, Production Modifications and Production Patches, including all intellectual property rights embodied in or related to the foregoing.
+
+2. Notwithstanding the foregoing, You may copy and modify the EE Software solely for development and testing purposes (such copies, “Development Copies” and such modifications, “Development Modifications”) with or without a license to the EE Software if your use is in compliance with this Section 2. You agree that Strapi and/or its licensors (as applicable) will own all right, title and interest in and to all Development Copies and Development Modifications and You hereby assign to Strapi all right, title and interest in and to all Development Copies and Development Modifications, including all intellectual property rights embodied in or related to the foregoing. If You do not have a license to the EE Software, then You further agree as follows:
+
+Other than as expressly set forth in this Section 2, You may not (a) copy or modify the EE Software, (b) create derivative works of the EE Software, (c) remove or modify any notice of any patent, copyright, trademark, or other proprietary rights that appear on or in the EE Software, (d) reverse engineer, decompile, translate, disassemble, or discover the source code of all or any portion of the EE Software, (e) publicly display all or any part of the EE Software, (f) distribute, disclose, market, lease, publish, merge, resell, assign, loan, sublicense, rent, or transfer the EE Software to any third party, (g) use the EE Software for any dial-up, remote access, interactive, or other on-line or hosted service, or to provide a service bureau, time share, or other services to third parties, (h) merge the EE Software into another product, (i) disclose the results of any EE Software performance benchmarks or test results to any third party without Strapi’s prior written consent, (j) use any trademarks, logos, service marks, trade names of Strapi, or any portion thereof, without Strapi’s prior written consent, (k) use the EE Software, or any portion thereof, in a manner that does not comply with applicable law, regulations, or governmental orders, or (l) use or store the EE Software on equipment not owned or controlled by Customer. 
+
+THE EE SOFTWARE IS PROVIDED ON AN “AS IS” BASIS WITHOUT ANY REPRESENTATIONS, WARRANTIES, COVENANTS, OR CONDITIONS OF ANY KIND (EXPRESS OR IMPLIED, STATUTORY OR OTHERWISE), INCLUDING, BUT NOT LIMITED TO, WARRANTIES OF MERCHANTABILITY, TITLE, FITNESS FOR A PARTICULAR PURPOSE, OR NONINFRINGEMENT.  FURTHER, STRAPI DOES NOT REPRESENT OR WARRANT THAT (A) THE ACCESS TO OR USE OF THE EE SOFTWARE WILL BE SECURE, TIMELY, UNINTERRUPTED, ERROR-FREE, OR OPERATE IN COMBINATION WITH ANY OTHER HARDWARE, SOFTWARE, SYSTEM, OR DATA, (B) THE EE SOFTWARE WILL MEET YOUR REQUIREMENTS OR EXPECTATIONS, OR OTHERWISE PRODUCE ANY PARTICULAR RESULTS, (C) ERRORS OR DEFECTS WILL BE CORRECTED, PATCHES OR WORKAROUNDS WILL BE PROVIDED, OR STRAPI WILL DETECT ANY BUG IN THE EE SOFTWARE, (D) THE SOFTWARE IS FREE OF VIRUSES OR OTHER HARMFUL COMPONENTS, OR (E) THIRD-PARTY DISRUPTIONS OR SECURITY BREACHES OF THE EE SOFTWARE WILL BE PREVENTED.
+
+STRAPI WILL NOT BE LIABLE FOR ANY LOSS OF PROFITS OR ANY INDIRECT, SPECIAL, INCIDENTAL, RELIANCE, OR CONSEQUENTIAL DAMAGES OF ANY KIND, REGARDLESS OF THE FORM OF ACTION, WHETHER IN CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY, OR OTHERWISE, EVEN IF INFORMED OF THE POSSIBILITY OF SUCH DAMAGES IN ADVANCE. 
+
+STRAPI’S ENTIRE LIABILITY TO YOU FOR USE OF THE EE SOFTWARE WILL NOT EXCEED $100.
+
+3. You are not granted any other rights beyond what is expressly stated herein and in the Enterprise Agreement or Subscription Agreement, as applicable.
+
+4. This EE Supplemental License does not apply to Strapi software that is distributed as part of the Strapi Community Edition (CE) (the “CE Software”).

package/ee/admin/components/ProviderButton/ProviderButtonStyles.js

@@ -0,0 +1,31 @@
+/* eslint-disable jsx-a11y/click-events-have-key-events */
+import React from 'react';
+import styled from 'styled-components';
+import { Flex, Text } from '@buffetjs/core';
+
+export const ProviderButtonWrapper = styled(props => <Flex {...props} />)`
+  width: 11rem;
+  height: 4.5rem;
+  padding: 0.5rem;
+  border-radius: ${({ theme }) => theme.main.sizes.borderRadius};
+  border: 1px solid ${({ theme }) => theme.main.colors.border};
+  cursor: pointer;
+  &:hover {
+    ${Text} {
+      color: ${({ theme }) => theme.main.colors.mediumBlue};
+    }
+    svg > path {
+      fill: ${({ theme }) => theme.main.colors.mediumBlue};
+    }
+    border: 1px solid ${({ theme }) => theme.main.colors.darkBlue};
+    background-color: ${({ theme }) => theme.main.colors.lightestBlue};
+  }
+`;
+
+export const ProviderLink = styled.a`
+  text-decoration: none;
+
+  &:hover {
+    text-decoration: none;
+  }
+`;

package/ee/admin/components/ProviderButton/index.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Text } from '@buffetjs/core';
+import { Tooltip } from '@buffetjs/styles';
+import { ProviderButtonWrapper, ProviderLink } from './ProviderButtonStyles';
+
+const ProviderButton = ({ provider }) => {
+  return (
+    <>
+      <ProviderLink
+        href={`${strapi.backendURL}/admin/connect/${provider.uid}`}
+        data-for={provider.uid}
+        data-tip={provider.displayName}
+      >
+        <ProviderButtonWrapper justifyContent="center" alignItems="center">
+          {provider.icon ? (
+            <img
+              src={provider.icon}
+              alt={provider.displayName}
+              style={{ maxWidth: '100%', maxHeight: 30 }}
+            />
+          ) : (
+            <Text color="black" ellipsis>
+              {provider.displayName}
+            </Text>
+          )}
+        </ProviderButtonWrapper>
+      </ProviderLink>
+      <Tooltip id={provider.uid} />
+    </>
+  );
+};
+
+ProviderButton.propTypes = {
+  provider: PropTypes.exact({
+    displayName: PropTypes.string,
+    icon: PropTypes.string,
+    uid: PropTypes.string,
+  }).isRequired,
+};
+
+export default ProviderButton;

package/ee/admin/components/Roles/ConditionsModal/ConditionsSelect/MenuList/utils/constants.js

@@ -0,0 +1,3 @@
+const IS_DISABLED = false;
+
+export default IS_DISABLED;

package/ee/admin/components/Roles/ContentTypeCollapse/Collapse/utils/constants.js

@@ -0,0 +1,3 @@
+const IS_DISABLED = false;
+
+export default IS_DISABLED;

package/ee/admin/components/Roles/ContentTypeCollapse/CollapsePropertyMatrix/ActionRow/utils/constants.js

@@ -0,0 +1,3 @@
+const IS_DISABLED = false;
+
+export default IS_DISABLED;

package/ee/admin/components/Roles/ContentTypeCollapse/CollapsePropertyMatrix/SubActionRow/utils/constants.js

@@ -0,0 +1,3 @@
+const IS_DISABLED = false;
+
+export default IS_DISABLED;

package/ee/admin/components/Roles/GlobalActions/utils/constants.js

@@ -0,0 +1,3 @@
+const IS_DISABLED = false;
+
+export default IS_DISABLED;