Feature/local register

package.json

@@ -14,7 +14,7 @@
     "start:debug": "nest start --debug --watch",
     "start:prod": "node dist/main",
     "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
-    "test": "jest",
+    "test": "jest --verbose",
     "test:watch": "jest --watch",
     "test:cov": "jest --coverage",
     "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
@@ -39,6 +39,7 @@
     "@nestjs/platform-express": "^9.0.0",
     "@nestjs/swagger": "^6.1.4",
     "@nestjs/typeorm": "^9.0.1",
+    "bcrypt": "^5.1.0",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.0",
     "dotenv": "^16.0.3",
@@ -71,6 +72,7 @@
     "lint-staged": "^13.1.0",
     "prettier": "^2.3.2",
     "source-map-support": "^0.5.20",
+    "sqlite3": "^5.1.6",
     "supertest": "^6.1.3",
     "ts-jest": "28.0.8",
     "ts-loader": "^9.2.3",
@@ -93,6 +95,9 @@
       "**/*.(t|j)s"
     ],
     "coverageDirectory": "../coverage",
-    "testEnvironment": "node"
+    "testEnvironment": "node",
+    "moduleNameMapper": {
+      "src/(.*)$": "<rootDir>/$1"
+    }
   }
 }

src/app.module.ts

@@ -4,15 +4,19 @@ import { TypeOrmModule } from "@nestjs/typeorm";
 
 import { AppController } from "./app.controller";
 import { AppService } from "./app.service";
+import { AuthModule } from "./auth/auth.module";
 import { dataSourceOptions } from "./config/data-source";
 import { validate } from "./config/env.validation";
+import { UserModule } from "./user/user.module";
 
 @Module({
   imports: [
     ConfigModule.forRoot({
       validate,
     }),
     TypeOrmModule.forRoot(dataSourceOptions),
+    UserModule,
+    AuthModule,
   ],
   controllers: [AppController],
   providers: [AppService],

src/auth/auth.controller.spec.ts

@@ -0,0 +1,79 @@
+import { ConflictException } from "@nestjs/common";
+import { Test, TestingModule } from "@nestjs/testing";
+import { getRepositoryToken, TypeOrmModule } from "@nestjs/typeorm";
+import { dataSourceJest } from "src/config/data-source";
+import { UserEntity } from "src/user/entities/user.entity";
+import { CreateUserRespose } from "src/user/resposes/create-user-respose";
+import { UserService } from "src/user/user.service";
+import { Repository } from "typeorm";
+
+import { CreateUserDto } from "../user/dto/create-user.dto";
+import { AuthController } from "./auth.controller";
+import { AuthService } from "./auth.service";
+
+describe("AuthController", () => {
+  let authController: AuthController;
+  let authService: AuthService;
+  let userRepository: Repository<UserEntity>;
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [TypeOrmModule.forRoot(dataSourceJest)],
+      controllers: [AuthController],
+      providers: [
+        AuthService,
+        UserService,
+        {
+          provide: getRepositoryToken(UserEntity),
+          useValue: UserEntity, // 使用測試資料庫的 Repository
+        },
+      ],
+    }).compile();
+
+    authController = module.get<AuthController>(AuthController);
+    authService = module.get<AuthService>(AuthService);
+    userRepository = module.get<Repository<UserEntity>>(
+      getRepositoryToken(UserEntity),
+    );
+  });
+  describe("create", () => {
+    it("應該會創建一個使用者，並返回 201 狀態碼", async () => {
+      const createUserDto: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account",
+        password: "Password@123",
+      };
+      const expectedResponse: CreateUserRespose = {
+        statusCode: 201,
+        message: "創建成功",
+      };
+      jest.spyOn(authService, "register").mockResolvedValue(expectedResponse);
+      const result = await authController.register(createUserDto);
+      expect(result).toEqual(expectedResponse);
+    });
+    it("應該會發生資料使用者重覆，並返回 409 狀態碼", async () => {
+      const createUserDto1: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account1",
+        password: "Password@123",
+      };
+      try {
+        await authService.register(createUserDto1);
+        await authService.register(createUserDto1);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ConflictException);
+        expect(error.response).toEqual({
+          statusCode: 409,
+          message: ["email 已被註冊。", "account 已被註冊。"],
+          error: "Conflict",
+        });
+      }
+    });
+  });
+  afterEach(async () => {
+    if (userRepository && userRepository.clear) {
+      await userRepository.clear();
+    }
+  });
+});

