feat: auth

Author: hildxd

apps/api/package.json

@@ -28,6 +28,8 @@
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/swagger": "^7.1.17",
     "argon2": "^0.31.2",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.1",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.1",
     "start": "^5.1.0"

apps/api/src/app.module.ts

@@ -2,9 +2,11 @@ import { Module } from '@nestjs/common';
 import { AppController } from './app.controller';
 import { AppService } from './app.service';
 import { GlobalModule } from './global/global.mudule';
+import { UserModule } from './user/user.module';
+import { AuthModule } from './auth/auth.module';
 
 @Module({
-  imports: [GlobalModule],
+  imports: [GlobalModule, UserModule, AuthModule],
   controllers: [AppController],
   providers: [AppService],
 })

apps/api/src/auth/auth.controller.ts

@@ -0,0 +1,33 @@
+import {
+  Controller,
+  Post,
+  Body,
+  Get,
+  UseGuards,
+  Request,
+} from '@nestjs/common';
+import { SignDto } from './model/auth.dto';
+import { AuthService } from './auth.service';
+import { AuthGuard } from './auth.guard';
+import { CreateUserDto } from '../user/model/user.dto';
+
+@Controller('auth')
+export class AuthController {
+  constructor(private readonly authService: AuthService) {}
+
+  @Post('sign')
+  sign(@Body() dto: SignDto) {
+    return this.authService.signIn(dto);
+  }
+
+  @Post('signup')
+  signup(@Body() dto: CreateUserDto) {
+    return this.authService.signup(dto);
+  }
+
+  @UseGuards(AuthGuard)
+  @Get('test')
+  tets(@Request() req) {
+    return req.user;
+  }
+}

apps/api/src/auth/auth.guard.ts

@@ -0,0 +1,37 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import { Request } from 'express';
+
+@Injectable()
+export class AuthGuard implements CanActivate {
+  constructor(private jwtService: JwtService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest();
+    const token = this.extractTokenFromHeader(request);
+    if (!token) {
+      throw new UnauthorizedException();
+    }
+    try {
+      const payload = await this.jwtService.verifyAsync(token, {
+        secret: process.env.SECRET,
+      });
+      // 💡 We're assigning the payload to the request object here
+      // so that we can access it in our route handlers
+      request['user'] = payload;
+    } catch {
+      throw new UnauthorizedException();
+    }
+    return true;
+  }
+
+  private extractTokenFromHeader(request: Request): string | undefined {
+    const [type, token] = request.headers.authorization?.split(' ') ?? [];
+    return type === 'Bearer' ? token : undefined;
+  }
+}

apps/api/src/auth/auth.module.ts

@@ -0,0 +1,19 @@
+import { Module } from '@nestjs/common';
+import { AuthService } from './auth.service';
+import { AuthController } from './auth.controller';
+import { JwtModule } from '@nestjs/jwt';
+import { UserModule } from '../user/user.module';
+
+@Module({
+  imports: [
+    UserModule,
+    JwtModule.register({
+      global: true,
+      secret: process.env.SECRET,
+      signOptions: { expiresIn: '7d' },
+    }),
+  ],
+  providers: [AuthService],
+  controllers: [AuthController],
+})
+export class AuthModule {}

apps/api/src/auth/auth.service.ts

