• Nest.js项目小结1

    整体项目结构

            prisma\        （用于管理数据库迁移、定义数据模型和数据填充）

                    migrations\        （日志记录，不用管）

                    schema.prisma        （定义数据模型）

                    seed.ts        （用于填充数据库初始数据的文件）

            src\

                    auth\        （包含处理用户认证的模块代码）

                            dto\        （定义数据传输对象）

                                    register.dto.ts        （数据对象）

                            auth.controller.ts         （处理路由等）

                            auth.module.ts            （模块）

                            auth.service.ts            （逻辑）

                    common\        （包含通用的功能代码）

                            rules\        (自定义验证规则)

                                    is-confirm.rule.ts

                                    is-not-exists.rule.ts

                            validate.ts        （通用数据验证）

                    prisma\

                            prisma.module.ts        （模块）

                            prisma.service.ts        （处理与Prisma数据库交互的服务）

                    app.module.ts        （模块）

                    main.ts        （主入口）

                    transform.inteceptor.ts        （响应拦截器）

    ——————————————————————————————————————

    schema.prisma       

            定义数据库模型

    1. generator client {
    2.   provider = "prisma-client-js"
    3. }
    4.  
    5. datasource db {
    6.   provider = "mysql"
    7.   url      = env("DATABASE_URL")
    8. }
    9.  
    10. model user {
    11.   id       Int     @id @default(autoincrement()) @db.UnsignedInt
    12.   name     String  @unique
    13.   password String
    14. }
    15.  
    16. model article {
    17.   id       Int     @id @default(autoincrement()) @db.UnsignedInt
    18.   title    String
    19.   content  String  @db.Text
    20. }

    seed.ts

            填充数据库数据

    1. import { PrismaClient } from "@prisma/client"
    2. import { hash } from "argon2"
    3. import { Random } from "mockjs"
    4.  
    5. const prisma = new PrismaClient()    //注册Prisma
    6. async function run() {
    7.     await prisma.user.create({    //往user表里面插入数据
    8.         data: {
    9.             name: "admin",
    10.             password: await hash("admin8888")    //转成hash
    11.         }
    12.     })
    13.     for (let i = 0; i < 50; i++) {    //填充50组
    14.         await prisma.article.create({    //往article表里面插入数据
    15.             data: {
    16.                 title: Random.ctitle(10, 30),    //随机题目
    17.                 content: Random.cparagraph(10, 20),    //随机内容
    18.             }
    19.         })
    20.     }
    21.  
    22. }
    23. run()

    ——————————————————————————————————————

    app.module.ts

    1. import { Module } from '@nestjs/common';
    2. import { AuthModule } from './auth/auth.module';    //引入验证模块
    3. import { PrismaModule } from './prisma/prisma.module';    //引入prisma模块
    4.  
    5.  
    6. @Module({
    7.   imports: [ AuthModule , PrismaModule ],    //插入
    8. })
    9. export class AppModule {}

    ——————————————————————————————————————

    auth

            dto

                    register.dto.ts

    1. import { IsNotEmpty } from "class-validator";    //引入默认不为空验证
    2. import { IsNotExistsRule } from "../../common/rules/is-not-exists.rule"; //引入自定义验证
    3. import { IsConfiemRule } from "../../common/rules/is-confirm.rule";    //引入自定义验证
    4.  
    5. export default class RegisterDto {    
    6.     @IsNotEmpty({ message:'用户名不能为空' })                //验证规则
    7.     @IsNotExistsRule("user" , { message: "用户已经存在" })   //验证规则
    8.     name:string;                                             //类型
    9.  
    10.     @IsNotEmpty({ message:'密码不能为空' })
    11.     @IsConfiemRule({ message: "两次密码不一致" })
    12.     password:string
    13.  
    14.     @IsNotEmpty({message: "确认密码不能为空"})
    15.     password_confirm: string
    16. }

    auth.controller.ts

    1. import { Controller , Body , Post } from '@nestjs/common'
    2. import { AuthService } from './auth.service';
    3. import RegisterDto from './dto/register.dto';    //引入验证规则
    4.  
    5. @Controller()
    6. export class AuthController{
    7.     constructor(private auth: AuthService) {}
    8.  
    9.     @Post('register')    //post请求，路由为register
    10.     login(@Body() dto: RegisterDto) {    //获取body数据 为dto : 验证规则
    11.         return this.auth.register(dto)    //执行auth的register函数
    12.     }
    13. }

    auth.service.ts

    1. import { Injectable } from '@nestjs/common'
    2. import RegisterDto from './dto/register.dto';
    3. import { PrismaService } from './../prisma/prisma.service';    //引入全局配置prisma
    4. import { hash } from 'argon2';
    5. import { JwtService } from '@nestjs/jwt';
    6.  
    7. @Injectable()
    8. export class AuthService {
    9.     constructor(private prisma:PrismaService , private jwt: JwtService){}
    10.  
    11.     async register(dto: RegisterDto){    //验证通过后执行这里
    12.         const user = await this.prisma.user.create({    //等候创建
    13.             data:{
    14.                 name: dto.name,
    15.                 password: await hash(dto.password)
    16.             }
    17.         })
    18.         return this.token(user);    //执行token函数
    19.     }
    20.  
    21.     private async token({ id , name }){
    22.         return {
    23.             token: await this.jwt.signAsync({ //执行配置好后的jwt
    24.                 name , 
    25.                 sub: id 
    26.             })
    27.         }
    28.     }
    29. }

    auth.module.ts

    1. import { Module } from '@nestjs/common'
    2. import { AuthService } from './auth.service'
    3. import { AuthController } from './auth.controller'
    4. import { JwtModule } from '@nestjs/jwt'
    5. import { ConfigModule, ConfigService } from '@nestjs/config'
    6.  
    7. @Module({
    8.    imports: [        //TODO        配置JWT
    9.       JwtModule.registerAsync({
    10.          imports: [ConfigModule],
    11.          inject: [ConfigService],
    12.          useFactory: (config: ConfigService) => {
    13.              return {
    14.                secret: config.get('TOKEN_SECRET'),    //密钥在.env里配置
    15.                signOptions: { expiresIn: '60d' }    //持续时间
    16.              }
    17.          },
    18.       })
    19.    ],        //END
    20.    controllers: [AuthController],    //引入控制器
    21.    providers: [AuthService]    //引入函数
    22. })
    23.  
    24. export class AuthModule{}

    common

            rules

                    is-confirm.rule.ts

    1. import { PrismaClient } from '@prisma/client'
    2. import { registerDecorator , ValidationArguments , ValidationOptions } from 'class-validator'
    3.  
    4. //表字段是否唯一
    5. export function IsConfiemRule(    //这里定义规则名称
    6.    validationOptions?: ValidationOptions
    7. ) {
    8.    return function (object: Record<string , any>, propertyName: string) {
    9.        registerDecorator({
    10.            name: 'IsConfiemRule',    //同上
    11.            target: object.constructor,
    12.            propertyName: propertyName,
    13.            constraints: [],
    14.            options: validationOptions,
    15.            validator: {
    16.                async validate(value: string, args: ValidationArguments) {
    17.                    //TODO
    18.                    return Boolean(value == args.object[`${args.property}_confirm`]) //true为通过，false为不通过
    19.                    //END
    20.                }
    21.            }
    22.        })
    23.    }
    24. }

                    is-not-exists.ule.ts

    1. import { PrismaClient } from '@prisma/client'
    2. import { registerDecorator , ValidationArguments , ValidationOptions } from 'class-validator'
    3.  
    4. //表字段是否唯一
    5. export function IsNotExistsRule(
    6.    table: string,
    7.    validationOptions?: ValidationOptions
    8. ) {
    9.    return function (object: Record<string , any>, propertyName: string) {
    10.        registerDecorator({
    11.            name: 'IsNotExistsRule',
    12.            target: object.constructor,
    13.            propertyName: propertyName,
    14.            constraints: [table],
    15.            options: validationOptions,
    16.            validator: {
    17.                async validate(value: string, args: ValidationArguments) {
    18.                    //TODO
    19.                    const prisma = new PrismaClient
    20.                    const res = await prisma[table].findFirst({
    21.                        where: {
    22.                            [args.property]: value
    23.                        }
    24.                    })
    25.                    return !Boolean(res)
    26.                    //END
    27.                }
    28.            }
    29.        })
    30.    }
    31. }
    32. //同上

            validate.ts

    1. import { HttpException, HttpStatus, ValidationPipe } from "@nestjs/common";
    2. import { ValidationError } from "class-validator";
    3.  
    4. export default class Validate extends ValidationPipe {
    5.     protected flattenValidationErrors(validationErrors: ValidationError[]): string[] {
    6.         const messages = {}
    7.         validationErrors.forEach(error => {    //遍历出必要错误返回给前端
    8.             messages[error.property] = Object.values(error.constraints)[0];
    9.         })
    10.             
    11.         throw new HttpException({    //返回给前端的错误
    12.             code: 422,    
    13.             messages
    14.         }, HttpStatus.UNPROCESSABLE_ENTITY); 
    15.     }
    16. }

    prisma

            prisma.module.ts

    1. import { Global, Module } from '@nestjs/common'
    2. import { PrismaService } from './prisma.service';
    3.  
    4.  
    5. @Global() // 全局模块
    6. @Module({
    7.    providers: [PrismaService],
    8.    exports: [PrismaService]
    9. })
    10.  
    11. export class PrismaModule{}

            prisma.service.ts

    1. import { PrismaClient } from '@prisma/client' 
    2. import { Injectable } from '@nestjs/common'
    3.  
    4. @Injectable()
    5. export class PrismaService extends PrismaClient{
    6.     constructor(){
    7.         super({
    8.             log:['query']
    9.         })
    10.     }
    11. }

    transform.inteceptor.ts

    1. import { CallHandler , ExecutionContext , Injectable , NestInterceptor } from '@nestjs/common'
    2. import { map } from 'rxjs/operators'
    3.  
    4. @Injectable()
    5. export class TransformInterceptor implements NestInterceptor {    //修改一下数据格式
    6.     intercept(context: ExecutionContext, next: CallHandler) {
    7.         return next.handle().pipe(
    8.             map((data) => {
    9.                 return {
    10.                     data
    11.                 }
    12.             })
    13.        )
    14.    }
    15. }

    main.ts

    1. import { NestFactory } from '@nestjs/core';
    2. import { AppModule } from './app.module';
    3. import Validate from './common/validate';
    4. import { TransformInterceptor } from './transform.inteceptor';
    5.  
    6. async function bootstrap() {
    7.   const app = await NestFactory.create(AppModule);
    8.   app.useGlobalPipes(new Validate())    //返回给前端的错误数据
    9.   app.useGlobalInterceptors(new TransformInterceptor())    //返回给前端的正确数据（响应拦截器）
    10.   await app.listen(3000);    //监听的端口号
    11. }
    12. bootstrap();

  • 相关阅读:
    leetcode 216. 组合总和 III
    外卖系统源码，搭建同城点餐配送服务平台
    机器学习/人工智能的笔试面试题目——CNN相关问题总结
    什么是岗位点检？在设备管理中如何应用岗位点检理论？
    C语言基础篇 —— 4.1 管理内存：栈（stack）、堆（heap）、数据区（.data）
    SpringBoot 如何使用 CORS 进行跨域资源共享
    用Nginx搭建一个具备缓存功能的反向代理服务
    OneFormer: One Transformer to Rule Universal Image Segmentation论文笔记
    excel的frequency函数的用法和实例
    C++之＜set和map模拟实现＞
  • 原文地址：https://blog.csdn.net/m0_53785610/article/details/138169744