@strapi/admin 4.16.2 → 4.18.0

package/server/domain/condition/__tests__/condition-domain.test.js

@@ -1,122 +0,0 @@
-'use strict';
-
-const domain = require('..');
-
-describe('Condition Domain', () => {
-  describe('assignConditionId', () => {
-    test('Create a new condition with an id attribute. Prevent mutation on original object', () => {
-      const condition = { name: 'foobar' };
-
-      const newCondition = domain.assignConditionId(condition);
-
-      // Original condition shouldn't be mutated
-      expect(condition).not.toHaveProperty('id');
-      // The new condition should match the original one and add a new conditionId attribute
-      expect(newCondition).toMatchObject(condition);
-      expect(newCondition).toHaveProperty('id', 'api::foobar');
-    });
-  });
-
-  describe('computeConditionId', () => {
-    test('Should return a condition ID prefixed with "api::" when there is no plugin', () => {
-      const attributes = { name: 'foobar' };
-      const expected = 'api::foobar';
-
-      const id = domain.computeConditionId(attributes);
-
-      expect(id).toBe(expected);
-    });
-
-    test('Should return a condition id prefixed with "admin::" when the plugin is "admin"', () => {
-      const attributes = { name: 'foobar', plugin: 'admin' };
-      const expected = 'admin::foobar';
-
-      const id = domain.computeConditionId(attributes);
-
-      expect(id).toBe(expected);
-    });
-
-    test('Should return a condition id prefixed with "plugin::" when there is a plugin (other than admin)', () => {
-      const attributes = { name: 'foobar', plugin: 'myPlugin' };
-      const expected = 'plugin::myPlugin.foobar';
-
-      const id = domain.computeConditionId(attributes);
-
-      expect(id).toBe(expected);
-    });
-  });
-
-  describe('create', () => {
-    test('Should register a condition with the minimum amount of information', () => {
-      const handler = jest.fn(() => ({ foo: 'bar' }));
-      const condition = {
-        handler,
-        name: 'foo',
-        displayName: 'Foo',
-      };
-      const expected = {
-        handler,
-        id: 'api::foo',
-        displayName: 'Foo',
-        category: 'default',
-      };
-
-      const result = domain.create(condition);
-
-      expect(result).toMatchObject(expected);
-    });
-
-    test('Should handle multiple step of transformation', () => {
-      const handler = jest.fn(() => ({ foo: 'bar' }));
-      const condition = {
-        name: 'foo',
-        plugin: 'bar',
-        displayName: 'Foo',
-        handler,
-        invalidAttribute: 'foobar',
-      };
-
-      const expected = {
-        id: 'plugin::bar.foo',
-        category: 'default',
-        plugin: 'bar',
-        displayName: 'Foo',
-        handler,
-      };
-
-      const result = domain.create(condition);
-
-      expect(result).toMatchObject(expected);
-    });
-  });
-
-  describe('sanitizeConditionAttributes', () => {
-    const getSortedAttributes = (object) => Object.keys(object).sort();
-
-    test(`It shouldn't remove attributes contained in domain.conditionAttributes`, () => {
-      const condition = domain.conditionFields.reduce(
-        (attrs, attrName) => ({ ...attrs, [attrName]: 'foo' }),
-        {}
-      );
-
-      const sanitizedCondition = domain.sanitizeConditionAttributes(condition);
-
-      expect(sanitizedCondition).toMatchObject(condition);
-      expect(getSortedAttributes(sanitizedCondition)).toEqual(getSortedAttributes(condition));
-    });
-
-    test('It should remove attributes not contained in domain.conditionFields', () => {
-      const invalidAttributes = ['foo', 'bar'];
-      const condition = domain.conditionFields
-        .concat(invalidAttributes)
-        .reduce((attrs, attrName) => ({ ...attrs, [attrName]: 'foo' }), {});
-
-      const sanitizedCondition = domain.sanitizeConditionAttributes(condition);
-
-      expect(getSortedAttributes(sanitizedCondition)).not.toEqual(getSortedAttributes(condition));
-      invalidAttributes.forEach((attribute) =>
-        expect(sanitizedCondition).not.toHaveProperty(attribute)
-      );
-    });
-  });
-});

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

