feat: Implement rest API endpoint for admins to create user

packages/backend/src/controllers/api/v1/admin/users/create-user.js

@@ -0,0 +1,22 @@
+import { renderObject } from '../../../../../helpers/renderer.js';
+import User from '../../../../../models/user.js';
+import Role from '../../../../../models/role.js';
+
+export default async (request, response) => {
+  const user = await User.query().insertAndFetch(await userParams(request));
+  await user.sendInvitationEmail();
+
+  renderObject(response, user, { status: 201 });
+};
+
+const userParams = async (request) => {
+  const { fullName, email } = request.body;
+  const roleId = request.body.roleId || (await Role.findAdmin()).id;
+
+  return {
+    fullName,
+    status: 'invited',
+    email: email?.toLowerCase(),
+    roleId,
+  };
+};

packages/backend/src/controllers/api/v1/admin/users/create-user.test.js

@@ -0,0 +1,122 @@
+import { describe, beforeEach, it, expect } from 'vitest';
+import request from 'supertest';
+import app from '../../../../../app.js';
+import createAuthTokenByUserId from '../../../../../helpers/create-auth-token-by-user-id.js';
+import User from '../../../../../models/user.js';
+import Role from '../../../../../models/role.js';
+import { createUser } from '../../../../../../test/factories/user.js';
+import { createRole } from '../../../../../../test/factories/role.js';
+import createUserMock from '../../../../../../test/mocks/rest/api/v1/users/create-user.js';
+
+describe('POST /api/v1/admin/users', () => {
+  let currentUser, adminRole, token;
+
+  beforeEach(async () => {
+    adminRole = await createRole({ name: 'Admin' });
+    currentUser = await createUser({ roleId: adminRole.id });
+
+    token = await createAuthTokenByUserId(currentUser.id);
+  });
+
+  it('should return created user with valid data', async () => {
+    const userRole = await createRole({ name: 'User' });
+
+    const userData = {
+      email: 'created@sample.com',
+      fullName: 'Full Name',
+      password: 'samplePassword123',
+      roleId: userRole.id,
+    };
+
+    const response = await request(app)
+      .post('/api/v1/admin/users')
+      .set('Authorization', token)
+      .send(userData)
+      .expect(201);
+
+    const refetchedRegisteredUser = await User.query()
+      .findById(response.body.data.id)
+      .throwIfNotFound();
+
+    const expectedPayload = createUserMock(refetchedRegisteredUser);
+
+    expect(response.body).toStrictEqual(expectedPayload);
+    expect(refetchedRegisteredUser.roleId).toStrictEqual(userRole.id);
+  });
+
+  it('should create user with admin role if there is no role id given', async () => {
+    const userData = {
+      email: 'created@sample.com',
+      fullName: 'Full Name',
+      password: 'samplePassword123',
+    };
+
+    const response = await request(app)
+      .post('/api/v1/admin/users')
+      .set('Authorization', token)
+      .send(userData)
+      .expect(201);
+
+    const refetchedRegisteredUser = await User.query()
+      .findById(response.body.data.id)
+      .throwIfNotFound();
+
+    const refetchedUserRole = await Role.query().findById(
+      refetchedRegisteredUser.roleId
+    );
+
+    const expectedPayload = createUserMock(refetchedRegisteredUser);
+
+    expect(response.body).toStrictEqual(expectedPayload);
+    expect(refetchedUserRole.name).toStrictEqual('Admin');
+  });
+
+  it('should return unprocessable entity response with already used email', async () => {
+    await createRole({ name: 'User' });
+
+    await createUser({
+      email: 'created@sample.com',
+    });
+
+    const userData = {
+      email: 'created@sample.com',
+      fullName: 'Full Name',
+      password: 'samplePassword123',
+    };
+
+    const response = await request(app)
+      .post('/api/v1/admin/users')
+      .set('Authorization', token)
+      .send(userData)
+      .expect(422);
+
+    expect(response.body.errors).toStrictEqual({
+      email: ["'email' must be unique."],
+    });
+
+    expect(response.body.meta).toStrictEqual({
+      type: 'UniqueViolationError',
+    });
+  });
+
+  it('should return unprocessable entity response with invalid user data', async () => {
+    await createRole({ name: 'User' });
+
+    const userData = {
+      email: null,
+      fullName: null,
+    };
+
+    const response = await request(app)
+      .post('/api/v1/admin/users')
+      .set('Authorization', token)
+      .send(userData)
+      .expect(422);
+
+    expect(response.body.meta.type).toStrictEqual('ModelValidation');
+    expect(response.body.errors).toStrictEqual({
+      email: ["must have required property 'email'"],
+      fullName: ['must be string'],
+    });
+  });
+});

