@strapi/admin 4.16.2 → 4.17.0

package/server/controllers/__tests__/user.test.js

@@ -1,326 +0,0 @@
-'use strict';
-
-const { ApplicationError } = require('@strapi/utils').errors;
-const createContext = require('../../../../../../test/helpers/create-context');
-const userController = require('../user');
-
-describe('User Controller', () => {
-  describe('Create User', () => {
-    const body = {
-      firstname: 'Kai',
-      lastname: 'Doe',
-      email: 'kaidoe@email.com',
-      roles: [1, 2],
-    };
-
-    test('Fails if user already exist', async () => {
-      const exists = jest.fn(() => Promise.resolve(true));
-      const ctx = createContext({ body });
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: {
-              exists,
-            },
-          },
-        },
-      };
-
-      expect.assertions(3);
-
-      try {
-        await userController.create(ctx);
-      } catch (e) {
-        expect(e instanceof ApplicationError).toBe(true);
-        expect(e.message).toEqual('Email already taken');
-      }
-
-      expect(exists).toHaveBeenCalledWith({ email: body.email });
-    });
-
-    test('Create User Successfully', async () => {
-      const create = jest.fn(() => Promise.resolve(body));
-      const exists = jest.fn(() => Promise.resolve(false));
-      const sanitizeUser = jest.fn((user) => Promise.resolve(user));
-      const created = jest.fn();
-      const ctx = createContext({ body }, { created });
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: {
-              exists,
-              create,
-              sanitizeUser,
-            },
-          },
-        },
-      };
-
-      await userController.create(ctx);
-
-      expect(exists).toHaveBeenCalledWith({ email: body.email });
-      expect(create).toHaveBeenCalledWith(body);
-      expect(sanitizeUser).toHaveBeenCalled();
-      expect(created).toHaveBeenCalled();
-    });
-
-    test('Create User Successfully with camelCase email', async () => {
-      const camelCaseBody = { ...body, email: 'kAiDoE@CamelCaSE.com' };
-      const create = jest.fn(() => Promise.resolve(camelCaseBody));
-      const exists = jest.fn(() => Promise.resolve(false));
-      const sanitizeUser = jest.fn((user) => Promise.resolve(user));
-      const created = jest.fn();
-      const ctx = createContext({ body: camelCaseBody }, { created });
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: {
-              exists,
-              create,
-              sanitizeUser,
-            },
-          },
-        },
-      };
-
-      await userController.create(ctx);
-
-      const lowerEmail = camelCaseBody.email.toLowerCase();
-      expect(exists).toHaveBeenCalledWith({ email: lowerEmail });
-      expect(create).toHaveBeenCalledWith({
-        ...camelCaseBody,
-        email: lowerEmail,
-      });
-      expect(sanitizeUser).toHaveBeenCalled();
-      expect(created).toHaveBeenCalled();
-    });
-  });
-
-  describe('Find a user by its ID', () => {
-    const user = {
-      id: 1,
-      firstname: 'Kai',
-      lastname: 'Doe',
-      email: 'kaidoe@email.com',
-      roles: [1, 2],
-    };
-
-    test('Find a user correctly', async () => {
-      const findOne = jest.fn(() => user);
-      const sanitizeUser = jest.fn((user) => user);
-      const ctx = createContext({ params: { id: user.id } });
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: { findOne, sanitizeUser },
-          },
-        },
-      };
-
-      await userController.findOne(ctx);
-
-      expect(findOne).toHaveBeenCalledWith(user.id);
-      expect(sanitizeUser).toHaveBeenCalledWith(user);
-      expect(ctx.body).toStrictEqual({ data: user });
-    });
-
-    test('User not found', async () => {
-      const fakeId = 42;
-      const notFound = jest.fn();
-      const findOne = jest.fn(() => Promise.resolve(null));
-      const ctx = createContext({ params: { id: fakeId } }, { notFound });
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: { findOne },
-          },
-        },
-      };
-
-      await userController.findOne(ctx);
-
-      expect(findOne).toHaveBeenCalledWith(fakeId);
-      expect(notFound).toHaveBeenCalledWith('User does not exist');
-    });
-  });
-
-  describe('Find users', () => {
-    const users = [
-      {
-        id: 1,
-        firstname: 'Kai',
-        lastname: 'Doe',
-        email: 'kaidoe@email.com',
-        roles: [1, 2],
-      },
-      {
-        id: 2,
-        firstname: 'Doe',
-        lastname: 'Kai',
-        email: 'doekai@email.com',
-        roles: [3],
-      },
-    ];
-
-    test('Find all users', async () => {
-      const pagination = { page: 1, pageSize: 5, pageCount: 1, total: 2 };
-      const findPage = jest.fn(() => ({
-        results: users,
-        pagination,
-      }));
-
-      const state = {
-        userAbility: {
-          can: jest.fn(),
-          cannot: jest.fn(() => false),
-        },
-      };
-
-      const sanitizeUser = jest.fn((user) => user);
-      const ctx = createContext({});
-      ctx.state = state;
-
-      const createPermissionsManager = jest.fn(() => ({
-        ability: state.userAbility,
-        sanitizeQuery: (query) => query,
-        validateQuery() {},
-      }));
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: { findPage, sanitizeUser },
-            permission: {
-              createPermissionsManager,
-            },
-          },
-        },
-      };
-
-      await userController.find(ctx);
-
-      expect(findPage).toHaveBeenCalled();
-      expect(sanitizeUser).toHaveBeenCalledTimes(2);
-      expect(ctx.body).toStrictEqual({ data: { results: users, pagination } });
-    });
-
-    test('Search all users', async () => {
-      const pagination = { page: 1, pageSize: 5, pageCount: 1, total: 2 };
-      const findPage = jest.fn(() => ({
-        results: users,
-        pagination,
-      }));
-
-      const state = {
-        userAbility: {
-          can: jest.fn(),
-          cannot: jest.fn(() => false),
-        },
-      };
-
-      const sanitizeUser = jest.fn((user) => user);
-      const ctx = createContext({ query: { _q: 'foo' } });
-
-      ctx.state = state;
-
-      const createPermissionsManager = jest.fn(() => ({
-        ability: state.userAbility,
-        sanitizeQuery: (query) => query,
-        validateQuery() {},
-      }));
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: { findPage, sanitizeUser },
-            permission: {
-              createPermissionsManager,
-            },
-          },
-        },
-      };
-
-      await userController.find(ctx);
-
-      expect(findPage).toHaveBeenCalled();
-      expect(sanitizeUser).toHaveBeenCalledTimes(2);
-      expect(ctx.body).toStrictEqual({ data: { results: users, pagination } });
-    });
-  });
-
-  describe('Update user', () => {
-    const user = {
-      id: 1,
-      firstname: 'Kai',
-      lastname: 'Doe',
-      email: 'kaidoe@email.com',
-      roles: [1, 2],
-    };
-
-    test('User not found', async () => {
-      const fakeId = 42;
-      const updateById = jest.fn(() => null);
-      const notFound = jest.fn();
-      const body = { username: 'Foo' };
-
-      const ctx = createContext({ params: { id: fakeId }, body }, { notFound });
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: { updateById },
-          },
-        },
-      };
-
-      await userController.update(ctx);
-
-      expect(updateById).toHaveReturnedWith(null);
-      expect(notFound).toHaveBeenCalledWith('User does not exist');
-    });
-
-    test('Validation error', async () => {
-      const body = { firstname: 21 };
-
-      const ctx = createContext({ params: { id: user.id }, body });
-
-      expect.assertions(2);
-
-      try {
-        await userController.update(ctx);
-      } catch (e) {
-        expect(e instanceof ApplicationError).toBe(true);
-        expect(e.message).toEqual(
-          'firstname must be a `string` type, but the final value was: `21`.'
-        );
-      }
-    });
-
-    test('Update a user correctly', async () => {
-      const updateById = jest.fn((_, input) => ({ ...user, ...input }));
-      const sanitizeUser = jest.fn((user) => user);
-      const body = { firstname: 'Foo' };
-
-      const ctx = createContext({ params: { id: user.id }, body });
-
-      global.strapi = {
-        admin: {
-          services: {
-            user: { updateById, sanitizeUser },
-          },
-        },
-      };
-
-      await userController.update(ctx);
-
-      expect(updateById).toHaveBeenCalledWith(user.id, body);
-      expect(sanitizeUser).toHaveBeenCalled();
-      expect(ctx.body).toStrictEqual({ data: { ...user, ...body } });
-    });
-  });
-});

