nestjs如实连接mysql，并使用TypeORM

nestjs使用msyql

首先声明数据库配置

import { DataSourceOptions } from "typeorm";
import { ConfigService } from "@nestjs/config";

// 当前通过 npm scripts 执行的命令
const currentScript = process.env.npm_lifecycle_event;

export function getDatabaseConfig(configService: ConfigService) {
  const dbPort = configService.get<string>("DB_PORT");

  // 验证 DB_PORT 是否存在且为有效的数字
  const port = dbPort ? parseInt(dbPort, 10) : 3306;
  const config: DataSourceOptions = {
    type: "mysql",
    host: configService.get("DB_HOST") || "127.0.0.1",
    port,
    username: configService.get("DB_USERNAME"),
    password: configService.get("DB_PASSWORD"),
    database: configService.get("DB_DATABASE"),
    synchronize: Boolean(configService.get("DB_SYNCHRONIZE")),
    // 解决通过 pnpm migration:run 初始化数据时，遇到的 SET FOREIGN_KEY_CHECKS = 0; 等语句报错问题, 仅在执行数据迁移操作时设为 true
    multipleStatements: currentScript === "typeorm",
    entities: ["dist/modules/**/*.entity{.ts,.js}"],
    migrations: ["dist/migrations/*{.ts,.js}"],
    subscribers: ["dist/modules/**/*.subscriber{.ts,.js}"],
  };
  return config;
}

dataSourceProviders 

import { DataSource } from "typeorm";
import { ConfigService } from "@nestjs/config";
import { getDatabaseConfig } from "@/config/database.config";

export const DATA_SOURCE_REPOSITORY = "DATA_SOURCE";
export const databaseProviders = [
  {
    provide: DATA_SOURCE_REPOSITORY,
    inject: [ConfigService],
    useFactory: async (configService: ConfigService) => {
      const databaseConfig = getDatabaseConfig(configService);
      const dataSource = new DataSource(databaseConfig);
      return dataSource.initialize();
    },
  },
];

DataSourceModule

import { Module, Global } from '@nestjs/common';
import { databaseProviders } from './database.providers';

@Global()
@Module({
  providers: [...databaseProviders],
  exports: [...databaseProviders],
})
export class DatabaseModule {}

然后再入口处引入就行了

import { Module } from "@nestjs/common";
import { ConfigModule } from "@nestjs/config";
import { UsersModule } from "@modules/users/users.module";
import { SpaceModule } from "@modules/space/space.module";
import { DatabaseModule } from "@share/database/database.module";
import {
  AcceptLanguageResolver,
  CookieResolver,
  I18nModule,
  QueryResolver,
} from "nestjs-i18n";

@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: [".env", `.env.${process.env.NODE_ENV || "development"}`],
      // 控制是否不解析.env文件，只使用运行时注入的环境变量
      ignoreEnvFile: false,
      // 是否是全局模块
      isGlobal: true,
    }),
    I18nModule.forRoot({
      fallbackLanguage: "en",
      loaderOptions: {
        path: "src/i18n/",
        watch: true,
      },
      resolvers: [
        { use: QueryResolver, options: ["lang"] },
        new CookieResolver(["lang"]),
        AcceptLanguageResolver,
      ],
    }),
    DatabaseModule,
    UsersModule,
    SpaceModule,
  ],
  providers: [],
})
export class AppModule {}

业务中使用

import { DataSource } from "typeorm";
import { UserEntity } from "./entities/user.entity";
import { DATA_SOURCE_REPOSITORY } from "@share/database/database.providers";

export const USER_REPOSITORY = "USER_REPOSITORY";
export const userProviders = [
  {
    provide: USER_REPOSITORY,
    useFactory: (dataSource: DataSource) =>
      dataSource.getRepository(UserEntity),
    inject: [DATA_SOURCE_REPOSITORY],
  },
];

service注入

import { Injectable, Inject } from "@nestjs/common";
import { Repository } from "typeorm";
import { SpaceItem } from "./space.entity";
import { SPACE_REPOSITORY } from "@modules/space/space.providers";

