Typescript 当使用来自其他模块的枚举时，NestJs尝试解析依赖项

我无法理解在解析依赖项时为什么要考虑enum

情况如下：

我有两个功能文件夹。让我们称之为FeatureUrea和FeatureB。在这方面做得不多。此功能的最小工作示例是：

feature-a.module.ts:

import { Module } from '@nestjs/common';
import { FeatureAService } from './feature-a.service';

@Module({
    providers: [FeatureAService],
})
export class FeatureAModule {}

import { Injectable } from '@nestjs/common';
import { STUFF_B_ONLY } from '../FeatureB/feature-b.service';

@Injectable()
export class FeatureAService {
    public doSomeStuff(): string {
        return 'Doing stuff: ' + STUFF_B_ONLY.A; // <--- Problems with this line, enum
    }
}

import { Module } from '@nestjs/common';
import { FeatureAService } from '../FeatureA/feature-a.service';
import { FeatureBService } from './feature-b.service';

@Module({
    providers: [FeatureAService, FeatureBService],
})
export class FeatureBModule {}

import { Injectable } from '@nestjs/common';
import { FeatureAService } from '../FeatureA/feature-a.service';

export enum STUFF_B_ONLY {
    A = 'a',
    B = 'b',
}

@Injectable()
export class FeatureBService {
    constructor(private readonly featureAService: FeatureAService) {}

    public do(): void {
        this.featureAService.doSomeStuff();
    }
}

feature-a.service.ts:

import { Module } from '@nestjs/common';
import { FeatureAService } from './feature-a.service';

@Module({
    providers: [FeatureAService],
})
export class FeatureAModule {}

import { Injectable } from '@nestjs/common';
import { STUFF_B_ONLY } from '../FeatureB/feature-b.service';

@Injectable()
export class FeatureAService {
    public doSomeStuff(): string {
        return 'Doing stuff: ' + STUFF_B_ONLY.A; // <--- Problems with this line, enum
    }
}

import { Module } from '@nestjs/common';
import { FeatureAService } from '../FeatureA/feature-a.service';
import { FeatureBService } from './feature-b.service';

@Module({
    providers: [FeatureAService, FeatureBService],
})
export class FeatureBModule {}

import { Injectable } from '@nestjs/common';
import { FeatureAService } from '../FeatureA/feature-a.service';

export enum STUFF_B_ONLY {
    A = 'a',
    B = 'b',
}

@Injectable()
export class FeatureBService {
    constructor(private readonly featureAService: FeatureAService) {}

    public do(): void {
        this.featureAService.doSomeStuff();
    }
}

feature-b.service.ts:

import { Module } from '@nestjs/common';
import { FeatureAService } from './feature-a.service';

@Module({
    providers: [FeatureAService],
})
export class FeatureAModule {}

import { Injectable } from '@nestjs/common';
import { STUFF_B_ONLY } from '../FeatureB/feature-b.service';

@Injectable()
export class FeatureAService {
    public doSomeStuff(): string {
        return 'Doing stuff: ' + STUFF_B_ONLY.A; // <--- Problems with this line, enum
    }
}

import { Module } from '@nestjs/common';
import { FeatureAService } from '../FeatureA/feature-a.service';
import { FeatureBService } from './feature-b.service';

@Module({
    providers: [FeatureAService, FeatureBService],
})
export class FeatureBModule {}

import { Injectable } from '@nestjs/common';
import { FeatureAService } from '../FeatureA/feature-a.service';

export enum STUFF_B_ONLY {
    A = 'a',
    B = 'b',
}

@Injectable()
export class FeatureBService {
    constructor(private readonly featureAService: FeatureAService) {}

    public do(): void {
        this.featureAService.doSomeStuff();
    }
}

在feature-b.service.ts中，我只是从featureAService调用

doSomeStuff（）

但问题是：我在

feature-a.service.ts

中使用了

feature-b.service.ts

中的枚举，出于某种原因，NestJs试图解决所有依赖项，即使枚举一般不在

@Injectable

提供程序和类中。此枚举不是featureB的一部分，不应引发任何错误

错误消息：

错误：嵌套无法解析FeatureBService（？）的依赖项。 请确保索引[0]处的参数依赖关系为 在FeatureBModule上下文中可用

可能的解决办法：

• 如果dependency是一个提供者，它是当前FeatureBModule的一部分吗