src/auth/auth.controller.ts

@@ -0,0 +1,40 @@
+import { Body, Controller, Post } from "@nestjs/common";
+import {
+  ApiBadRequestResponse,
+  ApiConflictResponse,
+  ApiCreatedResponse,
+  ApiOperation,
+  ApiTags,
+} from "@nestjs/swagger";
+import { CreateUserDto } from "src/user/dto/create-user.dto";
+import { CreateUserBadrequestError } from "src/user/exceptions/create-user-badrequest-error.exception";
+import { CreateUserConflictError } from "src/user/exceptions/create-user-conflict-error.exception";
+import { CreateUserRespose } from "src/user/resposes/create-user-respose";
+
+import { AuthService } from "./auth.service";
+
+@ApiTags("Auth")
+@Controller("auth")
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+  @Post("register")
+  @ApiOperation({
+    summary: "使用者註冊",
+    description: "會檢查是否重複過的資料",
+  })
+  @ApiCreatedResponse({
+    description: "使用者創建成功",
+    type: CreateUserRespose,
+  })
+  @ApiConflictResponse({
+    description: "使用者資料重覆",
+    type: CreateUserConflictError,
+  })
+  @ApiBadRequestResponse({
+    description: "使用者格式不符",
+    type: CreateUserBadrequestError,
+  })
+  register(@Body() userDto: CreateUserDto) {
+    return this.authService.register(userDto);
+  }
+}

src/auth/auth.module.ts

@@ -0,0 +1,14 @@
+import { Module } from "@nestjs/common";
+import { TypeOrmModule } from "@nestjs/typeorm";
+import { UserEntity } from "src/user/entities/user.entity";
+import { UserModule } from "src/user/user.module";
+
+import { AuthController } from "./auth.controller";
+import { AuthService } from "./auth.service";
+
+@Module({
+  imports: [UserModule, TypeOrmModule.forFeature([UserEntity])],
+  controllers: [AuthController],
+  providers: [AuthService],
+})
+export class AuthModule {}

src/auth/auth.service.spec.ts

