@strapi/admin 4.16.2 → 4.17.0

package/server/domain/action/__tests__/action-provider.test.js

@@ -1,376 +0,0 @@
-'use strict';
-
-const { omit } = require('lodash/fp');
-const createActionProvider = require('../provider');
-const domain = require('..');
-
-const providerMethods = [
-  'register',
-  'registerMany',
-  'appliesToProperty',
-  'delete',
-  'get',
-  'getWhere',
-  'values',
-  'keys',
-  'has',
-  'size',
-  'clear',
-];
-
-describe('Action Provider', () => {
-  beforeEach(() => {
-    global.strapi = {
-      isLoaded: false,
-      plugins: {
-        bar: {},
-      },
-    };
-  });
-
-  test('ActionProvider is a provider instance', () => {
-    const actionProvider = createActionProvider();
-
-    expect(actionProvider).toHaveProperty('hooks', expect.any(Object));
-
-    providerMethods.forEach((methodName) =>
-      expect(actionProvider).toHaveProperty(methodName, expect.any(Function))
-    );
-  });
-
-  describe('Methods', () => {
-    describe('Register', () => {
-      test('Can register a new action using action attributes', async () => {
-        const attributes = {
-          section: 'settings',
-          displayName: 'Foo bar',
-          uid: 'foo',
-          pluginName: 'bar',
-          category: 'category',
-          subCategory: 'subcategory',
-        };
-        const expected = omit('uid', attributes);
-        const actionId = domain.computeActionId(attributes);
-
-        const actionProvider = createActionProvider();
-
-        await actionProvider.register(attributes);
-
-        const action = actionProvider.get(actionId);
-
-        expect(action).not.toHaveProperty('uid');
-        expect(action).toHaveProperty('actionId', actionId);
-        expect(action).toMatchObject(expected);
-      });
-
-      test(`Can't register an action if strapi is loaded`, async () => {
-        global.strapi.isLoaded = true;
-
-        const attributes = {
-          section: 'settings',
-          displayName: 'Foo bar',
-          uid: 'foo',
-          pluginName: 'bar',
-          category: 'category',
-          subCategory: 'subcategory',
-          invalidField: 'invalid',
-        };
-
-        const actionProvider = createActionProvider();
-
-        const register = () => actionProvider.register(attributes);
-
-        await expect(register()).rejects.toThrowError(
-          `You can't register new actions outside of the bootstrap function.`
-        );
-      });
-
-      test(`Can't register an action with unknown attribute`, async () => {
-        const attributes = {
-          section: 'settings',
-          displayName: 'Foo bar',
-          uid: 'foo',
-          pluginName: 'bar',
-          category: 'category',
-          subCategory: 'subcategory',
-          invalidField: 'invalid',
-        };
-
-        const actionProvider = createActionProvider();
-
-        const register = () => actionProvider.register(attributes);
-
-        await expect(register()).rejects.toThrowError();
-      });
-
-      test('Registration hooks are triggered on register', async () => {
-        const attributes = {
-          section: 'settings',
-          displayName: 'Foo bar',
-          uid: 'foo',
-          pluginName: 'bar',
-          category: 'category',
-          subCategory: 'subcategory',
-        };
-
-        const willRegister = jest.fn();
-        const didRegister = jest.fn();
-
-        const actionProvider = createActionProvider();
-
-        actionProvider.hooks.willRegister.register(willRegister);
-        actionProvider.hooks.didRegister.register(didRegister);
-
-        await actionProvider.register(attributes);
-
-        expect(willRegister).toHaveBeenCalled();
-        expect(didRegister).toHaveBeenCalled();
-      });
-    });
-
-    describe('Register Many', () => {
-      test('Can register multiple action at once', async () => {
-        const attributes = [
-          {
-            section: 'settings',
-            displayName: 'Foo bar',
-            uid: 'foo',
-            pluginName: 'bar',
-            category: 'category',
-            subCategory: 'subcategory',
-          },
-          {
-            section: 'contentTypes',
-            subjects: ['foo', 'bar'],
-            displayName: 'Bar foo',
-            uid: 'bar',
-          },
-        ];
-
-        const actionProvider = createActionProvider();
-
-        await actionProvider.registerMany(attributes);
-
-        expect(actionProvider.size()).toBe(attributes.length);
-      });
-
-      test(`If one action has invalid attributes, don't register the other`, async () => {
-        const attributes = [
-          {
-            section: 'settings',
-            displayName: 'Foo bar',
-            uid: 'foo',
-            pluginName: 'bar',
-            category: 'category',
-            subCategory: 'subcategory',
-          },
-          {
-            section: 'contentTypes',
-            displayName: 'Bar foo',
-            uid: 'bar',
-          },
-        ];
-
-        const actionProvider = createActionProvider();
-        const registerAll = () => actionProvider.registerMany(attributes);
-
-        await expect(registerAll()).rejects.toThrowError();
-        expect(actionProvider.size()).toBe(0);
-      });
-
-      test('Registering many action shall trigger the registration hooks multiple time', async () => {
-        const attributes = [
-          {
-            section: 'settings',
-            displayName: 'Foo bar',
-            uid: 'foo',
-            pluginName: 'bar',
-            category: 'category',
-            subCategory: 'subcategory',
-          },
-          {
-            section: 'contentTypes',
-            subjects: ['foo', 'bar'],
-            displayName: 'Bar foo',
-            uid: 'bar',
-          },
-        ];
-        const willRegister = jest.fn();
-        const didRegister = jest.fn();
-
-        const actionProvider = createActionProvider();
-
-        actionProvider.hooks.willRegister.register(willRegister);
-        actionProvider.hooks.didRegister.register(didRegister);
-
-        await actionProvider.registerMany(attributes);
-
-        expect(willRegister).toHaveBeenCalledTimes(2);
-        expect(didRegister).toHaveBeenCalledTimes(2);
-      });
-    });
-
-    describe('Applies To Property', () => {
-      test('Returns false if the property cannot be applied to the action', async () => {
-        const action = {
-          section: 'contentTypes',
-          subjects: ['foo', 'bar'],
-          displayName: 'Foo bar',
-          uid: 'foobar',
-        };
-
-        const actionId = domain.computeActionId(action);
-        const actionProvider = createActionProvider();
-
-        await actionProvider.register(action);
-
-        const applies = await actionProvider.appliesToProperty('fields', actionId);
-
-        expect(applies).toBe(false);
-      });
-
-      test('Returns true if the property can be applied to the action and there is no subject', async () => {
-        const action = {
-          section: 'contentTypes',
-          subjects: ['foo', 'bar'],
-          displayName: 'Foo bar',
-          uid: 'foobar',
-          options: {
-            applyToProperties: ['fields'],
-          },
-        };
-
-        const actionId = domain.computeActionId(action);
-        const actionProvider = createActionProvider();
-
-        await actionProvider.register(action);
-
-        const applies = await actionProvider.appliesToProperty('fields', actionId);
-
-        expect(applies).toBe(true);
-      });
-
-      test('Returns false if the property can be applied to the action but not the subject', async () => {
-        const action = {
-          section: 'contentTypes',
-          subjects: ['foo', 'bar'],
-          displayName: 'Foo bar',
-          uid: 'foobar',
-          options: {
-            applyToProperties: ['fields'],
-          },
-        };
-
-        const actionId = domain.computeActionId(action);
-        const actionProvider = createActionProvider();
-
-        await actionProvider.register(action);
-
-        const applies = await actionProvider.appliesToProperty('fields', actionId, 'foobar');
-
-        expect(applies).toBe(false);
-      });
-
-      test('Returns true if the property and the subject can be applied to the action and there is no hook registered', async () => {
-        const action = {
-          section: 'contentTypes',
-          subjects: ['foo', 'bar'],
-          displayName: 'Foo bar',
-          uid: 'foobar',
-          options: {
-            applyToProperties: ['fields'],
-          },
-        };
-
-        const actionId = domain.computeActionId(action);
-        const actionProvider = createActionProvider();
-
-        await actionProvider.register(action);
-
-        const applies = await actionProvider.appliesToProperty('fields', actionId, 'foo');
-
-        expect(applies).toBe(true);
-      });
-
-      test('Returns false if one of the registered hooks returns false', async () => {
-        const action = {
-          section: 'contentTypes',
-          subjects: ['foo', 'bar'],
-          displayName: 'Foo bar',
-          uid: 'foobar',
-          options: {
-            applyToProperties: ['fields'],
-          },
-        };
-
-        const actionId = domain.computeActionId(action);
-        const actionProvider = createActionProvider();
-
-        const hooks = [
-          jest.fn(() => true),
-          jest.fn(() => undefined),
-          jest.fn(() => 2),
-          jest.fn(() => ({})),
-          jest.fn(() => false),
-        ];
-
-        hooks.forEach((hook) => actionProvider.hooks.appliesPropertyToSubject.register(hook));
-
-        await actionProvider.register(action);
-
-        const actionFromProvider = actionProvider.get(actionId);
-        const applies = await actionProvider.appliesToProperty('fields', actionId, 'foo');
-
-        expect(applies).toBe(false);
-
-        hooks.forEach((hook) =>
-          expect(hook).toHaveBeenCalledWith({
-            property: 'fields',
-            action: actionFromProvider,
-            subject: 'foo',
-          })
-        );
-      });
-
-      test('Returns true if none of the registered hooks returns false', async () => {
-        const action = {
-          section: 'contentTypes',
-          subjects: ['foo', 'bar'],
-          displayName: 'Foo bar',
-          uid: 'foobar',
-          options: {
-            applyToProperties: ['fields'],
-          },
-        };
-
-        const actionId = domain.computeActionId(action);
-        const actionProvider = createActionProvider();
-
-        const hooks = [
-          jest.fn(() => true),
-          jest.fn(() => undefined),
-          jest.fn(() => 2),
-          jest.fn(() => ({})),
-          jest.fn(() => new Date()),
-        ];
-
-        hooks.forEach((hook) => actionProvider.hooks.appliesPropertyToSubject.register(hook));
-
-        await actionProvider.register(action);
-
-        const actionFromProvider = actionProvider.get(actionId);
-        const applies = await actionProvider.appliesToProperty('fields', actionId, 'foo');
-
-        expect(applies).toBe(true);
-
-        hooks.forEach((hook) =>
-          expect(hook).toHaveBeenCalledWith({
-            property: 'fields',
-            action: actionFromProvider,
-            subject: 'foo',
-          })
-        );
-      });
-    });
-  });
-});

package/server/domain/action/index.js

@@ -1,142 +0,0 @@
-'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 `api::${uid}`;
-  }
-
-  if (pluginName === 'admin') {
-    return `admin::${uid}`;
-  }
-
-  return `plugin::${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/server/domain/action/provider.js

@@ -1,83 +0,0 @@
-'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;