Partial injection in Inversify

Question

Partial injection in Inversify

How can I perform partial properties injection using Inversify?

Imagine we have a class like this:

class MyClass {
    constructor(
        @inject(EXTERNAL_A) private externalA: ExternalClassA,
        private b: string
    ) {}
}

Is there a way to utilize MyClass with inversify in other classes if all the possible values of b are known at compile time? Essentially, I only need instances of MyClass with b = "a" and b = "b".

The solution I have come across so far involves defining two different bindings or using a factory to directly instantiate new MyClass.

In the first scenario, I would need to do something like this:

container.bind<MyClass>(CLASS_A).toConstantValue(
    new MyClass(container.get<ExternalClassA>(EXTERNAL_A), "a")
);

container.bind<MyClass>(CLASS_B).toConstantValue(
    new MyClass(container.get<ExternalClassA>(EXTERNAL_A), "b")
);

This approach seems messy and does not address the issue of constructing deep object hierarchies manually.

What is the optimal solution here?

An advanced challenge would be if it's possible to resolve dependency trees by replacing the same single dependency with a provided one. For example, consider:

 |-----B-----e
A|-----C-----e
 |-----D
 |-----e

I want to replace the e dependency with my custom one. How can this be achieved?

typescript dependency-injection inversion-of-control inversifyjs

Answer 1

Answer №1

If you want to associate a factory with your inversify container, you can do so using the toFactory method. It's worth noting that the factory can accept arguments.

For more information, visit: https://github.com/inversify/InversifyJS/blob/master/wiki/factory_injection.md

Below is an example tailored to your specific scenario.

container
    .bind<(b: string) => MyClass>("MyClassFactory")
    .toFactory<MyClass>((context: interfaces.Context) => {
      return (b: string) => {
        const classA = context.container.get<ExternalClassA>("EXTERNAL_A")

        return new MyClass(classA, b)
      }
    })

In essence, we are associating a function with identifier "MyClassFactory", which generates an instance of MyClass based on the provided arguments.

Since we fetch EXTERNAL_A from the container through inversify, we don't need to handle its dependencies ourselves.

To utilize your factory...

@injectable()
class SomeClass {
  @inject("MyClassFactory") private myClassFactory!: (b: string) => MyClass

  someMethod() {
    const myClassA = this.myClassFactory('a')
    const myClassB = this.myClassFactory('b')
  }
}

It's important to note that in your initial setup, you utilize toConstantValue which constructs and binds classes as singletons. If this behavior is intentional, you can still employ the above factory...

container.bind<MyClass>("CLASS_A").toDynamicValue((context: interfaces.Context) => { 
  const myClassFactory = context.container.get<(b: string) => MyClass>("MyClassFactory")
  return myClassFactory('a')
})

container.bind<MyClass>("CLASS_B").toDynamicValue((context: interfaces.Context) => { 
  const myClassFactory = context.container.get<(b: string) => MyClass>("MyClassFactory")
  return myClassFactory('b')
})

You could also programmatically create singletons. For instance, if you had an array of objects like

{identifier: "CLASS_A", factoryArg: 'a'}

, you could iterate over it and generate dynamic values as demonstrated above.

In reference to your last question, I realize this response has become quite lengthy, but consider exploring this section in the documentation for potential insights: https://github.com/inversify/InversifyJS/blob/master/wiki/recipes.md#overriding-bindings-on-unit-tests

Answer 2

If you want to associate a factory with your inversify container, you can do so using the toFactory method. It's worth noting that the factory can accept arguments.

For more information, visit: https://github.com/inversify/InversifyJS/blob/master/wiki/factory_injection.md

Below is an example tailored to your specific scenario.

container
    .bind<(b: string) => MyClass>("MyClassFactory")
    .toFactory<MyClass>((context: interfaces.Context) => {
      return (b: string) => {
        const classA = context.container.get<ExternalClassA>("EXTERNAL_A")

        return new MyClass(classA, b)
      }
    })

In essence, we are associating a function with identifier "MyClassFactory", which generates an instance of MyClass based on the provided arguments.

Since we fetch EXTERNAL_A from the container through inversify, we don't need to handle its dependencies ourselves.

To utilize your factory...

@injectable()
class SomeClass {
  @inject("MyClassFactory") private myClassFactory!: (b: string) => MyClass

  someMethod() {
    const myClassA = this.myClassFactory('a')
    const myClassB = this.myClassFactory('b')
  }
}

It's important to note that in your initial setup, you utilize toConstantValue which constructs and binds classes as singletons. If this behavior is intentional, you can still employ the above factory...

container.bind<MyClass>("CLASS_A").toDynamicValue((context: interfaces.Context) => { 
  const myClassFactory = context.container.get<(b: string) => MyClass>("MyClassFactory")
  return myClassFactory('a')
})