package/server/controllers/admin.js

@@ -1,151 +0,0 @@
-'use strict';
-
-const path = require('path');
-
-const { map, values, sumBy, pipe, flatMap, propEq } = require('lodash/fp');
-const _ = require('lodash');
-const { exists } = require('fs-extra');
-const { env } = require('@strapi/utils');
-const { isUsingTypeScript } = require('@strapi/typescript-utils');
-// eslint-disable-next-line node/no-extraneous-require
-const ee = require('@strapi/strapi/dist/utils/ee');
-
-const {
-  validateUpdateProjectSettings,
-  validateUpdateProjectSettingsFiles,
-  validateUpdateProjectSettingsImagesDimensions,
-} = require('../validation/project-settings');
-const { getService } = require('../utils');
-
-/**
- * A set of functions called "actions" for `Admin`
- */
-
-module.exports = {
-  // TODO very temporary to check the switch ee/ce
-  // When removing this we need to update the /admin/src/index.js file
-  // where we set the strapi.window.isEE value
-  async getProjectType() {
-    const flags = strapi.config.get('admin.flags', {});
-    // FIXME
-    try {
-      return { data: { isEE: strapi.EE, features: ee.features.list(), flags } };
-    } catch (err) {
-      return { data: { isEE: false, features: [], flags } };
-    }
-  },
-
-  async init() {
-    let uuid = strapi.config.get('uuid', false);
-    const hasAdmin = await getService('user').exists();
-    const { menuLogo, authLogo } = await getService('project-settings').getProjectSettings();
-    // set to null if telemetryDisabled flag not avaialble in package.json
-    const telemetryDisabled = strapi.config.get('packageJsonStrapi.telemetryDisabled', null);
-
-    if (telemetryDisabled !== null && telemetryDisabled === true) {
-      uuid = false;
-    }
-
-    return {
-      data: {
-        uuid,
-        hasAdmin,
-        menuLogo: menuLogo ? menuLogo.url : null,
-        authLogo: authLogo ? authLogo.url : null,
-      },
-    };
-  },
-
-  async getProjectSettings() {
-    return getService('project-settings').getProjectSettings();
-  },
-
-  async updateProjectSettings(ctx) {
-    const projectSettingsService = getService('project-settings');
-
-    const {
-      request: { files, body },
-    } = ctx;
-
-    await validateUpdateProjectSettings(body);
-    await validateUpdateProjectSettingsFiles(files);
-
-    const formatedFiles = await projectSettingsService.parseFilesData(files);
-    await validateUpdateProjectSettingsImagesDimensions(formatedFiles);
-
-    return projectSettingsService.updateProjectSettings({ ...body, ...formatedFiles });
-  },
-
-  async telemetryProperties(ctx) {
-    // If the telemetry is disabled, ignore the request and return early
-    if (strapi.telemetry.isDisabled) {
-      ctx.status = 204;
-      return;
-    }
-
-    const useTypescriptOnServer = await isUsingTypeScript(strapi.dirs.app.root);
-    const useTypescriptOnAdmin = await isUsingTypeScript(
-      path.join(strapi.dirs.app.root, 'src', 'admin')
-    );
-    const isHostedOnStrapiCloud = env('STRAPI_HOSTING', null) === 'strapi.cloud';
-
-    const numberOfAllContentTypes = _.size(strapi.contentTypes);
-    const numberOfComponents = _.size(strapi.components);
-
-    const getNumberOfDynamicZones = () => {
-      return pipe(
-        map('attributes'),
-        flatMap(values),
-        sumBy(propEq('type', 'dynamiczone'))
-      )(strapi.contentTypes);
-    };
-
-    return {
-      data: {
-        useTypescriptOnServer,
-        useTypescriptOnAdmin,
-        isHostedOnStrapiCloud,
-        numberOfAllContentTypes, // TODO: V5: This event should be renamed numberOfContentTypes in V5 as the name is already taken to describe the number of content types using i18n.
-        numberOfComponents,
-        numberOfDynamicZones: getNumberOfDynamicZones(),
-      },
-    };
-  },
-
-  async information() {
-    const currentEnvironment = strapi.config.get('environment');
-    const autoReload = strapi.config.get('autoReload', false);
-    const strapiVersion = strapi.config.get('info.strapi', null);
-    const dependencies = strapi.config.get('info.dependencies', {});
-    const projectId = strapi.config.get('uuid', null);
-    const nodeVersion = process.version;
-    const communityEdition = !strapi.EE;
-    const useYarn = await exists(path.join(process.cwd(), 'yarn.lock'));
-
-    return {
-      data: {
-        currentEnvironment,
-        autoReload,
-        strapiVersion,
-        dependencies,
-        projectId,
-        nodeVersion,
-        communityEdition,
-        useYarn,
-      },
-    };
-  },
-
-  async plugins(ctx) {
-    const enabledPlugins = strapi.config.get('enabledPlugins');
-
-    const plugins = Object.entries(enabledPlugins).map(([key, plugin]) => ({
-      name: plugin.info.name || key,
-      displayName: plugin.info.displayName || plugin.info.name || key,
-      description: plugin.info.description || '',
-      packageName: plugin.info.packageName,
-    }));
-
-    ctx.send({ plugins });
-  },
-};

