@strapi/strapi 4.10.0-beta.1 → 4.10.1-experimental.0

package/lib/commands/actions/admin/create-user/__tests__/admin.create-user.test.js

@@ -0,0 +1,450 @@
+'use strict';
+
+const roleId = 1;
+const load = jest.fn(() => mock);
+
+const create = jest.fn();
+const getSuperAdmin = jest.fn(() => Promise.resolve({ id: roleId }));
+const exists = jest.fn();
+
+const admin = {
+  services: {
+    user: {
+      create,
+      exists,
+    },
+    role: {
+      getSuperAdmin,
+    },
+  },
+};
+
+const mock = {
+  load,
+  admin,
+};
+
+jest.mock('@strapi/strapi', () => {
+  const impl = jest.fn(() => mock);
+
+  impl.compile = jest.fn();
+
+  return impl;
+});
+
+const inquirer = require('inquirer');
+const createAdminCommand = require('../action');
+
+describe('admin:create command', () => {
+  beforeEach(() => {
+    load.mockClear();
+    create.mockClear();
+    getSuperAdmin.mockClear();
+  });
+
+  test('createAdminCommand accepts direct input', async () => {
+    const email = 'email@email.fr';
+    const password = 'testPasword1234';
+    const firstname = 'John';
+    const lastname = 'Doe';
+
+    const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+    const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+    await createAdminCommand({ email, password, firstname, lastname });
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+    expect(consoleLog).toHaveBeenCalled();
+    expect(load).toHaveBeenCalled();
+    expect(getSuperAdmin).toHaveBeenCalled();
+    expect(create).toHaveBeenCalledWith(
+      expect.objectContaining({ email, password, firstname, lastname })
+    );
+
+    mockExit.mockRestore();
+    consoleLog.mockRestore();
+  });
+
+  describe('Handles prompt input', () => {
+    test('Only prompt on TTY', async () => {
+      const tmpTTY = process.stdin.isTTY;
+      process.stdin.isTTY = false;
+
+      // throw so the code will stop executing
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('First name is required');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(load).not.toHaveBeenCalled();
+      expect(getSuperAdmin).not.toHaveBeenCalled();
+      expect(create).not.toHaveBeenCalled();
+
+      process.stdin.isTTY = tmpTTY;
+      mockExit.mockRestore();
+      consoleError.mockRestore();
+    });
+
+    test('Stops if not confirmed', async () => {
+      process.stdin.isTTY = true;
+      const email = 'email@email.fr';
+      const password = 'testPasword1234';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: false,
+      }));
+
+      // throw so the code will stop executing
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(mockInquiry).toHaveBeenLastCalledWith([
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'email',
+          type: 'input',
+        }),
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'password',
+          type: 'password',
+        }),
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'firstname',
+          type: 'input',
+        }),
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'lastname',
+          type: 'input',
+        }),
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'confirm',
+          type: 'confirm',
+        }),
+      ]);
+      expect(mockExit).toHaveBeenCalledWith(0);
+      expect(load).not.toHaveBeenCalled();
+      expect(getSuperAdmin).not.toHaveBeenCalled();
+      expect(create).not.toHaveBeenCalled();
+
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+    });
+
+    test('Calls the create method with user input', async () => {
+      const email = 'email@email.fr';
+      const password = 'testPasword1234';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+      const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+      await createAdminCommand();
+
+      expect(mockExit).toHaveBeenCalledWith(0);
+      expect(consoleLog).toHaveBeenCalled();
+      expect(load).toHaveBeenCalled();
+      expect(getSuperAdmin).toHaveBeenCalled();
+      expect(create).toHaveBeenCalledWith(
+        expect.objectContaining({ email, password, firstname, lastname })
+      );
+
+      mockInquiry.mockRestore();
+      mockExit.mockRestore();
+      consoleLog.mockRestore();
+    });
+
+    test('Creates registration token if password is not passed', async () => {
+      const email = 'email@email.fr';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+      const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      await createAdminCommand();
+
+      expect(getSuperAdmin).toHaveBeenCalled();
+      expect(create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          email,
+          firstname,
+          lastname,
+        })
+      );
+      expect.not.objectContaining({ password: expect.any(String), registrationToken: null });
+
+      mockInquiry.mockRestore();
+      mockExit.mockRestore();
+      consoleLog.mockRestore();
+    });
+
+    test('Sets registration token to null if password is passed', async () => {
+      const email = 'email@email.fr';
+      const password = 'testPasword1234';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+      const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      await createAdminCommand();
+
+      expect(getSuperAdmin).toHaveBeenCalled();
+      expect(create).toHaveBeenCalledWith(
+        expect.objectContaining({ email, password, firstname, lastname, registrationToken: null })
+      );
+
+      mockInquiry.mockRestore();
+      mockExit.mockRestore();
+      consoleLog.mockRestore();
+    });
+
+    test('Stops if the user already exists', async () => {
+      exists.mockImplementation(() => Promise.resolve(true));
+
+      const email = 'email@email.fr';
+      const password = 'testPasword1234';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('User with email "email@email.fr" already exists');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(exists).toHaveBeenCalledWith(expect.objectContaining({ email }));
+      expect(getSuperAdmin).not.toHaveBeenCalled();
+      expect(create).not.toHaveBeenCalled();
+
+      exists.mockRestore();
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+      consoleError.mockRestore();
+    });
+  });
+
+  describe('Validation', () => {
+    test('Handles invalid email', async () => {
+      const email = 'email.@email.fr';
+      const password = 'testPasword1234';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('Invalid email address');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(load).not.toHaveBeenCalled();
+
+      exists.mockRestore();
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+      consoleError.mockRestore();
+    });
+
+    test('Handles short passwords', async () => {
+      const email = 'email.@email.fr';
+      const password = '123';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('Password must be at least 8 characters long');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(load).not.toHaveBeenCalled();
+
+      exists.mockRestore();
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+      consoleError.mockRestore();
+    });
+
+    test('Handles passwords without lowercase characters', async () => {
+      const email = 'email.@email.fr';
+      const password = '12345678';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('Password must contain at least one lowercase character');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(load).not.toHaveBeenCalled();
+
+      exists.mockRestore();
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+      consoleError.mockRestore();
+    });
+
+    test('Handles passwords without uppercase characters', async () => {
+      const email = 'email.@email.fr';
+      const password = '1234567a';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('Password must contain at least one uppercase character');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(load).not.toHaveBeenCalled();
+
+      exists.mockRestore();
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+      consoleError.mockRestore();
+    });
+
+    test('Handles passwords without number', async () => {
+      const email = 'email.@email.fr';
+      const password = 'abcdefgH';
+      const firstname = 'John';
+      const lastname = 'Doe';
+
+      const mockInquiry = jest.spyOn(inquirer, 'prompt').mockImplementationOnce(async () => ({
+        email,
+        password,
+        firstname,
+        lastname,
+        confirm: true,
+      }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await createAdminCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('Password must contain at least one number');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(load).not.toHaveBeenCalled();
+
+      exists.mockRestore();
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+      consoleError.mockRestore();
+    });
+  });
+});