@Injectable()
export class SpaceService {
  constructor(
    @Inject(SPACE_REPOSITORY)
    private repository: Repository<SpaceItem>,
  ) {}

  async findAll(): Promise<SpaceItem[]> {
    return this.repository.find();
  }

  findOne(uid: string) {
    return `This action returns a #${uid} user`;
  }

  update(uid: string) {
    return `This action updates a #${uid} user`;
  }

  remove(uid: string) {
    return `This action removes a #${uid} user`;
  }
}

demo就好了

nestjs使用TypeORM连接mysql

只需把DataSourceModule 改TypeOrmModule.forRootAsync， 比如

import { getDatabaseConfig } from "@/config/database.config";
import { SpaceModule } from "@modules/space/space.module";
import { Module } from "@nestjs/common";
import { ConfigModule, ConfigService } from "@nestjs/config";

import {
  AcceptLanguageResolver,
  CookieResolver,
  I18nModule,
  QueryResolver,
} from "nestjs-i18n";
import { TypeOrmModule } from "@nestjs/typeorm";
import { DataSource } from "typeorm";
@Module({
  imports: [
    ConfigModule.forRoot({
      envFilePath: [".env", `.env.${process.env.NODE_ENV || "development"}`],
      // 控制是否不解析.env文件，只使用运行时注入的环境变量
      ignoreEnvFile: false,
      // 是否是全局模块
      isGlobal: true,
    }),
    I18nModule.forRoot({
      fallbackLanguage: "en",
      loaderOptions: {
        path: "src/i18n/",
        watch: true,
      },
      resolvers: [
        { use: QueryResolver, options: ["lang"] },
        new CookieResolver(["lang"]),
        AcceptLanguageResolver,
      ],
    }),
    TypeOrmModule.forRootAsync({
      inject: [ConfigService],
      useFactory: (configService: ConfigService) => {
        // const loggerOptions = configService.get<string>("DB_LOGGING");
        // const logging: LoggerOptions = loggerOptions
        //   ? (JSON.parse(loggerOptions) as LoggerOptions)
        //   : ["error"];
        const databaseConfig = getDatabaseConfig(configService);
        return {
          ...databaseConfig,
          synchronize: true,
          autoLoadEntities: true,
        };
      },
      dataSourceFactory: async (options) => {
        const dataSource = await new DataSource(options!).initialize();
        return dataSource;
      },
    }),
    // UsersModule,
    SpaceModule,
  ],
  providers: [],
})
export class AppModule {}

业务处改动

import { Module } from "@nestjs/common";
import { spaceProviders } from "@modules/space/space.providers";
import { SpaceService } from "@modules/space/space.service";
import { SpaceController } from "@modules/space/space.controller";
import { TypeOrmModule } from "@nestjs/typeorm";
import { SpaceEntity } from "@modules/space/space.entity";

@Module({
  imports: [TypeOrmModule.forFeature([SpaceEntity])],
  controllers: [SpaceController],
  providers: [...spaceProviders, SpaceService],
  exports: [TypeOrmModule, SpaceService],
})
export class SpaceModule {}

service处改动

import { BusinessException } from "@/common/exceptions/biz.exception";
import { ErrorEnum } from "@constants/error-code";
import { Injectable } from "@nestjs/common";
import { Repository } from "typeorm";
import { SpaceEntity } from "@modules/space/spaceEntity";
import type { SpaceFormDto } from "@modules/space/space.dto";
import { isEmpty } from "lodash";
import { InjectRepository } from "@nestjs/typeorm";

@Injectable()
export class SpaceService {
  constructor(
    @InjectRepository(SpaceEntity)
    private readonly repository: Repository<SpaceEntity>,
  ) {}

  async findAll(): Promise<SpaceEntity[]> {
    return this.repository.find();
  }

  async findOne(uid: string, field = "uid"): Promise<SpaceEntity | null> {
    const space = await this.repository
      .createQueryBuilder("space")
      .where(`user.${field} = :${field}`, { uid })
      .getOne();
    return space;
  }

}

转载本站文章《nestjs如实连接mysql，并使用TypeORM》,
请注明出处：https://www.zhoulujun.cn/html/webfront/server/nestjs/9536.html