@@ -1,156 +0,0 @@
-'use strict';
-
-const { omit } = require('lodash/fp');
-const createConditionProvider = require('../provider');
-const domain = require('..');
-
-const providerMethods = [
-  'register',
-  'registerMany',
-  'delete',
-  'get',
-  'getWhere',
-  'values',
-  'keys',
-  'has',
-  'size',
-  'clear',
-];
-
-describe('Condition Provider', () => {
-  beforeEach(() => {
-    global.strapi = {
-      isLoaded: false,
-    };
-  });
-
-  test('ConditionProvider is a provider instance', () => {
-    const conditionProvider = createConditionProvider();
-
-    expect(conditionProvider).toHaveProperty('hooks', expect.any(Object));
-
-    providerMethods.forEach((methodName) =>
-      expect(conditionProvider).toHaveProperty(methodName, expect.any(Function))
-    );
-  });
-
-  describe('Methods', () => {
-    describe('Register', () => {
-      test('Can register a new condition using condition attributes', async () => {
-        const attributes = {
-          name: 'foobar',
-          displayName: 'Foo bar',
-          plugin: 'foo',
-          handler: { foo: 'bar' },
-        };
-        const expected = omit('name', attributes);
-        const id = domain.computeConditionId(attributes);
-
-        const conditionProvider = createConditionProvider();
-
-        await conditionProvider.register(attributes);
-
-        const condition = conditionProvider.get(id);
-
-        expect(condition).not.toHaveProperty('name');
-        expect(condition).toHaveProperty('id', id);
-        expect(condition).toMatchObject(expected);
-      });
-
-      test(`Can't register a condition if strapi is loaded`, async () => {
-        global.strapi.isLoaded = true;
-
-        const attributes = {
-          name: 'foobar',
-          displayName: 'Foo bar',
-          plugin: 'foo',
-          handler: { foo: 'bar' },
-        };
-
-        const conditionProvider = createConditionProvider();
-
-        const register = () => conditionProvider.register(attributes);
-
-        await expect(register()).rejects.toThrowError(
-          `You can't register new conditions outside of the bootstrap function.`
-        );
-      });
-
-      test('Registration hooks are triggered on register', async () => {
-        const attributes = {
-          name: 'foobar',
-          displayName: 'Foo bar',
-          plugin: 'foo',
-          handler: { foo: 'bar' },
-        };
-
-        const willRegister = jest.fn();
-        const didRegister = jest.fn();
-
-        const conditionProvider = createConditionProvider();
-
-        conditionProvider.hooks.willRegister.register(willRegister);
-        conditionProvider.hooks.didRegister.register(didRegister);
-
-        await conditionProvider.register(attributes);
-
-        expect(willRegister).toHaveBeenCalled();
-        expect(didRegister).toHaveBeenCalled();
-      });
-    });
-
-    describe('Register Many', () => {
-      test('Can register multiple condition at once', async () => {
-        const attributes = [
-          {
-            name: 'foobar-A',
-            displayName: 'Foo bar A',
-            plugin: 'foo',
-            handler: { foo: 'bar' },
-          },
-          {
-            name: 'foobar-B',
-            displayName: 'Foo bar B',
-            plugin: 'foo',
-            handler: { foo: 'bar' },
-          },
-        ];
-
-        const conditionProvider = createConditionProvider();
-
-        await conditionProvider.registerMany(attributes);
-
-        expect(conditionProvider.size()).toBe(attributes.length);
-      });
-
-      test('Registering many condition shall trigger the registration hooks multiple time', async () => {
-        const attributes = [
-          {
-            name: 'foobar-A',
-            displayName: 'Foo bar A',
-            plugin: 'foo',
-            handler: { foo: 'bar' },
-          },
-          {
-            name: 'foobar-B',
-            displayName: 'Foo bar B',
-            plugin: 'foo',
-            handler: { foo: 'bar' },
-          },
-        ];
-        const willRegister = jest.fn();
-        const didRegister = jest.fn();
-
-        const conditionProvider = createConditionProvider();
-
-        conditionProvider.hooks.willRegister.register(willRegister);
-        conditionProvider.hooks.didRegister.register(didRegister);
-
-        await conditionProvider.registerMany(attributes);
-
-        expect(willRegister).toHaveBeenCalledTimes(2);
-        expect(didRegister).toHaveBeenCalledTimes(2);
-      });
-    });
-  });
-});

package/server/domain/condition/index.js

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

@@ -1,42 +0,0 @@
-'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/server/domain/permission/__tests__/permission-domain.test.js