@@ -0,0 +1,44 @@
+import {
+  HttpException,
+  HttpStatus,
+  Injectable,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { UserService } from '../user/user.service';
+import { JwtService } from '@nestjs/jwt';
+import { SignDto } from './model/auth.dto';
+import argon2 from 'argon2';
+import { CreateUserDto } from '../user/model/user.dto';
+
+@Injectable()
+export class AuthService {
+  constructor(
+    private userService: UserService,
+    private jwtService: JwtService,
+  ) {}
+
+  async signIn(dto: SignDto) {
+    const user = await this.userService.findWithPhone(dto);
+    if (!(await argon2.verify(user.password, dto.password))) {
+      throw new UnauthorizedException();
+    }
+
+    const payload = { userId: user.id, username: user.name };
+    return {
+      token: await this.jwtService.signAsync(payload),
+    };
+  }
+
+  async signup(dto: CreateUserDto) {
+    const user = await this.userService.findWithPhone(dto);
+    if (user) {
+      throw new HttpException('User already exists', HttpStatus.BAD_REQUEST);
+    }
+
+    const res = await this.userService.createUser(dto);
+    const payload = { userId: res.id, username: dto.name };
+    return {
+      token: await this.jwtService.signAsync(payload),
+    };
+  }
+}

apps/api/src/auth/model/auth.dto.ts

@@ -0,0 +1,5 @@
+import { PickType } from '@nestjs/swagger';
+import '@nestjs/common';
+import { CreateUserDto } from '../../user/model/user.dto';
+
+export class SignDto extends PickType(CreateUserDto, ['phone', 'password']) {}

apps/api/src/global/providers/db.provider.ts

@@ -3,20 +3,22 @@ import { type MySql2Database } from 'drizzle-orm/mysql2';
 import { drizzle } from 'drizzle-orm/mysql2';
 import * as mysql from 'mysql2/promise';
 import { DefaultLogger, LogWriter } from 'drizzle-orm';
+import { schemas } from '@earthwrom/shared';
 
 export const DB = Symbol('DB_SERVICE');
-export type DbType = MySql2Database;
+export type DbType = MySql2Database<typeof schemas>;
 
 const env = process.env;
 
 export const DbProvider: FactoryProvider<DbType> = {
   provide: DB,
-  useFactory: () => {
+  useFactory: async () => {
     const logger = new Logger('DB');
 
     logger.debug(`Connecting to ${env.DATABASE_URL}`);
+    logger.debug(`SECRET: ${env.SECRET}`);
 
-    const connection = mysql.createPool({
+    const connection = await mysql.createConnection({
       uri: env.DATABASE_URL,
       multipleStatements: true,
       waitForConnections: true,
@@ -36,8 +38,11 @@ export const DbProvider: FactoryProvider<DbType> = {
       }
     }
 
-    return drizzle(connection, {
+    const db = drizzle(connection, {
+      schema: schemas,
       logger: new DefaultLogger({ writer: new CustomDbLogWriter() }),
+      mode: 'planetscale',
     });
+    return db;
   },
 };

apps/api/src/main.ts

@@ -1,10 +1,12 @@
 import { NestFactory } from '@nestjs/core';
 import { AppModule } from './app.module';
 import { SwaggerModule, DocumentBuilder } from '@nestjs/swagger';
+import { ValidationPipe } from '@nestjs/common';
 
 async function bootstrap() {
   const app = await NestFactory.create(AppModule);
 
+  app.useGlobalPipes(new ValidationPipe());
   const config = new DocumentBuilder()
     .setTitle('Cats example')
     .setDescription('The cats API description')

apps/api/src/user/model/user.dto.ts

@@ -0,0 +1,26 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNotEmpty, Length } from 'class-validator';
+
+export class CreateUserDto {
+  @ApiProperty()
+  @IsNotEmpty({ message: ' 用户名不能为空' })
+  @Length(1, 8, { message: '用户名长度为1-8位' })
+  name: string;
+
+  @ApiProperty()
+  @IsNotEmpty({ message: '手机号码不能为空' })
+  @Length(11, 11, { message: '手机号码长度为11位' })
+  phone: string;
+
+  @ApiProperty()
+  @IsNotEmpty({ message: '密码不能为空' })
+  @Length(6, 20, { message: '密码长度为6-20位' })
+  password: string;
+}
+
+export class FindUserDto {
+  @ApiProperty()
+  @IsNotEmpty({ message: '手机号码不能为空' })
+  @Length(11, 11, { message: '手机号码长度为11位' })
+  phone: string;
+}

apps/api/src/user/user.controller.ts

@@ -0,0 +1,8 @@
+import { Controller, Get, Post, Body } from '@nestjs/common';
+import { UserService } from './user.service';
+import { CreateUserDto } from './model/user.dto';
+
+@Controller('user')
+export class UserController {
+  constructor(private readonly userService: UserService) {}
+}

apps/api/src/user/user.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { UserService } from './user.service';
+import { UserController } from './user.controller';
+
+@Module({
+  providers: [UserService],
+  controllers: [UserController],
+  exports: [UserService],
+})
+export class UserModule {}

apps/api/src/user/user.service.ts

@@ -0,0 +1,27 @@
+import { Inject, Injectable } from '@nestjs/common';
+import { CreateUserDto, FindUserDto } from './model/user.dto';
+import { DB, DbType } from '../global/providers/db.provider';
+import { user } from '@earthwrom/shared';
+import { eq } from 'drizzle-orm';
+import * as argon2 from 'argon2';
+
+@Injectable()
+export class UserService {
+  constructor(@Inject(DB) private db: DbType) {}
+
+  async createUser(dto: CreateUserDto) {
+    const [res] = await this.db.insert(user).values({
+      ...dto,
+      password: await argon2.hash(dto.password),
+    });
+    return {
+      id: res.insertId,
+    };
+  }
+
+  async findWithPhone(dto: FindUserDto) {
+    return this.db.query.user.findFirst({
+      where: eq(user.phone, dto.phone),
+    });
+  }
+}

libs/shared/src/schema/index.ts

@@ -1,4 +1,15 @@
+import { course } from "./course";
+import { statement } from "./statement";
+import { user } from "./user";
+import { userProgress } from "./userProgress";
+
 export * from "./course";
 export * from "./statement";
 export * from "./user";
 export * from "./userProgress";
+export const schemas = {
+  course,
+  statement,
+  user,
+  userProgress,
+};

libs/shared/src/schema/user.ts

@@ -1,10 +1,16 @@
-import { int, mysqlTable, text, timestamp } from "drizzle-orm/mysql-core";
+import {
+  int,
+  mysqlTable,
+  text,
+  timestamp,
+  varchar,
+} from "drizzle-orm/mysql-core";
 
-export const user = mysqlTable("courses", {
+export const user = mysqlTable("users", {
   id: int("id").autoincrement().primaryKey(),
-  phone: text("phone").notNull().unique(),
+  phone: varchar("phone", { length: 11 }).notNull().unique(),
   name: text("name").notNull(),
   password: text("password").notNull(),
   createdAt: timestamp("created_at").notNull().defaultNow(),
-  updatedAt: timestamp("updated_at").notNull().onUpdateNow(),
+  updatedAt: timestamp("updated_at").onUpdateNow(),
 });