packages/backend/src/models/user.js

@@ -230,7 +230,10 @@ class User extends Base {
     const invitationToken = crypto.randomBytes(64).toString('hex');
     const invitationTokenSentAt = new Date().toISOString();
 
-    await this.$query().patch({ invitationToken, invitationTokenSentAt });
+    await this.$query().patchAndFetch({
+      invitationToken,
+      invitationTokenSentAt,
+    });
   }
 
   async resetPassword(password) {
@@ -355,6 +358,30 @@ class User extends Base {
     return now.getTime() - sentAt.getTime() < fourHoursInMilliseconds;
   }
 
+  async sendInvitationEmail() {
+    await this.generateInvitationToken();
+
+    const jobName = `Invitation Email - ${this.id}`;
+    const acceptInvitationUrl = `${appConfig.webAppUrl}/accept-invitation?token=${this.invitationToken}`;
+
+    const jobPayload = {
+      email: this.email,
+      subject: 'You are invited!',
+      template: 'invitation-instructions',
+      params: {
+        fullName: this.fullName,
+        acceptInvitationUrl,
+      },
+    };
+
+    const jobOptions = {
+      removeOnComplete: REMOVE_AFTER_7_DAYS_OR_50_JOBS,
+      removeOnFail: REMOVE_AFTER_30_DAYS_OR_150_JOBS,
+    };
+
+    await emailQueue.add(jobName, jobPayload, jobOptions);
+  }
+
   isInvitationTokenValid() {
     if (!this.invitationTokenSentAt) {
       return false;

packages/backend/src/routes/api/v1/admin/users.ee.js

@@ -2,6 +2,7 @@ import { Router } from 'express';
 import { authenticateUser } from '../../../../helpers/authentication.js';
 import { authorizeAdmin } from '../../../../helpers/authorization.js';
 import getUsersAction from '../../../../controllers/api/v1/admin/users/get-users.ee.js';
+import createUserAction from '../../../../controllers/api/v1/admin/users/create-user.js';
 import getUserAction from '../../../../controllers/api/v1/admin/users/get-user.ee.js';
 import updateUserAction from '../../../../controllers/api/v1/admin/users/update-user.ee.js';
 import deleteUserAction from '../../../../controllers/api/v1/admin/users/delete-user.js';
@@ -9,6 +10,7 @@ import deleteUserAction from '../../../../controllers/api/v1/admin/users/delete-
 const router = Router();
 
 router.get('/', authenticateUser, authorizeAdmin, getUsersAction);
+router.post('/', authenticateUser, authorizeAdmin, createUserAction);
 router.get('/:userId', authenticateUser, authorizeAdmin, getUserAction);
 router.patch('/:userId', authenticateUser, authorizeAdmin, updateUserAction);
 router.delete('/:userId', authenticateUser, authorizeAdmin, deleteUserAction);

packages/backend/test/mocks/rest/api/v1/users/create-user.js

@@ -0,0 +1,29 @@
+import appConfig from '../../../../../../src/config/app.js';
+
+const createUserMock = (user) => {
+  const userData = {
+    createdAt: user.createdAt.getTime(),
+    email: user.email,
+    fullName: user.fullName,
+    id: user.id,
+    status: user.status,
+    updatedAt: user.updatedAt.getTime(),
+  };
+
+  if (appConfig.isCloud && user.trialExpiryDate) {
+    userData.trialExpiryDate = user.trialExpiryDate.toISOString();
+  }
+
+  return {
+    data: userData,
+    meta: {
+      count: 1,
+      currentPage: null,
+      isArray: false,
+      totalPages: null,
+      type: 'User',
+    },
+  };
+};
+
+export default createUserMock;