@strapi/admin 4.16.2 → 4.18.0

package/server/controllers/user.js

@@ -1,141 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { ApplicationError } = require('@strapi/utils').errors;
-const {
-  validateUserCreationInput,
-  validateUserUpdateInput,
-  validateUsersDeleteInput,
-} = require('../validation/user');
-
-const { getService } = require('../utils');
-
-module.exports = {
-  async create(ctx) {
-    const { body } = ctx.request;
-    const cleanData = { ...body, email: _.get(body, `email`, ``).toLowerCase() };
-
-    await validateUserCreationInput(cleanData);
-
-    const attributes = _.pick(cleanData, [
-      'firstname',
-      'lastname',
-      'email',
-      'roles',
-      'preferedLanguage',
-    ]);
-
-    const userAlreadyExists = await getService('user').exists({
-      email: attributes.email,
-    });
-
-    if (userAlreadyExists) {
-      throw new ApplicationError('Email already taken');
-    }
-
-    const createdUser = await getService('user').create(attributes);
-
-    const userInfo = getService('user').sanitizeUser(createdUser);
-
-    // Note: We need to assign manually the registrationToken to the
-    // final user payload so that it's not removed in the sanitation process.
-    Object.assign(userInfo, { registrationToken: createdUser.registrationToken });
-
-    // Send 201 created
-    ctx.created({ data: userInfo });
-  },
-
-  async find(ctx) {
-    const userService = getService('user');
-
-    const permissionsManager = strapi.admin.services.permission.createPermissionsManager({
-      ability: ctx.state.userAbility,
-      model: 'admin::user',
-    });
-
-    await permissionsManager.validateQuery(ctx.query);
-    const sanitizedQuery = await permissionsManager.sanitizeQuery(ctx.query);
-
-    const { results, pagination } = await userService.findPage(sanitizedQuery);
-
-    ctx.body = {
-      data: {
-        results: results.map((user) => userService.sanitizeUser(user)),
-        pagination,
-      },
-    };
-  },
-
-  async findOne(ctx) {
-    const { id } = ctx.params;
-
-    const user = await getService('user').findOne(id);
-
-    if (!user) {
-      return ctx.notFound('User does not exist');
-    }
-
-    ctx.body = {
-      data: getService('user').sanitizeUser(user),
-    };
-  },
-
-  async update(ctx) {
-    const { id } = ctx.params;
-    const { body: input } = ctx.request;
-
-    await validateUserUpdateInput(input);
-
-    if (_.has(input, 'email')) {
-      const uniqueEmailCheck = await getService('user').exists({
-        id: { $ne: id },
-        email: input.email,
-      });
-
-      if (uniqueEmailCheck) {
-        throw new ApplicationError('A user with this email address already exists');
-      }
-    }
-
-    const updatedUser = await getService('user').updateById(id, input);
-
-    if (!updatedUser) {
-      return ctx.notFound('User does not exist');
-    }
-
-    ctx.body = {
-      data: getService('user').sanitizeUser(updatedUser),
-    };
-  },
-
-  async deleteOne(ctx) {
-    const { id } = ctx.params;
-
-    const deletedUser = await getService('user').deleteById(id);
-
-    if (!deletedUser) {
-      return ctx.notFound('User not found');
-    }
-
-    return ctx.deleted({
-      data: getService('user').sanitizeUser(deletedUser),
-    });
-  },
-
-  /**
-   * Delete several users
-   * @param {KoaContext} ctx - koa context
-   */
-  async deleteMany(ctx) {
-    const { body } = ctx.request;
-    await validateUsersDeleteInput(body);
-
-    const users = await getService('user').deleteByIds(body.ids);
-
-    const sanitizedUsers = users.map(getService('user').sanitizeUser);
-
-    return ctx.deleted({
-      data: sanitizedUsers,
-    });
-  },
-};

package/server/controllers/webhooks.js