container.bind<MyClass>("CLASS_B").toDynamicValue((context: interfaces.Context) => { 
  const myClassFactory = context.container.get<(b: string) => MyClass>("MyClassFactory")
  return myClassFactory('b')
})

You could also programmatically create singletons. For instance, if you had an array of objects like

{identifier: "CLASS_A", factoryArg: 'a'}

, you could iterate over it and generate dynamic values as demonstrated above.

In reference to your last question, I realize this response has become quite lengthy, but consider exploring this section in the documentation for potential insights: https://github.com/inversify/InversifyJS/blob/master/wiki/recipes.md#overriding-bindings-on-unit-tests

Answer 3

Answer №2

Greetings,

Unfortunately, there isn't a one-size-fits-all solution to this issue. In situations like these, I usually opt for a factory pattern with a set or setup method.

For instance:

interface MyInterface {
     myPublicMethod();
}

type MyInterfaceFactoryA = () => MyInterface;
type MyInterfaceFactoryB = () => MyInterface;

class MyClass extends MyInterface {

     private b: string;

     constructor(
          @inject(EXTERNAL_A) private externalA: ExternalClassA,
     ) {}

     public setup(b: string): void {
          this.b = b;
     }

}

During the container setup process, typically within a ContainerModule, you would need to do something similar to the following:

 bind<MyClass>("MyClass").to(MyClass);

 container.bind<MyInterface>(CLASS_A).toConstantValue(
      const myClass = context.container.get<MyClass>("MyClass");
      return myClass.setup("a");
 );

 container.bind<MyInterface>(CLASS_B).toConstantValue(
     const myClass = context.container.get<MyClass>("MyClass");
     return myClass.setup("a");
 );

Then, you can utilize it as follows:

 class MyOtherClass {

      constructor(
          @inject(CLASS_A) private _myInterfaceInstanceA: MyInterface,
          @inject(CLASS_B) private _myInterfaceInstanceB: MyInterface) {

      }

 }

I hope this information proves helpful. For further details, you may refer to: https://github.com/inversify/InversifyJS/issues/530

Answer 4

Greetings,

Unfortunately, there isn't a one-size-fits-all solution to this issue. In situations like these, I usually opt for a factory pattern with a set or setup method.

For instance:

interface MyInterface {
     myPublicMethod();
}

type MyInterfaceFactoryA = () => MyInterface;
type MyInterfaceFactoryB = () => MyInterface;

class MyClass extends MyInterface {

     private b: string;

     constructor(
          @inject(EXTERNAL_A) private externalA: ExternalClassA,
     ) {}

     public setup(b: string): void {
          this.b = b;
     }

}

During the container setup process, typically within a ContainerModule, you would need to do something similar to the following:

 bind<MyClass>("MyClass").to(MyClass);

 container.bind<MyInterface>(CLASS_A).toConstantValue(
      const myClass = context.container.get<MyClass>("MyClass");
      return myClass.setup("a");
 );

 container.bind<MyInterface>(CLASS_B).toConstantValue(
     const myClass = context.container.get<MyClass>("MyClass");
     return myClass.setup("a");
 );

Then, you can utilize it as follows:

 class MyOtherClass {

      constructor(
          @inject(CLASS_A) private _myInterfaceInstanceA: MyInterface,
          @inject(CLASS_B) private _myInterfaceInstanceB: MyInterface) {

      }

 }

I hope this information proves helpful. For further details, you may refer to: https://github.com/inversify/InversifyJS/issues/530

Partial injection in Inversify

Answer №1

Answer №2

Similar questions

Transforming time into luxon time frames and hours

Display Nested Data in Angular Material Table: A Step-by-Step Guide

Are there any code paths that do not result in a return value?

NestJS TypeORM InjectRepository throwing an error: "Cannot access property 'prototype' of undefined"

Can Aurelia components be designed to communicate values back to their parent elements?

Narrowing types for arrays based on their discriminants

What is the best method for saving data from a reactive form to local storage?

Scrolling to the bottom of an ion-content in Ionic 4

Unable to replicate the function

I need assistance with using the angular-oauth2-oidc library to retrieve data from an asynchronous storage provider and then pass it to a synchronous storage implementation

Encountering a Jest issue where the error "Unable to use import statement outside a module" is thrown when trying to import node-fetch in CommonJS format

What is the correct way to properly parse JSON attributes containing slashes?

Which data structure is suitable for storing a JSON object?

Empty spaces are mandatory here

Ways to implement a non-Typescript javascript library

Converting numbers to strings based on locale in React Native

Testing Functions Defined on Window Object in Jest and TypeScript: A Comprehensive Guide

The type 'Object' is missing the property 'properties' for this object

Safari mobile and iOS app fail to activate lifecycle hooks as expected

Exploring the details of an object in Ionic 4: A guide to checking elements