@@ -0,0 +1,129 @@
+import { ConflictException, HttpStatus } from "@nestjs/common";
+import { Test, TestingModule } from "@nestjs/testing";
+import { getRepositoryToken, TypeOrmModule } from "@nestjs/typeorm";
+import { validate } from "class-validator";
+import { dataSourceJest } from "src/config/data-source";
+import { CreateUserDto } from "src/user/dto/create-user.dto";
+import { UserEntity } from "src/user/entities/user.entity";
+import { UserService } from "src/user/user.service";
+import { Repository } from "typeorm";
+
+import { AuthService } from "./auth.service";
+
+describe("AuthService", () => {
+  let authService: AuthService;
+  let userRepository: Repository<UserEntity>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      imports: [TypeOrmModule.forRoot(dataSourceJest)],
+      providers: [
+        AuthService,
+        UserService,
+        {
+          provide: getRepositoryToken(UserEntity),
+          useValue: UserEntity, // 使用測試資料庫的 Repository
+        },
+      ],
+    }).compile();
+
+    authService = module.get<AuthService>(AuthService);
+    userRepository = module.get<Repository<UserEntity>>(
+      getRepositoryToken(UserEntity),
+    );
+  });
+
+  describe("createUser - Data", () => {
+    it("應該會創建 一個使用者", async () => {
+      const test_data: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account1",
+        password: "Password@123",
+      };
+      const user = await authService.register(test_data);
+
+      expect(user).toBeDefined();
+      expect(user.statusCode).toEqual(HttpStatus.CREATED);
+      expect(user.message).toEqual("創建成功");
+    });
+    it("應該會發生 email、account 已被註冊衝突", async () => {
+      const createUserDto1: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account",
+        password: "Password@123",
+      };
+      try {
+        await authService.register(createUserDto1);
+        await authService.register(createUserDto1);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ConflictException);
+        expect(error.response).toEqual({
+          statusCode: 409,
+          message: ["email 已被註冊。", "account 已被註冊。"],
+          error: "Conflict",
+        });
+      }
+    });
+    it("應該會發生 email 已被註冊衝突", async () => {
+      const test_data1: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account1",
+        password: "Password@123",
+      };
+      const test_data2: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account2",
+        password: "Password@123",
+      };
+      const errors = await validate(test_data1);
+      expect(errors.length).toBe(0);
+      try {
+        await authService.register(test_data1);
+        await authService.register(test_data2);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ConflictException);
+        expect(error.response).toEqual({
+          statusCode: 409,
+          message: ["email 已被註冊。"],
+          error: "Conflict",
+        });
+      }
+    });
+    it("應該會發生 account 已被註冊衝突", async () => {
+      const test_data1: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account",
+        password: "Password@123",
+      };
+      const test_data2: CreateUserDto = {
+        email: "[email protected]",
+        name: "displayname",
+        account: "account",
+        password: "Password@123",
+      };
+      const errors = await validate(test_data1);
+      expect(errors.length).toBe(0);
+      try {
+        await authService.register(test_data1);
+        await authService.register(test_data2);
+      } catch (error) {
+        expect(error).toBeInstanceOf(ConflictException);
+        expect(error.response).toEqual({
+          statusCode: 409,
+          message: ["account 已被註冊。"],
+          error: "Conflict",
+        });
+      }
+    });
+  });
+  afterEach(async () => {
+    if (userRepository && userRepository.clear) {
+      await userRepository.clear();
+    }
+  });
+});

src/auth/auth.service.ts

@@ -0,0 +1,32 @@
+import { ConflictException, Injectable } from "@nestjs/common";
+import { InjectRepository } from "@nestjs/typeorm";
+import { CreateUserDto } from "src/user/dto/create-user.dto";
+import { UserEntity } from "src/user/entities/user.entity";
+import { UserService } from "src/user/user.service";
+import { Repository } from "typeorm";
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private userService: UserService,
+    @InjectRepository(UserEntity)
+    private userRepository: Repository<UserEntity>,
+  ) {}
+  async register(userDto: CreateUserDto) {
+    const existingUser = await this.userRepository.findOne({
+      where: [{ email: userDto.email }, { account: userDto.account }],
+    });
+
+    if (existingUser) {
+      const keys = ["email", "account"];
+      const conflictedAttributes = [];
+      keys.forEach(key => {
+        if (existingUser[key] === userDto[key]) {
+          conflictedAttributes.push(key + " 已被註冊。");
+        }
+      });
+      throw new ConflictException(conflictedAttributes);
+    }
+    return this.userService.create(userDto);
+  }
+}

src/config/data-source.ts

@@ -1,4 +1,5 @@
 import * as dotenv from "dotenv";
+import { UserEntity } from "src/user/entities/user.entity";
 import { DataSource, DataSourceOptions } from "typeorm";
 
 dotenv.config();
@@ -19,5 +20,12 @@ export const dataSourceOptions: DataSourceOptions = {
   logging: false,
 };
 
+export const dataSourceJest: DataSourceOptions = {
+  type: "sqlite",
+  database: ":memory:",
+  entities: [UserEntity],
+  synchronize: true,
+};
+
 const dataSource = new DataSource(dataSourceOptions);
 export default dataSource;