项目架构（4）--- 整合编写框架具体代码

 

项目结构

 

新建一个项目文件夹

通过 prisma init --datasource-provider mysql 构建prisma项目 

 

代码编写

 main.ts

import "reflect-metadata";
import { InversifyExpressServer } from "inversify-express-utils";
import { Container } from "inversify";
import { User } from "./src/user/controller";
import { UserService } from "./src/user/services";
import express from "express";
import { PrismaClient } from '@prisma/client'
import { PrismaDB } from "./src/db";
const container = new Container();

/**
 * user模块
 * */ 
container.bind<User>(User).to(User);
container.bind<UserService>(UserService).to(UserService);


/**
 * 封装PrismaClient
 * */ 
container.bind<PrismaClient>('PrismaClient').toFactory(()=>{
    return ()=>{
        return new PrismaClient()
    }
})

container.bind(PrismaDB).to(PrismaDB)


const server = new InversifyExpressServer(container);

server.setConfig((app) => {
    app.use(express.json())
})
const app = server.build();

app.listen(3000, () => {
  console.log("Server is running on port 3000");
});

封装PrismaClient：

使用了InversifyJS框架的依赖注入容器（container）来绑定一个PrismaClient实例的工厂函数。 这样做的原因是为了确保PrismaClient实例在应用程序的不同部分被正确地创建和管理。（不需要在别的文件中重新实例化）

在应用程序的其他地方，可以通过这个标识符来获取PrismaClient实例

 

src/user/controller.ts

import {
  controller, // 注入器
  httpGet as GetMapping,
  httpPost as PostMapping,
} from "inversify-express-utils";
import { UserService } from "./services";
import { inject } from "inversify";
import type { Request, Response } from "express";

//路由  装饰器
@controller("/user")
export class User {
  constructor(@inject(UserService) private readonly UserService: UserService) {}

  @GetMapping("/index")
  public async getIndex(req: Request, res: Response) {
    console.log(req.query);
    let result =  await this.UserService.getList();
    res.send(result);
  }

  @PostMapping("/create")
  public async createUser(req: Request, res: Response) {
    console.log(req.body);
    let result = await this.UserService.createUser(req.body);
    res.send(result);
  }
}

src/user/services.ts

import { injectable, inject } from "inversify"; //注射器
import { PrismaDB } from "../db";
import { UserDto } from "./user.dto";
import { plainToClass } from "class-transformer";
import { validate } from "class-validator";

@injectable()
// 获取用户列表的方法
export class UserService {
  constructor(@inject(PrismaDB) private readonly PrismaDB: PrismaDB) {}
  public async getList() {
    return await this.PrismaDB.prisma.user.findMany();
  }

  public async createUser(user: UserDto) {
    let userDto = plainToClass(UserDto, user);
    const errors = await validate(userDto);

    console.log(errors);

    if (errors.length > 0) {
      return errors;
    } else {
      return await this.PrismaDB.prisma.user.create({
        data: user,
      });
    }
  }
}

src/user/user.dto.ts

import { IsEmail, IsNotEmpty } from "class-validator";
import { Transform } from "class-transformer";

export class UserDto {
  @IsNotEmpty({ message: "Name is required" })
  @Transform((a) => a.value.trim())
  name: string;

  @IsNotEmpty({ message: "Email is required" })
  @IsEmail({}, { message: "Email is invalid" })
  email: string;
}

src/db/index.ts

import {injectable,inject} from  'inversify'
import { PrismaClient } from '@prisma/client'

@injectable()
export class PrismaDB {
    prisma : PrismaClient
    constructor(@inject('PrismaClient') PrismaClient :()=>PrismaClient) {
        this.prisma = PrismaClient()
    }

}

tsconig.json

支持装饰器和反射 打开一下 严格模式关闭

"experimentalDecorators": true,               
"emitDecoratorMetadata": true,    
"strict": false,