feat: Setup local user register & handle exception error to logger

package.json

@@ -39,9 +39,11 @@
     "@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",
+    "morgan": "^1.10.0",
     "mysql2": "^2.3.3",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.2",

src/app.module.ts

@@ -1,20 +1,30 @@
 import { Module } from "@nestjs/common";
 import { ConfigModule } from "@nestjs/config";
+import { APP_FILTER } from "@nestjs/core";
 import { TypeOrmModule } from "@nestjs/typeorm";
 
 import { AppController } from "./app.controller";
 import { AppService } from "./app.service";
 import { dataSourceOptions } from "./config/data-source";
 import { validate } from "./config/env.validation";
+import { AllExceptionsFilter } from "./core/all-exceptions.filter";
+import { UsersModule } from "./users/users.module";
 
 @Module({
   imports: [
     ConfigModule.forRoot({
       validate,
     }),
     TypeOrmModule.forRoot(dataSourceOptions),
+    UsersModule,
   ],
   controllers: [AppController],
-  providers: [AppService],
+  providers: [
+    AppService,
+    {
+      provide: APP_FILTER,
+      useClass: AllExceptionsFilter,
+    },
+  ],
 })
 export class AppModule {}

src/core/all-exceptions.filter.ts

@@ -0,0 +1,92 @@
+import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+  HttpStatus,
+} from "@nestjs/common";
+import { Request, Response } from "express";
+import * as fs from "fs";
+import { QueryFailedError } from "typeorm";
+
+import { CustomHttpExceptionResponse } from "./models/http-exception-response.interface";
+
+@Catch()
+export class AllExceptionsFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+
+    let status: HttpStatus;
+    let tinyErrorMessage: string;
+    let fullErrorMessage: string;
+    let errorMessage: string;
+    if (exception instanceof HttpException) {
+      status = exception.getStatus();
+      const errorResponse = exception.getResponse();
+      errorMessage = errorResponse["message"];
+    } else if (exception instanceof TypeError) {
+      status = HttpStatus.BAD_REQUEST;
+      errorMessage = exception.message
+        .substring(exception.message.indexOf("\n\n\n") + 1)
+        .trim();
+    } else if (exception instanceof QueryFailedError) {
+      status = HttpStatus.INTERNAL_SERVER_ERROR;
+      tinyErrorMessage = exception.message
+        .substring(exception.message.indexOf("\n\n\n") + 1)
+        .trim();
+      fullErrorMessage = exception["sql"];
+      errorMessage = "Critical internal server error occurred!";
+    } else {
+      status = HttpStatus.INTERNAL_SERVER_ERROR;
+      errorMessage = "Critical internal server error occurred!";
+      fullErrorMessage = JSON.stringify(exception);
+    }
+    const errorResponse = this.getErrorResponse(status, errorMessage, request);
+    const errorLog = this.getErrorLog(
+      tinyErrorMessage,
+      fullErrorMessage,
+      errorResponse,
+      request,
+      exception,
+    );
+    this.writeErrorLogToFile(errorLog);
+    response.status(status).json(errorResponse);
+  }
+
+  private getErrorResponse = (
+    status: HttpStatus,
+    errorMessage: string,
+    request: Request,
+  ): CustomHttpExceptionResponse => ({
+    statusCode: status,
+    error: errorMessage,
+    path: request.url,
+    method: request.method,
+    timeStamp: new Date(),
+  });
+
+  private getErrorLog = (
+    tinyErrorMessage: string,
+    fullErrorMessage: string,
+    errorResponse: CustomHttpExceptionResponse,
+    request: Request,
+    exception: unknown,
+  ): string => {
+    const { statusCode, error } = errorResponse;
+    const { method, url } = request;
+    const errorLog = `Response Code: ${statusCode} - Method: ${method} - URL: ${url}
+    ${JSON.stringify(errorResponse)}
+    ${tinyErrorMessage != undefined ? tinyErrorMessage : ""}
+    ${fullErrorMessage != undefined ? fullErrorMessage : ""}
+    ${exception instanceof HttpException ? exception.stack : error}\n\n`;
+    return errorLog;
+  };
+
+  private writeErrorLogToFile = (errorLog: string): void => {
+    fs.appendFile("error.log", errorLog, "utf8", err => {
+      if (err) throw err;
+    });
+  };
+}

src/core/models/http-exception-response.interface.ts

@@ -0,0 +1,7 @@
+export interface CustomHttpExceptionResponse {
+  statusCode: number;
+  error: string;
+  path: string;
+  method: string;
+  timeStamp: Date;
+}

src/database/migrations/1679539757893-UserInitMigration.ts

@@ -0,0 +1,37 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class UserInitMigration1679539757893 implements MigrationInterface {
+  name = "UserInitMigration1679539757893";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `CREATE TABLE \`users\` 
+      (
+        \`id\` int NOT NULL AUTO_INCREMENT,
+        \`email\` varchar(255) NOT NULL,
+        \`name\` varchar(255) NOT NULL,
+        \`account\` varchar(255) NOT NULL,
+        \`password\` varchar(255) NOT NULL,
+        \`createAt\` datetime(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
+        \`updateAt\` datetime(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6) ON UPDATE CURRENT_TIMESTAMP(6),
+        UNIQUE INDEX \`IDX_97672ac88f789774dd47f7c8be\` (\`email\`),
+        UNIQUE INDEX \`IDX_51b8b26ac168fbe7d6f5653e6c\` (\`name\`),
+        UNIQUE INDEX \`IDX_dd44b05034165835d6dcc18d68\` (\`account\`),
+        PRIMARY KEY (\`id\`)
+      ) ENGINE=InnoDB`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX \`IDX_dd44b05034165835d6dcc18d68\` ON \`users\``,
+    );
+    await queryRunner.query(
+      `DROP INDEX \`IDX_51b8b26ac168fbe7d6f5653e6c\` ON \`users\``,
+    );
+    await queryRunner.query(
+      `DROP INDEX \`IDX_97672ac88f789774dd47f7c8be\` ON \`users\``,
+    );
+    await queryRunner.query(`DROP TABLE \`users\``);
+  }
+}