@@ -1,285 +0,0 @@
-'use strict';
-
-const domain = require('..');
-
-describe('Permission Domain', () => {
-  describe('addCondition', () => {
-    test(`Init the condition array if it doesn't exists`, async () => {
-      const permission = {};
-
-      const newPermission = domain.addCondition('foo', permission);
-
-      expect(permission).not.toHaveProperty('conditions');
-      expect(newPermission).toHaveProperty('conditions', ['foo']);
-    });
-
-    test('Adds the new condition to the permission.conditions property', async () => {
-      const permission = { conditions: ['foo'] };
-
-      const newPermission = domain.addCondition('bar', permission);
-
-      expect(permission).toHaveProperty('conditions', ['foo']);
-      expect(newPermission).toHaveProperty('conditions', ['foo', 'bar']);
-    });
-
-    test(`Don't add the new condition to the permission.conditions property if it's already been added`, async () => {
-      const permission = { conditions: ['foo'] };
-
-      const newPermission = domain.addCondition('foo', permission);
-
-      expect(permission).toHaveProperty('conditions', ['foo']);
-      expect(newPermission).toHaveProperty('conditions', ['foo']);
-    });
-  });
-
-  describe('removeCondition', () => {
-    test('Can remove added condition from permission.conditions', () => {
-      const permission = { conditions: ['foo', 'bar'] };
-
-      const newPermission = domain.removeCondition('foo', permission);
-
-      expect(permission).toHaveProperty('conditions', ['foo', 'bar']);
-      expect(newPermission).toHaveProperty('conditions', ['bar']);
-    });
-
-    test(`Do not remove anything if the condition isn't present in permission.conditions`, () => {
-      const permission = { conditions: ['foo', 'bar'] };
-
-      const newPermission = domain.removeCondition('foobar', permission);
-
-      expect(permission).toHaveProperty('conditions', ['foo', 'bar']);
-      expect(newPermission).toHaveProperty('conditions', ['foo', 'bar']);
-    });
-  });
-
-  describe('create', () => {
-    test('Removes unwanted fields', () => {
-      const permission = {
-        id: 1,
-        action: 'foo',
-        subject: 'bar',
-        properties: {},
-        conditions: [],
-        foo: 'bar',
-      };
-
-      const newPermission = domain.create(permission);
-
-      expect(newPermission).not.toHaveProperty('foo');
-    });
-  });
-
-  describe('sanitizePermissionFields', () => {
-    test('Returns a new permission without the invalid fields', () => {
-      const invalidPermission = { action: 'foo', subject: 'bar', properties: {}, foo: 'bar' };
-
-      const permission = domain.sanitizePermissionFields(invalidPermission);
-
-      expect(permission).not.toHaveProperty('foo');
-    });
-  });
-
-  describe('setProperty', () => {
-    test('Can set a new property and its value', () => {
-      const permission = { properties: {} };
-
-      const newPermission = domain.setProperty('foo', 'bar', permission);
-
-      expect(permission).toHaveProperty('properties', {});
-      expect(newPermission).toHaveProperty('properties', { foo: 'bar' });
-    });
-
-    test('Can update the value of an existing property', () => {
-      const permission = { properties: { foo: 'bar' } };
-
-      const newPermission = domain.setProperty('foo', 'foobar', permission);
-
-      expect(permission).toHaveProperty('properties', { foo: 'bar' });
-      expect(newPermission).toHaveProperty('properties', { foo: 'foobar' });
-    });
-
-    test('Can perform a deep update on a property', () => {
-      const permission = { properties: { foo: { bar: { foobar: null } } }, bar: 'foo' };
-
-      const newPermission = domain.setProperty('foo.bar.foobar', 1, permission);
-
-      expect(permission).toHaveProperty('properties.foo.bar.foobar', null);
-      expect(newPermission).toHaveProperty('properties.foo.bar.foobar', 1);
-    });
-  });
-
-  describe('deleteProperty', () => {
-    test('Can delete an existing property', () => {
-      const permission = { properties: { foo: 'bar', bar: 'foo' } };
-
-      const newPermission = domain.deleteProperty('foo', permission);
-
-      expect(permission).toHaveProperty('properties', { foo: 'bar', bar: 'foo' });
-      expect(newPermission).toHaveProperty('properties', { bar: 'foo' });
-    });
-
-    test('Delete a non-existing property does nothing', () => {
-      const permission = { properties: { foo: 'bar' } };
-
-      const newPermission = domain.deleteProperty('bar', permission);
-
-      expect(permission).toHaveProperty('properties', { foo: 'bar' });
-      expect(newPermission).toHaveProperty('properties', { foo: 'bar' });
-    });
-
-    test('Can perform a deep delete on a property', () => {
-      const permission = { properties: { foo: { bar: { foobar: null, barfoo: 2 } } }, bar: 'foo' };
-
-      const newPermission = domain.deleteProperty('foo.bar.barfoo', permission);
-
-      expect(permission).toHaveProperty('properties.foo.bar', { foobar: null, barfoo: 2 });
-      expect(newPermission).toHaveProperty('properties.foo.bar', { foobar: null });
-    });
-  });
-
-  describe('toPermission', () => {
-    test('Handle single permission object and call domain.create', () => {
-      const permission = {
-        id: 1,
-        action: 'foo',
-        actionParameters: {},
-        subject: 'bar',
-        properties: {},
-        conditions: [],
-        foo: 'bar',
-      };
-
-      const newPermission = domain.toPermission(permission);
-
-      expect(newPermission).not.toHaveProperty('foo');
-    });
-
-    test('Handle multiple permission object and call domain.create', () => {
-      const permissions = [
-        {
-          id: 1,
-          action: 'foo',
-          actionParameters: {},
-          subject: 'bar',
-          properties: {},
-          conditions: [],
-          foo: 'bar',
-        },
-        {
-          id: 2,
-          action: 'foo',
-          subject: 'bar',
-          properties: {},
-          conditions: [],
-          foo: 'bar',
-        },
-      ];
-
-      const newPermissions = domain.toPermission(permissions);
-
-      newPermissions.forEach((p) => expect(p).not.toHaveProperty('foo'));
-    });
-  });
-
-  describe('getProperty', () => {
-    test('Can get a property if it exists', () => {
-      const permission = { properties: { foo: 'bar' } };
-
-      const property = domain.getProperty('foo', permission);
-
-      expect(property).toBe('bar');
-    });
-
-    test('Can get a deep property if it exists', () => {
-      const permission = { properties: { foo: { bar: 'foobar' } } };
-
-      const property = domain.getProperty('foo.bar', permission);
-
-      expect(property).toBe('foobar');
-    });
-
-    test(`Trying to get a property that doesn't exist returns undefined`, () => {
-      const permission = { properties: { foo: 'bar' } };
-
-      const property = domain.getProperty('bar', permission);
-
-      expect(property).toBeUndefined();
-    });
-
-    test('getProperty should allow currying', () => {
-      const permissions = [{ properties: { foo: 'bar' } }, { properties: { foo: 'foobar' } }];
-
-      const getFooProperty = domain.getProperty('foo');
-
-      permissions.forEach((permission) => {
-        const fooProperty = getFooProperty(permission);
-
-        expect(fooProperty).toBe(permission.properties.foo);
-      });
-    });
-
-    test(`Trying to access property if permission.properties isn't defined should return undefined`, () => {
-      const permission = {};
-
-      const property = domain.getProperty('foo', permission);
-
-      expect(property).toBeUndefined();
-    });
-  });
-
-  describe('sanitizeConditions', () => {
-    const conditions = ['foo', 'bar'];
-    const conditionProvider = { has: (condition) => conditions.includes(condition) };
-
-    test(`No conditions should be removed if they're valid`, () => {
-      const permission = { conditions: ['foo', 'bar'] };
-
-      const permissionWithSanitizedConditions = domain.sanitizeConditions(
-        conditionProvider,
-        permission
-      );
-
-      expect(permissionWithSanitizedConditions).toHaveProperty('conditions', ['foo', 'bar']);
-    });
-
-    test('Non existing permissions should be removed from the conditions property', () => {
-      const permission = { conditions: ['foo', 'foobar'] };
-
-      const permissionWithSanitizedConditions = domain.sanitizeConditions(
-        conditionProvider,
-        permission
-      );
-
-      expect(permissionWithSanitizedConditions).toHaveProperty('conditions', ['foo']);
-    });
-
-    test('Do nothing when permission.conditions is not defined', () => {
-      const permission = {};
-
-      const permissionWithSanitizedConditions = domain.sanitizeConditions(
-        conditionProvider,
-        permission
-      );
-
-      expect(permissionWithSanitizedConditions).not.toHaveProperty('conditions');
-    });
-
-    test.each([
-      [{ conditions: [] }, []],
-      [{ conditions: ['foo'] }, ['foo']],
-      [{ conditions: ['foo', 'foobar'] }, ['foo']],
-      [{ conditions: ['foobar'] }, []],
-      [{}, undefined],
-    ])('Should allow currying (arity 2)', (permission, expected) => {
-      const sanitizeConditionsWithProvider = domain.sanitizeConditions(conditionProvider);
-
-      const permissionWithSanitizedConditions = sanitizeConditionsWithProvider(permission);
-
-      if (expected === undefined) {
-        expect(permissionWithSanitizedConditions).not.toHaveProperty('conditions');
-      } else {
-        expect(permissionWithSanitizedConditions).toHaveProperty('conditions', expected);
-      }
-    });
-  });
-});