Question

我正在通过尝试实现干净的体系结构来对Nestjs进行试验，并且我想验证我的解决方案，因为我不确定我是否知道执行此操作的最佳方法。请注意，该示例几乎是伪代码，并且缺少许多类型或泛型，因为它们不是讨论的重点。

从我的域逻辑开始，我可能想在类似于以下的类中实现它：

@Injectable()
export class ProfileDomainEntity {
  async addAge(profileId: string, age: number): Promise<void> {
    const profile = await this.profilesRepository.getOne(profileId)
    profile.age = age
    await this.profilesRepository.updateOne(profileId, profile)
  }
}

这里我需要访问profileRepository，但是遵循干净架构的原理，我现在不想为实现而烦恼，所以我为此写了一个接口：

interface IProfilesRepository {
  getOne (profileId: string): object
  updateOne (profileId: string, profile: object): bool
}

然后，我将依赖项注入ProfileDomainEntity构造函数中，并确保它遵循预期的接口：

export class ProfileDomainEntity {
  constructor(
    private readonly profilesRepository: IProfilesRepository
  ){}

  async addAge(profileId: string, age: number): Promise<void> {
    const profile = await this.profilesRepository.getOne(profileId)
    profile.age = age

    await this.profilesRepository.updateOne(profileId, profile)
  }
}

然后创建一个简单的内存实现，让我运行代码：

class ProfilesRepository implements IProfileRepository {
  private profiles = {}

  getOne(profileId: string) {
    return Promise.resolve(this.profiles[profileId])
  }

  updateOne(profileId: string, profile: object) {
    this.profiles[profileId] = profile
    return Promise.resolve(true)
  }
}

现在是时候使用模块将所有东西都连接在一起了：

@Module({
  providers: [
    ProfileDomainEntity,
    ProfilesRepository
  ]
})
export class ProfilesModule {}

这里的问题是显然ProfileRepository实现了IProfilesRepository，但不是IProfilesRepository，因此，据我所知，令牌是不同的，Nest无法解决依赖关系

我找到的唯一解决方案是使用自定义提供程序来手动设置令牌：

@Module({
  providers: [
    ProfileDomainEntity,
    {
      provide: 'IProfilesRepository',
      useClass: ProfilesRepository
    }
  ]
})
export class ProfilesModule {}

并通过指定要与ProfileDomainEntity一起使用的令牌来修改@Inject：

export class ProfileDomainEntity {
  constructor(
    @Inject('IProfilesRepository') private readonly profilesRepository: IProfilesRepository
  ){}
}

这是用来处理所有依赖项的合理方法还是我完全偏离轨道？有更好的解决方案吗？对于所有这些东西（NestJs，干净的体系结构/ DDD和Typescript），我还是一个新手，所以在这里我可能完全错了。

谢谢

Answer 1

由于语言限制/功能resolve dependency by the interface in NestJS，无法(see structural vs nominal typing)。

并且，如果您使用接口定义依赖项（类型），则必须使用字符串标记。但是，您也可以使用类本身，也可以将其名称用作字符串文字，因此，在注入依赖类的构造函数期间，无需提及它。

示例：

// *** app.module.ts ***
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { AppServiceMock } from './app.service.mock';

process.env.NODE_ENV = 'test'; // or 'development'

const appServiceProvider = {
  provide: AppService, // or string token 'AppService'
  useClass: process.env.NODE_ENV === 'test' ? AppServiceMock : AppService,
};

@Module({
  imports: [],
  controllers: [AppController],
  providers: [appServiceProvider],
})
export class AppModule {}

// *** app.controller.ts ***
import { Get, Controller } from '@nestjs/common';
import { AppService } from './app.service';

@Controller()
export class AppController {
  constructor(private readonly appService: AppService) {}

  @Get()
  root(): string {
    return this.appService.root();
  }
}

您还可以使用抽象类而不是接口，或为接口和实现类提供相似的名称（并就地使用别名）。

是的，与C＃/ Java相比，这看起来很脏。请记住，接口仅是设计时。在我的示例中，AppServiceMock和AppService甚至都不是从接口或抽象类/基类继承的（当然，在现实世界中，它们应该）并且只要它们实现方法{{1 }}。

引用the NestJS docs on this topic：

注意

我们使用了ConfigService类，而不是自定义标记，因此我们覆盖了默认实现。

Answer 2

您确实可以使用接口以及抽象类。一种打字稿功能是从类（保留在JS world中）中推断接口，因此类似的事情会起作用

IFoo.ts

export abstract class IFoo {
    public abstract bar: string;
}

Foo.ts

export class Foo 
    extends IFoo
    implement IFoo
{
    public bar: string
    constructor(init: Partial<IFoo>) {
        Object.assign(this, init);
    }
}

const appServiceProvider = {
  provide: IFoo,
  useClass: Foo,
};

Nestjs依赖注入和DDD /干净架构

2 个答案: