如何在NestJS中为外部模块注入Sequelize数据库连接？

我在NestJS文档中未找到相关资料，遇到了如下问题：开发的NestJS应用需使用多个可复用的外部自定义模块（如FilterModule），该模块需要使用Sequelize数据库连接。我设想了一种实现方式，但不清楚DatabaseModule和DatabaseService应如何编写，相关代码示例如下：

@Module({
    imports: [
        FilterModule.forRootAsync({
            import: [DatabaseModule],
            inject: [DatabaseService],
            useFactory: (databaseService: DatabaseService) => ({
                connection: databaseService.getConnection()
            })
        }),
    ],
    controllers: [AppController],
    providers: [
        AppService,
    ],
})
export class AppModule {}

希望在外部Filter模块中能够使用该数据库连接，示例代码如下（将在外部模块中实现）：

@Injectable()
export class FilterService {

    private connection: Sequelize;

    constructor(
        @Inject('CONNECTION') filterConnection: Sequelize
    ) {
        this.connection = filterConnection;
    }

    applyFilter() {
        // some code using connection
    }

}

同时在主应用中可以这样使用：

@Injectable()
export class TestService {


    constructor(
        private filterService: FilterService
    ) {
    }

    findAll(params: any) {

        const sequelizeQuery = this.filterService.applyFilter(params);

        // some other code...

    }

}

请问这种方式在NestJS中是否可行？还是需要其他实现方案？另外说明：上述外部模块目前基于基础Node.js编写，我正寻求将其改写为适配NestJS的实现方式。

这种实现思路完全可行，属于NestJS动态模块（异步配置）的标准用法，下面给出完整的代码实现方案：

1. DatabaseModule与DatabaseService实现 #

首先实现全局的数据库模块，负责创建和管理Sequelize连接：

// database.module.ts
import { Module, Global } from '@nestjs/common';
import { Sequelize } from 'sequelize-typescript';
import { DatabaseService } from './database.service';

@Global() // 标记为全局模块，无需在其他模块重复导入
@Module({
  providers: [
    {
      provide: Sequelize,
      useFactory: async () => {
        const sequelize = new Sequelize({
          // 替换为你的数据库配置
          dialect: 'mysql',
          host: 'localhost',
          port: 3306,
          username: 'root',
          password: 'your_password',
          database: 'your_db',
          models: [/* 导入你的Sequelize模型类 */],
          autoLoadModels: true,
          synchronize: false,
        });
        await sequelize.authenticate(); // 验证连接有效性
        return sequelize;
      },
    },
    DatabaseService,
  ],
  exports: [Sequelize, DatabaseService], // 导出供其他模块注入使用
})
export class DatabaseModule {}

// database.service.ts
import { Injectable, Inject } from '@nestjs/common';
import { Sequelize } from 'sequelize-typescript';

@Injectable()
export class DatabaseService {
  constructor(@Inject(Sequelize) private readonly sequelize: Sequelize) {}

  getConnection(): Sequelize {
    return this.sequelize;
  }
}

2. 适配NestJS的FilterModule实现 #

将原基础Node.js模块改写为NestJS动态模块，支持异步接收数据库连接：

// filter.module.ts
import { Module, DynamicModule, Provider } from '@nestjs/common';
import { FilterService } from './filter.service';

// 定义模块配置项类型
export interface FilterModuleOptions {
  connection: Sequelize;
}

@Module({})
export class FilterModule {
  // 同步配置方式
  static forRoot(options: FilterModuleOptions): DynamicModule {
    const connectionProvider: Provider = {
      provide: 'CONNECTION',
      useValue: options.connection,
    };

    return {
      module: FilterModule,
      providers: [connectionProvider, FilterService],
      exports: [FilterService], // 导出FilterService供主应用使用
    };
  }

  // 异步配置方式（对应你设想的用法）
  static forRootAsync(options: {
    imports: any[];
    inject: any[];
    useFactory: (...args: any[]) => Promise<FilterModuleOptions> | FilterModuleOptions;
  }): DynamicModule {
    const connectionProvider: Provider = {
      provide: 'CONNECTION',
      useFactory: options.useFactory,
      inject: options.inject,
    };

    return {
      module: FilterModule,
      imports: options.imports,
      providers: [connectionProvider, FilterService],
      exports: [FilterService],
    };
  }
}

FilterService保持你原有的实现即可，无需改动：

// filter.service.ts
import { Injectable, Inject } from '@nestjs/common';
import { Sequelize } from 'sequelize-typescript';

@Injectable()
export class FilterService {
  private connection: Sequelize;

  constructor(@Inject('CONNECTION') filterConnection: Sequelize) {
    this.connection = filterConnection;
  }

  applyFilter(params: any) {
    // 这里编写基于Sequelize连接的过滤逻辑
    return this.connection.models.YourModel.findAll({
      where: {/* 根据params生成查询条件 */}
    });
  }
}

3. 主应用用法验证 #

你给出的AppModule和TestService写法基本正确，仅需修正一处笔误：

// app.module.ts
@Module({
    imports: [
        FilterModule.forRootAsync({
            imports: [DatabaseModule], // 修正笔误：原代码写的是单数import，需改为复数imports
            inject: [DatabaseService],
            useFactory: (databaseService: DatabaseService) => ({
                connection: databaseService.getConnection()
            })
        }),
    ],
    controllers: [AppController],
    providers: [AppService, TestService], // 添加TestService到providers数组
})
export class AppModule {}

// test.service.ts
@Injectable()
export class TestService {
    constructor(private filterService: FilterService) {}

    findAll(params: any) {
        const sequelizeQuery = this.filterService.applyFilter(params);
        // 后续业务逻辑处理
    }
}

额外注意事项 #

• 可以给CONNECTION定义一个常量令牌替代字符串硬编码，提升类型安全性：

  // filter.constants.ts
  export const CONNECTION_TOKEN = Symbol('CONNECTION');
  

  然后在FilterModule的provider和FilterService的@Inject中使用CONNECTION_TOKEN即可

内容的提问来源于stack exchange，提问作者romanholota