• 如果依赖项是从单独的@Module导出的，那么该模块是否在FeatureBModule中导入@模块({
  导入：[/*包含依赖项的模块*/]}）

找到的两种解决方案是：

• 将enum移动到generic.ts文件，即使在模块中也不行，但这种方法并不总是最好的，如果添加大量不同的enum，可能会造成拥挤

• 用基本字符串替换枚举值（

  STUFF_B_ONLY.A

  ），但这种方法对我无效

那么，为什么NestJs试图解析对enum的依赖关系，我是否遗漏了什么（提供/注入/导入）？或者移到通用的.ts文件是这里的唯一选项？

---

如果需要，主模块文件：

import { Module } from '@nestjs/common';
import { FeatureAModule } from './FeatureA/feature-a.module';
import { FeatureBModule } from './FeatureB/feature-b.module';

@Module({
  imports: [
    FeatureAModule,
    FeatureBModule,
  ],
})
export class AppModule {}

---

我认为发生这种情况的主要原因是，嵌套扫描程序运行代码，查看文件的所有导入和导出，以及使用

@module（）

装饰器中定义的模块元数据。在这里，由于两个服务之间的导入和导出，您已经在这两个服务之间创建了一个循环依赖关系。使用Nest提供的

forwardRef

函数，有一种只使用模块而不需要新文件的方法来解决此问题，如下所示：

功能模块

从'@nestjs/common'导入{Module，forwardRef}；
从“/feature-a.service”导入{FeatureAService}；
从'src/feature-b/feature-b.module'导入{FeatureBModule}；
@模块({
导入：[forwardRef（（）=>FeatureBModule）]，
提供者：[功能服务]，
导出：[功能服务]，
})
导出类功能模块{}

特色服务

从'@nestjs/common'导入{Injectable}；
从“../feature-B/feature-B.service”导入{STUFF_FROM_B}；
@可注射（）
导出类功能服务{
多斯塔夫（）{
log（'Doing stuff:\t'+stuff_FROM_B.A.）；
}
}

功能B模块 功能B服务

从'@nestjs/common'导入{Injectable，injection，forwardRef}；
从'src/feature-a/feature-a.service'导入{FeatureAService}；
从\u B导出枚举内容\u{
A=‘A’，
B=‘B’，
}
@可注射（）
导出类功能服务{
构造函数（@Inject（forwardRef（（）=>FeatureAService））私有只读FeatureAService:FeatureAService{}
doStuff（）：void{
this.featureAService.doStuff（）；
}
}

---

这不一定是一种坏的做法，但一般来说，应该避免循环依赖，原因如下。大多数情况下，Nest会警告服务之间的循环依赖关系，但由于这是文件之间的循环依赖关系，这就解释了为什么它没有像预期的那样被捕获

我认为发生这种情况的主要原因是，嵌套扫描程序运行代码，查看文件的所有导入和导出，以及使用

@module（）

装饰器中定义的模块元数据。在这里，由于两个服务之间的导入和导出，您已经在这两个服务之间创建了一个循环依赖关系。使用Nest提供的

forwardRef

函数，有一种只使用模块而不需要新文件的方法来解决此问题，如下所示：

功能模块

从'@nestjs/common'导入{Module，forwardRef}；
从“/feature-a.service”导入{FeatureAService}；
从'src/feature-b/feature-b.module'导入{FeatureBModule}；
@模块({
导入：[forwardRef（（）=>FeatureBModule）]，
提供者：[功能服务]，
导出：[功能服务]，
})
导出类功能模块{}

特色服务

从'@nestjs/common'导入{Injectable}；
从“../feature-B/feature-B.service”导入{STUFF_FROM_B}；
@可注射（）
导出类功能服务{
多斯塔夫（）{
log（'Doing stuff:\t'+stuff_FROM_B.A.）；
}
}

功能B模块 功能B服务

从'@nestjs/common'导入{Injectable，injection，forwardRef}；
从'src/feature-a/feature-a.service'导入{FeatureAService}；
从\u B导出枚举内容\u{
A=‘A’，
B=‘B’，
}
@可注射（）
导出类功能服务{
构造函数（@Inject（forwardRef（（）=>FeatureAService））私有只读FeatureAService:FeatureAService{}
doStuff（）：void{
this.featureAService.doStuff（）；
}
}

---

这不一定是一种坏的做法，但一般来说，应该避免循环依赖，原因如下。大多数情况下，Nest会警告服务之间的循环依赖关系，但由于这是文件之间的循环依赖关系，这就解释了为什么它没有像预期的那样被捕获

我不知道

forwardRef（）

实用程序。对其进行了测试，似乎正在工作。：）但在这种情况下，移动到不同的（通用）文件可能比使用

forwardRef（）

更好（因为这是可以避免的）