package/server/controllers/api-token.js

@@ -1,135 +0,0 @@
-'use strict';
-
-const {
-  stringEquals,
-  errors: { ApplicationError },
-} = require('@strapi/utils');
-const { trim, has } = require('lodash/fp');
-const { getService } = require('../utils');
-const {
-  validateApiTokenCreationInput,
-  validateApiTokenUpdateInput,
-} = require('../validation/api-tokens');
-
-module.exports = {
-  async create(ctx) {
-    const { body } = ctx.request;
-    const apiTokenService = getService('api-token');
-
-    /**
-     * We trim both field to avoid having issues with either:
-     * - having a space at the end or start of the value.
-     * - having only spaces as value;
-     */
-    const attributes = {
-      name: trim(body.name),
-      description: trim(body.description),
-      type: body.type,
-      permissions: body.permissions,
-      lifespan: body.lifespan,
-    };
-
-    await validateApiTokenCreationInput(attributes);
-
-    const alreadyExists = await apiTokenService.exists({ name: attributes.name });
-    if (alreadyExists) {
-      throw new ApplicationError('Name already taken');
-    }
-
-    const apiToken = await apiTokenService.create(attributes);
-    ctx.created({ data: apiToken });
-  },
-
-  async regenerate(ctx) {
-    const { id } = ctx.params;
-    const apiTokenService = getService('api-token');
-
-    const apiTokenExists = await apiTokenService.getById(id);
-    if (!apiTokenExists) {
-      ctx.notFound('API Token not found');
-      return;
-    }
-
-    const accessToken = await apiTokenService.regenerate(id);
-
-    ctx.created({ data: accessToken });
-  },
-
-  async list(ctx) {
-    const apiTokenService = getService('api-token');
-    const apiTokens = await apiTokenService.list();
-
-    ctx.send({ data: apiTokens });
-  },
-
-  async revoke(ctx) {
-    const { id } = ctx.params;
-    const apiTokenService = getService('api-token');
-    const apiToken = await apiTokenService.revoke(id);
-
-    ctx.deleted({ data: apiToken });
-  },
-
-  async get(ctx) {
-    const { id } = ctx.params;
-    const apiTokenService = getService('api-token');
-    const apiToken = await apiTokenService.getById(id);
-
-    if (!apiToken) {
-      ctx.notFound('API Token not found');
-      return;
-    }
-
-    ctx.send({ data: apiToken });
-  },
-
-  async update(ctx) {
-    const { body } = ctx.request;
-    const { id } = ctx.params;
-    const apiTokenService = getService('api-token');
-
-    const attributes = body;
-    /**
-     * We trim both field to avoid having issues with either:
-     * - having a space at the end or start of the value.
-     * - having only spaces as value;
-     */
-    if (has('name', attributes)) {
-      attributes.name = trim(body.name);
-    }
-
-    if (has('description', attributes) || attributes.description === null) {
-      attributes.description = trim(body.description);
-    }
-
-    await validateApiTokenUpdateInput(attributes);
-
-    const apiTokenExists = await apiTokenService.getById(id);
-    if (!apiTokenExists) {
-      return ctx.notFound('API Token not found');
-    }
-
-    if (has('name', attributes)) {
-      const nameAlreadyTaken = await apiTokenService.getByName(attributes.name);
-
-      /**
-       * We cast the ids as string as the one coming from the ctx isn't cast
-       * as a Number in case it is supposed to be an integer. It remains
-       * as a string. This way we avoid issues with integers in the db.
-       */
-      if (!!nameAlreadyTaken && !stringEquals(nameAlreadyTaken.id, id)) {
-        throw new ApplicationError('Name already taken');
-      }
-    }
-
-    const apiToken = await apiTokenService.update(id, attributes);
-    ctx.send({ data: apiToken });
-  },
-
-  async getLayout(ctx) {
-    const apiTokenService = getService('api-token');
-    const layout = await apiTokenService.getApiTokenLayout();
-
-    ctx.send({ data: layout });
-  },
-};

