依赖注入：推荐的 NPM 模块注入模式

Question

我想使用 Inversify 来删除对 NPM 模块的硬依赖，并将它们作为构造函数参数注入。在我试一试之前，这似乎要简单得多。

事实证明，大多数绝对类型的模块不会费心导出接口，当它们这样做时，它们很少包含代表整个模块的接口。此外，当一个类被导出时，我仍然需要为那个类手动定义一个构造函数接口。

这意味着我必须为几乎每个模块做这样的事情：

import * as ConcreteModule from 'module'
import { ContainerModule } from 'inversify'

export interface ModuleInstance {
  // copy a ton of stuff from DefinitelyTyped repo,
  // because they didn't export any interfaces
}

export interface ModuleConstructor {
  new (...args: any[]): ModuleInstance
}

export const ModuleConstructorSymbol = Symbol('ModuleConstructor')

export const ModuleContainer = new ContainerModule((bind) => {
  bind<ModuleConstructor>(ModuleConstructorSymbol).toConstantValue(ConcreteModule)
})

有什么办法可以简化其中的一些吗？注入 NPM 模块的开销太大了，而且 Inversify 文档中没有任何指导。管理您需要的所有不同导入/导出（接口、符号和容器）的名称是一件痛苦的事情，需要提出某种一致的命名方案。似乎没有 TypeScript 支持从模块自动创建接口的某种方式，就没有办法以理智的方式注入 NPM 包。

我想我可以只对模块使用 jest 的 automock 功能，但我真的不喜欢以这样一种方式设计我的代码，即它只能使用特定的测试框架进行单元测试。

如果我可以这样做，这似乎至少可以更容易实现：

import * as ConcreteModule from 'module'

export interface TheModule extends ConcreteModule {}

但这仅在模块导出类（不是工厂）并且仍然不能真正帮助我使用构造函数时才有效。

Answer 1

以下示例演示了如何将 npm 模块 ( lodash& sequelize) 注入到类中SomeClass。

目录结构如下所示：

src/
??? entities
?   ??? some_class.ts
??? index.ts
??? ioc
    ??? interfaces.ts
    ??? ioc.ts
    ??? types.

/src/ioc/types.ts

const TYPES = {
    Sequelize: Symbol("Sequelize"),
    Lodash: Symbol("Lodash"),
    SomeClass: Symbol("SomeClass")
};

export { TYPES };

/src/ioc/interfaces.ts

import * as sequelize from "sequelize";
import * as _ from "lodash";

export type Sequelize = typeof sequelize;
export type Lodash = typeof _;

export interface SomeClassInterface {
    test(): void;
}

/src/ioc/ioc.ts

import { Container, ContainerModule } from "inversify";
import * as sequelize from "sequelize";
import * as _ from "lodash";
import { TYPES } from "./types";
import { Sequelize, Lodash } from "./interfaces";
import { SomeClass } from "../entities/some_class";

const thirdPartyDependencies = new ContainerModule((bind) => {
    bind<Sequelize>(TYPES.Sequelize).toConstantValue(sequelize);
    bind<Lodash>(TYPES.Lodash).toConstantValue(_);
    // ..
});

const applicationDependencies = new ContainerModule((bind) => {
    bind<SomeClass>(TYPES.SomeClass).to(SomeClass);
    // ..
});

const container = new Container();

container.load(thirdPartyDependencies, applicationDependencies);

export { container };

/src/entitites/some_class.ts

import { Container, injectable, inject } from "inversify";
import { TYPES } from "../ioc/types";
import { Lodash, Sequelize, SomeClassInterface } from "../ioc/interfaces";

@injectable()
class SomeClass implements SomeClassInterface {

    private _lodash: Lodash;
    private _sequelize: Sequelize;

    public constructor(
        @inject(TYPES.Lodash) lodash,
        @inject(TYPES.Sequelize) sequelize,
    ) {
        this._sequelize = sequelize;
        this._lodash = lodash;
    }

    public test() {
        const sequelizeWasInjected = typeof this._sequelize.BIGINT === "function";
        const lodashWasInjected = this._lodash.cloneDeep === "function";
        console.log(sequelizeWasInjected); // true
        console.log(lodashWasInjected); // true
    }

}

export { SomeClass };

/src/index.ts

import "reflect-metadata";
import { container } from "./ioc/ioc";
import { SomeClassInterface } from "./ioc/interfaces";
import { TYPES } from "./ioc/types";

const someClassInstance = container.get<SomeClassInterface>(TYPES.SomeClass);
someClassInstance.test();

/package.json

{
  "name": "test",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "inversify": "^4.1.0",
    "lodash": "^4.17.4",
    "reflect-metadata": "^0.1.10",
    "sequelize": "^3.30.4"
  },
  "devDependencies": {
    "@types/lodash": "^4.14.63",
    "@types/sequelize": "^4.0.51"
  }
}

/tsconfig.json

{
    "compilerOptions": {
        "target": "es5",
        "lib": ["es6", "dom"],
        "types": ["reflect-metadata"],
        "module": "commonjs",
        "moduleResolution": "node",
        "experimentalDecorators": true,
        "emitDecoratorMetadata": true
    }
}

这个例子现在在inversify docs 中可用。