package/lib/commands/{admin-create.js → actions/admin/create-user/action.js}

@@ -3,7 +3,7 @@
 const { yup } = require('@strapi/utils');
 const _ = require('lodash');
 const inquirer = require('inquirer');
-const strapi = require('../index');
+const strapi = require('../../../../index');
 
 const emailValidator = yup.string().email('Invalid email address').lowercase();
 
@@ -57,7 +57,7 @@ const promptQuestions = [
  * @param {string} cmdOptions.firstname - new admin's first name
  * @param {string} [cmdOptions.lastname] - new admin's last name
  */
-module.exports = async function (cmdOptions = {}) {
+module.exports = async (cmdOptions = {}) => {
   let { email, password, firstname, lastname } = cmdOptions;
 
   if (

package/lib/commands/actions/admin/create-user/command.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi admin:create-user`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('admin:create-user')
+    .alias('admin:create')
+    .description('Create a new admin')
+    .option('-e, --email <email>', 'Email of the new admin')
+    .option('-p, --password <password>', 'Password of the new admin')
+    .option('-f, --firstname <first name>', 'First name of the new admin')
+    .option('-l, --lastname <last name>', 'Last name of the new admin')
+    .action(getLocalScript('admin/create-user'));
+};

package/lib/commands/actions/admin/reset-user-password/__tests__/admin.reset-user-password.test.js

@@ -0,0 +1,145 @@
+'use strict';
+
+const load = jest.fn(() => mock);
+const resetPasswordByEmail = jest.fn();
+const admin = {
+  services: {
+    user: {
+      resetPasswordByEmail,
+    },
+  },
+};
+
+const mock = {
+  load,
+  admin,
+};
+
+jest.mock('@strapi/strapi', () => {
+  const impl = jest.fn(() => mock);
+
+  impl.compile = jest.fn();
+
+  return impl;
+});
+
+const inquirer = require('inquirer');
+const resetAdminPasswordCommand = require('../action');
+
+describe('admin:reset-password command', () => {
+  beforeEach(() => {
+    load.mockClear();
+    resetPasswordByEmail.mockClear();
+  });
+
+  test('resetAdminPasswordCommand accepts direct input', async () => {
+    const email = 'email@email.fr';
+    const password = 'testPasword1234';
+
+    const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+    const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+    await resetAdminPasswordCommand({ email, password });
+
+    expect(mockExit).toHaveBeenCalledWith(0);
+    expect(consoleLog).toHaveBeenCalled();
+    expect(load).toHaveBeenCalled();
+    expect(resetPasswordByEmail).toHaveBeenCalledWith(email, password);
+
+    mockExit.mockRestore();
+    consoleLog.mockRestore();
+  });
+
+  describe('Handles prompt input', () => {
+    test('Only prompt on TTY', async () => {
+      const tmpTTY = process.stdin.isTTY;
+      process.stdin.isTTY = false;
+
+      // throw so the code will stop executing
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+
+      const consoleError = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+      await resetAdminPasswordCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(consoleError).toBeCalledWith('Missing required options `email` or `password`');
+      expect(mockExit).toHaveBeenCalledWith(1);
+      expect(load).not.toHaveBeenCalled();
+      expect(resetPasswordByEmail).not.toHaveBeenCalled();
+
+      process.stdin.isTTY = tmpTTY;
+      mockExit.mockRestore();
+      consoleError.mockRestore();
+    });
+
+    test('Stops if not confirmed', async () => {
+      process.stdin.isTTY = true;
+      const email = 'email@email.fr';
+      const password = 'testPasword1234';
+
+      const mockInquiry = jest
+        .spyOn(inquirer, 'prompt')
+        .mockImplementationOnce(async () => ({ email, password, confirm: false }));
+
+      // throw so the code will stop executing
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {
+        throw new Error('exit');
+      });
+
+      await resetAdminPasswordCommand().catch((err) => {
+        expect(err).toEqual(new Error('exit'));
+      });
+
+      expect(mockInquiry).toHaveBeenLastCalledWith([
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'email',
+          type: 'input',
+        }),
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'password',
+          type: 'password',
+        }),
+        expect.objectContaining({
+          message: expect.any(String),
+          name: 'confirm',
+          type: 'confirm',
+        }),
+      ]);
+      expect(mockExit).toHaveBeenCalledWith(0);
+      expect(load).not.toHaveBeenCalled();
+      expect(resetPasswordByEmail).not.toHaveBeenCalled();
+
+      mockExit.mockRestore();
+      mockInquiry.mockRestore();
+    });
+
+    test('Calls the reset method with user input', async () => {
+      const email = 'email@email.fr';
+      const password = 'testPasword1234';
+
+      const mockInquiry = jest
+        .spyOn(inquirer, 'prompt')
+        .mockImplementationOnce(async () => ({ email, password, confirm: true }));
+
+      const mockExit = jest.spyOn(process, 'exit').mockImplementation(() => {});
+      const consoleLog = jest.spyOn(console, 'log').mockImplementation(() => {});
+
+      await resetAdminPasswordCommand();
+
+      expect(mockExit).toHaveBeenCalledWith(0);
+      expect(consoleLog).toHaveBeenCalled();
+      expect(load).toHaveBeenCalled();
+      expect(resetPasswordByEmail).toHaveBeenCalledWith(email, password);
+
+      mockInquiry.mockRestore();
+      mockExit.mockRestore();
+      consoleLog.mockRestore();
+    });
+  });
+});

package/lib/commands/{admin-reset.js → actions/admin/reset-user-password/action.js}

@@ -2,7 +2,7 @@
 
 const _ = require('lodash');
 const inquirer = require('inquirer');
-const strapi = require('../index');
+const strapi = require('../../../../index');
 
 const promptQuestions = [
   { type: 'input', name: 'email', message: 'User email?' },
@@ -20,7 +20,7 @@ const promptQuestions = [
  * @param {string} cmdOptions.email - user's email
  * @param {string} cmdOptions.password - user's new password
  */
-module.exports = async function (cmdOptions = {}) {
+module.exports = async (cmdOptions = {}) => {
   const { email, password } = cmdOptions;
 
   if (_.isEmpty(email) && _.isEmpty(password) && process.stdin.isTTY) {

package/lib/commands/actions/admin/reset-user-password/command.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const { getLocalScript } = require('../../../utils/helpers');
+
+/**
+ * `$ strapi admin:reset-user-password`
+ * @param {import('../../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('admin:reset-user-password')
+    .alias('admin:reset-password')
+    .description("Reset an admin user's password")
+    .option('-e, --email <email>', 'The user email')
+    .option('-p, --password <password>', 'New password for the user')
+    .action(getLocalScript('admin/reset-user-password'));
+};

package/lib/commands/{build.js → actions/build/action.js}

@@ -1,7 +1,7 @@
 'use strict';
 
-const strapi = require('..');
-const { buildAdmin } = require('./builders');
+const strapi = require('../../..');
+const { buildAdmin } = require('../../builders');
 
 /**
  * `$ strapi build`

package/lib/commands/actions/build/command.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const { getLocalScript } = require('../../utils/helpers');
+
+/**
+ * `$ strapi build`
+ * @param {import('../../../types/core/commands').AddCommandOptions} options
+ */
+module.exports = ({ command }) => {
+  command
+    .command('build')
+    .option('--no-optimization', 'Build the admin app without optimizing assets')
+    .description('Build the strapi admin app')
+    .action(getLocalScript('build'));
+};