package/server/controllers/authenticated-user.js

@@ -1,52 +0,0 @@
-'use strict';
-
-const { validateProfileUpdateInput } = require('../validation/user');
-const { getService } = require('../utils');
-
-module.exports = {
-  async getMe(ctx) {
-    const userInfo = getService('user').sanitizeUser(ctx.state.user);
-
-    ctx.body = {
-      data: userInfo,
-    };
-  },
-
-  async updateMe(ctx) {
-    const input = ctx.request.body;
-
-    await validateProfileUpdateInput(input);
-
-    const userService = getService('user');
-    const authServer = getService('auth');
-
-    const { currentPassword, ...userInfo } = input;
-
-    if (currentPassword && userInfo.password) {
-      const isValid = await authServer.validatePassword(currentPassword, ctx.state.user.password);
-
-      if (!isValid) {
-        return ctx.badRequest('ValidationError', {
-          currentPassword: ['Invalid credentials'],
-        });
-      }
-    }
-
-    const updatedUser = await userService.updateById(ctx.state.user.id, userInfo);
-
-    ctx.body = {
-      data: userService.sanitizeUser(updatedUser),
-    };
-  },
-
-  async getOwnPermissions(ctx) {
-    const { findUserPermissions, sanitizePermission } = getService('permission');
-    const { user } = ctx.state;
-
-    const userPermissions = await findUserPermissions(user);
-
-    ctx.body = {
-      data: userPermissions.map(sanitizePermission),
-    };
-  },
-};