src/main.ts

@@ -1,15 +1,22 @@
 import { INestApplication } from "@nestjs/common";
 import { NestFactory } from "@nestjs/core";
 import { DocumentBuilder, SwaggerModule } from "@nestjs/swagger";
+import * as fs from "fs";
+import * as morgan from "morgan";
 
 import { AppModule } from "./app.module";
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
+  app.use(morgan("default", { stream: logStream }));
   setupSwagger(app);
   await app.listen(3000);
 }
 
+const logStream = fs.createWriteStream("api.log", {
+  flags: "a", // append
+});
+
 function setupSwagger(app: INestApplication) {
   const builder = new DocumentBuilder();
   const config = builder

src/users/dto/create-user.dto.ts

@@ -0,0 +1,62 @@
+import { ApiProperty, PickType } from "@nestjs/swagger";
+import { IsEmail, IsNotEmpty, Length } from "class-validator";
+
+export class CreateUserDto {
+  @ApiProperty({
+    description: "User email",
+    example: "[email protected]",
+  })
+  @IsEmail({}, { message: "email must be in mailbox format." })
+  @IsNotEmpty({
+    message: "email is required field.",
+  })
+  public readonly email: string;
+
+  @ApiProperty({
+    description: "User showname",
+    example: "showname",
+  })
+  @IsNotEmpty({
+    message: "name is required field.",
+  })
+  public readonly name: string;
+
+  @ApiProperty({
+    description: "User account",
+    example: "account",
+  })
+  @IsNotEmpty({
+    message: "account is required field.",
+  })
+  public readonly account: string;
+
+  @ApiProperty({
+    description: "User Password",
+    example: "Password@123",
+  })
+  @IsNotEmpty({
+    message: "password is required field.",
+  })
+  @Length(8, 24, {
+    message: "password's length must be between 8-24 characters.",
+  })
+  public readonly password: string;
+
+  @ApiProperty({
+    description: "check password again",
+    example: "Password@123",
+  })
+  @IsNotEmpty({
+    message: "confirm is required field.",
+  })
+  @Length(8, 24, {
+    message: "confirm's length must be between 8-24 characters.",
+  })
+  public readonly confirm: string;
+}
+export class CreateUserParam extends PickType(CreateUserDto, [
+  "name",
+  "email",
+  "account",
+  "password",
+] as const) {}

src/users/entities/user.entity.ts

@@ -0,0 +1,32 @@
+import {
+  BaseEntity,
+  Column,
+  CreateDateColumn,
+  Entity,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn,
+} from "typeorm";
+
+@Entity({ name: "users" })
+export class UserEntity extends BaseEntity {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  @Column({ unique: true })
+  email: string;
+
+  @Column({ unique: true })
+  name: string;
+
+  @Column({ unique: true })
+  account: string;
+
+  @Column()
+  password: string;
+
+  @CreateDateColumn()
+  createAt: Date;
+
+  @UpdateDateColumn()
+  updateAt: Date;
+}

src/users/exceptions/create-conflict-error.exception.ts

@@ -0,0 +1,39 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export class CreateConflictUserError {
+  @ApiProperty({
+    type: "number",
+    description: "HTTP StatusCode",
+    example: "409",
+  })
+  public readonly StatusCode: number;
+
+  @ApiProperty({
+    type: "array",
+    description: "Error Message",
+    items: {
+      properties: {
+        email: {
+          description: "email has been registered.  \n",
+          type: "string",
+        },
+        name: {
+          description: "name has been registered.  \n",
+          type: "string",
+        },
+        account: {
+          description: "account has been registered. \n",
+          type: "string",
+        },
+        password: {
+          description:
+            "Confirm and password do not match, please try again.  \n",
+
+          type: "string",
+        },
+      },
+    },
+    example: "email has been registered.",
+  })
+  public readonly error: string[];
+}

src/users/exceptions/create-entity-error.exception.ts

@@ -0,0 +1,50 @@
+import { ApiProperty } from "@nestjs/swagger";
+
+export class CreateEntityUserError {
+  @ApiProperty({
+    type: "number",
+    description: "HTTP StatusCode",
+    example: "422",
+  })
+  public readonly StatusCode: number;
+
+  @ApiProperty({
+    type: "array",
+    description: "Error Message",
+    items: {
+      properties: {
+        email: {
+          description:
+            "email is required field.  \n" +
+            "email must be in mailbox format.  \n",
+          type: "string",
+        },
+        name: {
+          description: "name is required field.  \n",
+          type: "string",
+        },
+        account: {
+          description: "account is required field.  \n",
+          type: "string",
+        },
+        password: {
+          description:
+            "password is required field.  \n" +
+            "password's length must be between 8-24 characters.  \n" +
+            "password Should contain 1 uppercase letter, 1 lowercase letter plus numbers and special characters.  \n",
+
+          type: "string",
+        },
+        confirm: {
+          description:
+            "confirm is required field.  \n" +
+            "confirm's length must be between 8-24 characters.  \n" +
+            "confirm Should contain 1 uppercase letter, 1 lowercase letter plus numbers and special characters.  \n",
+          type: "string",
+        },
+      },
+    },
+    example: ["email is required field.", "email must be in mailbox format."],
+  })
+  public readonly error: string[];
+}