@@ -1,132 +0,0 @@
-'use strict';
-
-const _ = require('lodash');
-const { yup, validateYupSchema } = require('@strapi/utils');
-
-const urlRegex =
-  /^(?:([a-z0-9+.-]+):\/\/)(?:\S+(?::\S*)?@)?(?:(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))|(?:(?:[a-z\u00a1-\uffff0-9_]-*)*[a-z\u00a1-\uffff0-9_]+)(?:\.(?:[a-z\u00a1-\uffff0-9_]-*)*[a-z\u00a1-\uffff0-9_]+)*\.?)(?::\d{2,5})?(?:[/?#]\S*)?$/;
-
-const webhookValidator = yup
-  .object({
-    name: yup.string().required(),
-    url: yup.string().matches(urlRegex, 'url must be a valid URL').required(),
-    headers: yup.lazy((data) => {
-      if (typeof data !== 'object') {
-        return yup.object().required();
-      }
-
-      return yup
-        .object(
-          _.mapValues(data, () => {
-            yup.string().min(1).required();
-          })
-        )
-        .required();
-    }),
-    events: yup.array().of(yup.string()).required(),
-  })
-  .noUnknown();
-
-const updateWebhookValidator = webhookValidator.shape({
-  isEnabled: yup.boolean(),
-});
-
-module.exports = {
-  async listWebhooks(ctx) {
-    const webhooks = await strapi.webhookStore.findWebhooks();
-    ctx.send({ data: webhooks });
-  },
-
-  async getWebhook(ctx) {
-    const { id } = ctx.params;
-    const webhook = await strapi.webhookStore.findWebhook(id);
-
-    if (!webhook) {
-      return ctx.notFound('webhook.notFound');
-    }
-
-    ctx.send({ data: webhook });
-  },
-
-  async createWebhook(ctx) {
-    const { body } = ctx.request;
-
-    await validateYupSchema(webhookValidator)(body);
-
-    const webhook = await strapi.webhookStore.createWebhook(body);
-
-    strapi.webhookRunner.add(webhook);
-
-    ctx.created({ data: webhook });
-  },
-
-  async updateWebhook(ctx) {
-    const { id } = ctx.params;
-    const { body } = ctx.request;
-
-    await validateYupSchema(updateWebhookValidator)(body);
-
-    const webhook = await strapi.webhookStore.findWebhook(id);
-
-    if (!webhook) {
-      return ctx.notFound('webhook.notFound');
-    }
-
-    const updatedWebhook = await strapi.webhookStore.updateWebhook(id, {
-      ...webhook,
-      ...body,
-    });
-
-    if (!updatedWebhook) {
-      return ctx.notFound('webhook.notFound');
-    }
-
-    strapi.webhookRunner.update(updatedWebhook);
-
-    ctx.send({ data: updatedWebhook });
-  },
-
-  async deleteWebhook(ctx) {
-    const { id } = ctx.params;
-    const webhook = await strapi.webhookStore.findWebhook(id);
-
-    if (!webhook) {
-      return ctx.notFound('webhook.notFound');
-    }
-
-    await strapi.webhookStore.deleteWebhook(id);
-
-    strapi.webhookRunner.remove(webhook);
-
-    ctx.body = { data: webhook };
-  },
-
-  async deleteWebhooks(ctx) {
-    const { ids } = ctx.request.body;
-
-    if (!Array.isArray(ids) || ids.length === 0) {
-      return ctx.badRequest('ids must be an array of id');
-    }
-
-    for (const id of ids) {
-      const webhook = await strapi.webhookStore.findWebhook(id);
-
-      if (webhook) {
-        await strapi.webhookStore.deleteWebhook(id);
-        strapi.webhookRunner.remove(webhook);
-      }
-    }
-
-    ctx.send({ data: ids });
-  },
-
-  async triggerWebhook(ctx) {
-    const { id } = ctx.params;
-
-    const webhook = await strapi.webhookStore.findWebhook(id);
-
-    const response = await strapi.webhookRunner.run(webhook, 'trigger-test', {});
-
-    ctx.body = { data: response };
-  },
-};

package/server/destroy.js

@@ -1,10 +0,0 @@
-'use strict';
-
-const { getService } = require('./utils');
-
-module.exports = async () => {
-  const { conditionProvider, actionProvider } = getService('permission');
-
-  await conditionProvider.clear();
-  await actionProvider.clear();
-};

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

@@ -1,230 +0,0 @@
-'use strict';
-
-const domain = require('..');
-
-describe('Action Domain', () => {
-  describe('appliesToProperty', () => {
-    test('Should return false when action.options.applyToProperties is Nil', () => {
-      const action = { options: {} };
-      const property = 'foo';
-
-      const result = domain.appliesToProperty(property, action);
-
-      expect(result).toBe(false);
-    });
-
-    test('Should return true when action.options.applyToProperties contains the property', () => {
-      const action = { options: { applyToProperties: ['foo', 'bar'] } };
-      const property = 'foo';
-
-      const result = domain.appliesToProperty(property, action);
-
-      expect(result).toBe(true);
-    });
-
-    test('Should allow currying (arity of 2)', () => {
-      const action = { options: { applyToProperties: ['foo', 'bar'] } };
-      const property = 'foo';
-
-      const curriedForProperty = domain.appliesToProperty(property);
-      const result = curriedForProperty(action);
-
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('appliesToSubject', () => {
-    test('Should return false when action.subjects is not an array (applies to no subjects)', () => {
-      const action = {};
-      const subject = 'foo';
-
-      const result = domain.appliesToSubject(subject, action);
-
-      expect(result).toBe(false);
-    });
-
-    test('Should return true when action.subjects contains the subject', () => {
-      const action = { subjects: ['foo', 'bar'] };
-      const subject = 'foo';
-
-      const result = domain.appliesToSubject(subject, action);
-
-      expect(result).toBe(true);
-    });
-
-    test(`Should return false when action.subjects doesn't contains the subject`, () => {
-      const action = { subjects: ['foo', 'bar'] };
-      const subject = 'foobar';
-
-      const result = domain.appliesToSubject(subject, action);
-
-      expect(result).toBe(false);
-    });
-
-    test('Should allow currying (arity of 2)', () => {
-      const action = { subjects: ['foo', 'bar'] };
-      const subject = 'foo';
-
-      const curriedForSubject = domain.appliesToSubject(subject);
-      const result = curriedForSubject(action);
-
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('assignActionId', () => {
-    test('Create a new action with an actionId attribute. Prevent mutation on original object', () => {
-      const action = { uid: 'foobar' };
-
-      const newAction = domain.assignActionId(action);
-
-      // Original action shouldn't be mutated
-      expect(action).not.toHaveProperty('actionId');
-      // The new action should match the original one and add a new actionId attribute
-      expect(newAction).toMatchObject(action);
-      expect(newAction).toHaveProperty('actionId', 'api::foobar');
-    });
-  });
-
-  describe('assignOrOmitSubCategory', () => {
-    test('Should keep the subCategory property if action.section is "settings"', () => {
-      const action = { section: 'settings', subCategory: 'foo' };
-
-      const newAction = domain.assignOrOmitSubCategory(action);
-
-      expect(newAction).toHaveProperty('subCategory', 'foo');
-    });
-
-    test('Should keep the subCategory property if action.section is "plugins"', () => {
-      const action = { section: 'plugins', subCategory: 'foo' };
-
-      const newAction = domain.assignOrOmitSubCategory(action);
-
-      expect(newAction).toHaveProperty('subCategory', 'foo');
-    });
-
-    test('Should add a generic subCategory property if action.section is "settings" or "plugins" and action.subCategory is not defined', () => {
-      const action = { section: 'settings' };
-
-      const newAction = domain.assignOrOmitSubCategory(action);
-
-      expect(newAction).toHaveProperty('subCategory', 'general');
-    });
-
-    test(`Shouldn't add the subCategory property if action.section is not "settings" or "plugins"`, () => {
-      const action = { section: 'contentTypes' };
-
-      const newAction = domain.assignOrOmitSubCategory(action);
-
-      expect(newAction).not.toHaveProperty('subCategory');
-    });
-
-    test(`Should omit the subCategory property if action.section is not "settings" or "plugins"`, () => {
-      const action = { section: 'contentTypes', subCategory: 'foo' };
-
-      const newAction = domain.assignOrOmitSubCategory(action);
-
-      expect(newAction).not.toHaveProperty('subCategory');
-    });
-  });
-
-  describe('create', () => {
-    test('Should register an action with the minimum amount of information', () => {
-      const action = { section: 'contentTypes', uid: 'foo' };
-      const expected = { section: 'contentTypes', actionId: 'api::foo' };
-
-      const result = domain.create(action);
-
-      expect(result).toMatchObject(expected);
-    });
-
-    test('Should handle multiple step of transformation', () => {
-      const action = {
-        section: 'settings',
-        uid: 'foo',
-        pluginName: 'bar',
-        subCategory: 'foobar',
-        invalidAttribute: 'foobar',
-      };
-
-      const expected = {
-        section: 'settings',
-        pluginName: 'bar',
-        actionId: 'plugin::bar.foo',
-        subCategory: 'foobar',
-      };
-
-      const result = domain.create(action);
-
-      expect(result).toMatchObject(expected);
-    });
-  });
-
-  describe('computeActionId', () => {
-    test('Should return an actionId prefixed with "api::" when there is no pluginName', () => {
-      const attributes = { uid: 'foobar' };
-      const expected = 'api::foobar';
-
-      const actionId = domain.computeActionId(attributes);
-
-      expect(actionId).toBe(expected);
-    });
-
-    test('Should return an actionId prefixed with "admin::" when the pluginName is "admin"', () => {
-      const attributes = { uid: 'foobar', pluginName: 'admin' };
-      const expected = 'admin::foobar';
-
-      const actionId = domain.computeActionId(attributes);
-
-      expect(actionId).toBe(expected);
-    });
-
-    test('Should return an actionId prefixed with "plugin::" when there is a pluginName (other than admin)', () => {
-      const attributes = { uid: 'foobar', pluginName: 'myPlugin' };
-      const expected = 'plugin::myPlugin.foobar';
-
-      const actionId = domain.computeActionId(attributes);
-
-      expect(actionId).toBe(expected);
-    });
-  });
-
-  describe('getDefaultActionAttributes', () => {
-    test(`Default action attributes contains only elements from domain.actionFields`, () => {
-      const defaultAction = domain.getDefaultActionAttributes();
-      const attributes = Object.keys(defaultAction);
-
-      attributes.forEach((attribute) => expect(domain.actionFields).toContain(attribute));
-    });
-  });
-
-  describe('sanitizeActionAttributes', () => {
-    const getSortedAttributes = (object) => Object.keys(object).sort();
-
-    test(`It shouldn't remove attributes contained in domain.actionFields`, () => {
-      const action = domain.actionFields.reduce(
-        (attrs, attrName) => ({ ...attrs, [attrName]: 'foo' }),
-        {}
-      );
-
-      const sanitizedAction = domain.sanitizeActionAttributes(action);
-
-      expect(sanitizedAction).toMatchObject(action);
-      expect(getSortedAttributes(sanitizedAction)).toEqual(getSortedAttributes(action));
-    });
-
-    test('It should remove attributes not contained in domain.actionFields', () => {
-      const invalidAttributes = ['foo', 'bar'];
-      const action = domain.actionFields
-        .concat(invalidAttributes)
-        .reduce((attrs, attrName) => ({ ...attrs, [attrName]: 'foo' }), {});
-
-      const sanitizedAction = domain.sanitizeActionAttributes(action);
-
-      expect(getSortedAttributes(sanitizedAction)).not.toEqual(getSortedAttributes(action));
-      invalidAttributes.forEach((attribute) =>
-        expect(sanitizedAction).not.toHaveProperty(attribute)
-      );
-    });
-  });
-});