OV-3: add sign up flow

backend/src/bundles/auth/auth.controller.ts

@@ -53,6 +53,8 @@ class AuthController extends BaseController {
      *                  format: email
      *                password:
      *                  type: string
+     *                name:
+     *                  type: string
      *      responses:
      *        201:
      *          description: Successful operation

backend/src/bundles/users/user.entity.ts

@@ -5,58 +5,69 @@ class UserEntity implements Entity {
 
     private 'email': string;
 
+    private 'name': string;
+
     private 'passwordHash': string;
 
     private 'passwordSalt': string;
 
     private constructor({
         id,
         email,
+        name,
         passwordHash,
         passwordSalt,
     }: {
         id: number | null;
         email: string;
+        name: string;
         passwordHash: string;
         passwordSalt: string;
     }) {
         this.id = id;
         this.email = email;
+        this.name = name;
         this.passwordHash = passwordHash;
         this.passwordSalt = passwordSalt;
     }
 
     public static initialize({
         id,
         email,
+        name,
         passwordHash,
         passwordSalt,
     }: {
         id: number;
         email: string;
+        name: string;
         passwordHash: string;
         passwordSalt: string;
     }): UserEntity {
         return new UserEntity({
             id,
             email,
+            name,
             passwordHash,
             passwordSalt,
         });
     }
 
     public static initializeNew({
         email,
+        name,
         passwordHash,
         passwordSalt,
     }: {
         email: string;
+        name: string;
         passwordHash: string;
         passwordSalt: string;
     }): UserEntity {
         return new UserEntity({
             id: null,
             email,
+            name,
             passwordHash,
             passwordSalt,
         });
@@ -65,20 +76,24 @@ class UserEntity implements Entity {
     public toObject(): {
         id: number;
         email: string;
+        name: string;
     } {
         return {
             id: this.id as number,
             email: this.email,
+            name: this.name,
         };
     }
 
     public toNewObject(): {
         email: string;
+        name: string;
         passwordHash: string;
         passwordSalt: string;
     } {
         return {
             email: this.email,
+            name: this.name,
             passwordHash: this.passwordHash,
             passwordSalt: this.passwordSalt,
         };

backend/src/bundles/users/user.model.ts

@@ -6,6 +6,8 @@ import {
 class UserModel extends AbstractModel {
     public 'email': string;
 
+    public 'name': string;
+
     public 'passwordHash': string;
 
     public 'passwordSalt': string;

backend/src/bundles/users/user.repository.ts

@@ -20,12 +20,14 @@ class UserRepository implements Repository {
     }
 
     public async create(entity: UserEntity): Promise<UserEntity> {
-        const { email, passwordSalt, passwordHash } = entity.toNewObject();
+        const { email, name, passwordSalt, passwordHash } =
+            entity.toNewObject();
 
         const item = await this.userModel
             .query()
             .insert({
                 email,
+                name,
                 passwordSalt,
                 passwordHash,
             })

backend/src/bundles/users/user.service.ts

@@ -35,8 +35,9 @@ class UserService implements Service {
         const user = await this.userRepository.create(
             UserEntity.initializeNew({
                 email: payload.email,
-                passwordSalt: salt, // TODO
-                passwordHash: hash, // TODO
+                name: payload.name,
+                passwordSalt: salt,
+                passwordHash: hash,
             }),
         );
 

backend/src/migrations/20240820093010_add_name_field_to_users_table.ts

@@ -0,0 +1,17 @@
+import { type Knex } from 'knex';
+
+const TABLE_NAME = 'users';
+
+async function up(knex: Knex): Promise<void> {
+    await knex.schema.table(TABLE_NAME, (table) => {
+        table.string('name').notNullable();
+    });
+}
+
+async function down(knex: Knex): Promise<void> {
+    await knex.schema.table(TABLE_NAME, (table) => {
+        table.dropColumn('name');
+    });
+}
+
+export { down, up };

frontend/src/bundles/auth/components/sign-up-form/constants/constants.ts

@@ -1,8 +1,10 @@
 import { type UserSignUpRequestDto } from '~/bundles/users/users.js';
 
 const DEFAULT_SIGN_UP_PAYLOAD: UserSignUpRequestDto = {
+    name: '',
     email: '',
     password: '',
+    confirmPassword: '',
 };
 
 export { DEFAULT_SIGN_UP_PAYLOAD };

shared/src/bundles/users/enums/user-validation-message.enum.ts

@@ -1,6 +1,10 @@
 const UserValidationMessage = {
-    EMAIL_REQUIRE: 'Email is required',
-    EMAIL_WRONG: 'Email is wrong',
+    FIELD_IS_REQUIRE: 'Please fill out this field',
+    EMAIL_WRONG: 'Please enter a valid email',
+    PASS_DONT_MATCH: 'Passwords must be identical',
+    PASS_WRONG: 'Password must have from 6 to 12 characters',
+    USER_IS_NOT_AVAILABLE:
+        'User with this email already exists. Log in if it is you',
 } as const;
 
 export { UserValidationMessage };

shared/src/bundles/users/enums/user-validation-rule.enum.ts

@@ -1,5 +1,8 @@
 const UserValidationRule = {
     EMAIL_MINIMUM_LENGTH: 1,
+    EMAIL_MAXIMUM_LENGTH: 320,
+    PASSWORD_MINIMUM_LENGTH: 6,
+    PASSWORD_MAXIMUM_LENGTH: 12,
 } as const;
 
 export { UserValidationRule };

shared/src/bundles/users/types/user-sign-up-request-dto.type.ts

@@ -1,6 +1,8 @@
 type UserSignUpRequestDto = {
+    name: string;
     email: string;
     password: string;
+    confirmPassword: string;
 };
 
 export { type UserSignUpRequestDto };

shared/src/bundles/users/types/user-sign-up-response-dto.type.ts

@@ -1,5 +1,6 @@
 type UserSignUpResponseDto = {
     id: number;
+    name: string;
     email: string;
 };
 

shared/src/bundles/users/validation-schemas/user-sign-up.validation-schema.ts

@@ -3,23 +3,50 @@ import { z } from 'zod';
 import { UserValidationMessage, UserValidationRule } from '../enums/enums.js';
 
 type UserSignUpRequestValidationDto = {
+    name: z.ZodString;
     email: z.ZodString;
     password: z.ZodString;
+    confirmPassword: z.ZodString;
 };
 
 const userSignUp = z
     .object<UserSignUpRequestValidationDto>({
+        name: z.string().trim(),
         email: z
             .string()
             .trim()
             .min(UserValidationRule.EMAIL_MINIMUM_LENGTH, {
-                message: UserValidationMessage.EMAIL_REQUIRE,
+                message: UserValidationMessage.EMAIL_WRONG,
+            })
+            .max(UserValidationRule.EMAIL_MAXIMUM_LENGTH, {
+                message: UserValidationMessage.EMAIL_WRONG,
             })
             .email({
                 message: UserValidationMessage.EMAIL_WRONG,
             }),
-        password: z.string().trim(),
+        password: z
+            .string()
+            .trim()
+            .min(UserValidationRule.PASSWORD_MINIMUM_LENGTH, {
+                message: UserValidationMessage.PASS_WRONG,
+            })
+            .max(UserValidationRule.PASSWORD_MAXIMUM_LENGTH, {
+                message: UserValidationMessage.PASS_WRONG,
+            }),
+        confirmPassword: z
+            .string()
+            .trim()
+            .min(UserValidationRule.PASSWORD_MINIMUM_LENGTH, {
+                message: UserValidationMessage.PASS_WRONG,
+            })
+            .max(UserValidationRule.PASSWORD_MAXIMUM_LENGTH, {
+                message: UserValidationMessage.PASS_WRONG,
+            }),
     })
-    .required();
+    .required()
+    .refine((data) => data.password === data.confirmPassword, {
+        message: UserValidationMessage.PASS_DONT_MATCH,
+        path: ['confirmPassword'],
+    });
 
 export { userSignUp };