标签: inversifyjs

我有一个使用Inversify的打字稿Vue SPA项目。

我使用了awesome-typescript-loader来编译我的打字稿源代码。现在我想切换到Babel，但是当我编译我的应用程序webpack时会出现以下错误：

模块解析失败：意外字符'@'（38:25）您可能需要
适当的加载程序来处理此文件类型。
| _inherits（ReportService，_BaseService）;
| >函数ReportService（@inject（TYPES.Urls）
|网址）{
| var _this;
@ ./app/Ioc/container.ts 6：0-54 14：39-52
@ ./app/startup.ts

.babelrc

{
    "presets": [
        "@babel/env",
        "@babel/preset-typescript"
    ],
    "plugins": [
        ["@babel/plugin-proposal-decorators", { "legacy": true }],
        "@babel/proposal-class-properties",
        "@babel/proposal-object-rest-spread"
    ]
}

tsconfig.json

{
  "compilerOptions": {
    "baseUrl": ".",
    "paths": {
      "test/*": [ "test/*" ],
      "@/*": [ "app/*" ]
    },
    "lib": [ "es6", "dom" ], // es6 minimum required for Promise
    "target": "es6", // Required for vuetify
    "strict": …

我有一个使用 inversify 的现有打字稿项目。我已经在我的 TYPES 中定义了一个记录器，TYPES.ILoggger当我直接从我的容器访问记录器时，它可以工作：

import {ILogger} from "./interfaces/ILogger";
import {TYPES} from "./interfaces/TYPES";
import container from "./kernel/inversify.config";

const loggerFromTheContainer: ILogger = container.get<ILogger>(TYPES.ILogger);
loggerFromTheContainer.info("I WILL LOG"); // this works

所以我的设置应该没问题。

我不想直接访问容器，但我想使用属性注入。[InversifyJS' README提供了一个例子：

如果你喜欢它，你可以使用属性注入而不是构造函数注入，这样你就不必声明类构造函数：

@injectable()
class Ninja implements Warrior {
    @inject(TYPES.Weapon) private _katana: Weapon;
    @inject(TYPES.ThrowableWeapon) private _shuriken: ThrowableWeapon;
    public fight() { return this._katana.hit(); }
    public sneak() { return this._shuriken.throw(); }
}

Run Code Online (Sandbox Code Playgroud)

我试着遵循那个。

然而，当我尝试通过属性注入来注入记录器时，我突然undefined变成了一个记录器，我不知道为什么：

@injectable()
class ShouldHaveLogger {
    @inject(TYPES.ILogger) private logger: ILogger;

    constructor() {
        this.logger.info("Hello World"); // this.logger …

我有一个用于视图渲染的函数文件，我想在这里使用 nestjs 模块服务。我的渲染文件是这样的。

export default {
  parse() { }
  render() { }
}

所以要在这里使用模块服务，我尝试像这样注入。

import { Inject } from '@nestjs/common';
import { MemberService } from './member.service';

class SampleClass {
  constructor(@Inject('MemberService') private readonly memberService: MemberService) {}
}

// Creating class in here to use in functions
const sampleService = new SampleClass();

export default {
  parse() { }
  render() { }
}

当我尝试在这里创建新类时出现错误“预期有 1 个参数但得到 0”

我的会员服务是这样的

@Injectable()
export class MemberService {
  constructor(@Inject(Constants.RelationshipMemberModel) private readonly relationshipMemberModel: typeof Model) {}
  login () {} …

在InversifyJS中,遵循工厂注入指南和构造函数注入指南中概述的方法,分别仅使用toDynamicValue注入工厂和构造器,是否有任何特定的优点.

我正在使用 inversify、inversify-binding-decorators 和 inversify-express-utlis，并且在使用 express 中间件时遇到了问题。

我以这种方式调用我的中间件：

let server = new InversifyExpressServer(container);
...
server.setConfig((app) => {

  app.use(validateSession);

});
...

这是我的 ioc 注册课程。请注意，这里我在请求范围内手动注册了 SessionContext

import DatabaseApi  from './../repositories/databaseApi';
import { Container, inject } from "inversify";
import TYPES from "./types";
import { autoProvide, makeProvideDecorator, makeFluentProvideDecorator } from "inversify-binding-decorators";
import { SessionContext } from './../services/session/sessionContext';
let container = new Container();
container.bind<SessionContext>(TYPES.SessionContext).to(SessionContext).inRequestScope();
let provide = makeProvideDecorator(container);
let fluentProvider = makeFluentProvideDecorator(container);

let provideNamed = (identifier: any, name: any) => {
  return fluentProvider(identifier)
    .whenTargetNamed(name)
    .done();
}; …

我正在使用inversify与inversify-express-utils.

我有一个很平常的inversify/express设置。

• 控制器
  • 服务
    • 一个模块
      • B模块

B module是一个如下所示的类：

import { injectable } from 'inversify';
import SpellCorrector from 'spelling-corrector';

@injectable()
export class SpellCorrectorFactory {
  private corrector: any;

  constructor() {
    this.corrector = new SpellCorrector();
    this.corrector.loadDictionary();
  }

  public correct = (text: string): string => this.corrector.correct(text);
}

现在，这里的问题是，正如您在构造函数中看到的，我有这行代码：

this.corrector.loadDictionary()

该行需要一秒钟多的时间来执行。所以基本上看起来实际的实例创建是在我为服务提供服务@inject时发生的 所以每次我发出请求时，都会执行 的构造函数，因此请求需要超过 1000 毫秒而不是低于 100 毫秒。BASpellCorrectorFactory

如何将此类绑定到 inversify，以便在绑定期间实例化该类，并且在A module我可以访问在应用程序启动时创建的实例，而不是在我向快速路径发送请求时？

提前致谢！

我在编译代码时遇到错误：找不到 serviceIdentifier: Symbol(LicencesService) 的匹配绑定 以下是与该问题相关的代码。问题在于 server.ts 文件上 HTTP 的构造函数，如何正确注入 LicensesService？

我的打字文件：-

const TYPES = {
  LicencesService:Symbol.for('LicencesService')
}
export { TYPES }

我的 server.ts 文件：-

import { LogsRepository } from './repositories/logs'
 import { TelemetryRepository } from './repositories/telemetry'
 import { AdminRouter, AuthRouter, BotsRouter, ModulesRouter } from './routers'
 import { ContentRouter } from './routers/bots/content'
 import { ConverseRouter } from './routers/bots/converse'
 import { HintsRouter } from './routers/bots/hints'
 import { NLURouter } from './routers/bots/nlu'
 import { isDisabled } from './routers/conditionalMiddleware'
 import { InvalidExternalToken, PaymentRequiredError } …

需要有关Inversify相关实现的帮助.我正在创建一个从节点扩展EventEmitter的类.当我尝试使用反转时,它说EventEmitter不可注射.以下是示例代码

//接口

export interface ISubscriber {
Connect(callback: Function);
on(event: string, listener: Function): this;
emit(event: string, ...args: any[]): boolean;
}

//类

import {EventEmitter} from 'events';


@injectable()
class Subscriber extends EventEmitter implements ISubscriber {
logProvider: SCLogging.ILogger;
public constructor(
    @inject(TYPES.ILogger) logProvider: SCLogging.ILogger,
    @inject(TYPES.IConfig) config: IConfig
) {
    super();
    //Some Implementation
}

public Connect(callback) {
//Some Implementation
}

public on(event: string, listener: Function): this {
    super.on(event, listener);
    return this;
}

public emit(event: string, ...args: any[]): boolean {
    return super.emit(event, ...args);
}
}
export { …

我正在使用 nodejs、express 和 inversify 构建一个非常小的 rest api。

这是我的工作代码：

索引.ts

 const container = new Container();
 container.bind<interfaces.Controller>(Types.Controller)
          .to(MyController)
          .whenTargetNamed(Targets.Controller.MyController);

 container.bind<Types.Service>(Types.Service)
          .to(MyService)
          .whenTargetNamed(Targets.Services.MyService);


 const server = new InversifyExpressServer(container); 
 const app = server.build();
 app.listen(3000);

mycontroller.ts

 @injectable()
 @controller('/api/test')
 export class MyController {

  constructor(@inject(Types.Service) 
                  @named(Targets.Service.MyService) 
                  private MyService: MyService) { }

  @httpGet('/')
  public getCompanies(req: Request, res: Response, next: any): Promise<any[]> 
  {
    console.log('getTestData');
    return this.MyService.fetchAll();
  }
}  

上面的代码工作正常。当我想使用中间件来检查身份验证令牌时，问题就出现了。

authmiddleware.ts

function authMiddlewareFactory( 
{
  return (config: { role: string }) => 
  {
    return (req: Request, res: Response, next: any): void …

我正在尝试将反脚本与typescript和node.js结合使用。我当前使用的是Node.js版本6.9.1，打字稿版本2.6.2和ECMAScript6。当我尝试运行node.js应用程序时，我一直收到以下错误，“ TypeError：Reflect.hasOwnMetadata不是一个函数”。

根据我在网上找到的文档，通过在inversify.config.js文件顶部添加导入“ reflect-matadata”，它似乎可以工作一段时间，但是现在问题又回来了。

在我的inversify.config.ts文件中，有以下代码从我的app.ts文件中调用：

export let initialize = async (): Promise<Container> => {
        var container = new Container();

        try {
                if (!Reflect.hasOwnMetadata("inversify:paramtypes", ClassToAddInjectableTo)) {
                        decorate(injectable(), ClassToAddInjectableTo);
                }

                ….

            container.bind<interfaces.Controller>(TYPE.Controller).to(MyController1).whenTargetNamed('MyController1');
            container.bind<interfaces.Controller>(TYPE.Controller).to(MyController2).whenTargetNamed('MyController2');
        } catch (ex) {
            throw ex;
        }
}

此代码存在于app.ts中，它调用inversify.config.ts文件中的代码：

setup = async () => {
    try {
        let container: Container = await initialize();
        …..

    } catch (err){
        throw err;
    }
}

问题似乎在node_modules / inversify / lib / annotation / decorator_utils.js：22的以下行中：

if (Reflect.hasOwnMetadata(metadataKey, annotationTarget) === true) {

在生成的inversify.config.js文件中，以下代码似乎在导入“ reflect-metadata”上方：

var …