How can I instantiate a class with injected arguments and custom arguments?

[RGBboy]

export class MyClass {

  @Inject(Service)
  constructor (service, customArgument) {
    this.service = service;
  }

  ...

}

My application has many instances of MyClass each instantiated with different customArgumnent. Is there a way to get DI to provide the injected arguments? I was thinking something similar to how in angular you can provide locals to the $injector.instantiate(expression, locals):

injector.instantiate(MyClass, { customArgument: 'customArgument' });

[vojtajina]

At this point you can do something like this:

class MyClass {
  constructor(service, customArgument) {
    // ...
  }
}

@Inject(Service)
export function instantiateMyClass(service) {
  return function(customArgument) {
    return new MyClass(service, customArgument);
  };
}

// Then, use the prebound factory (instantiateMyClass),
// rather than MyClass directly.
class SomeOther {
  @Inject(instantiateMyClass)
  constructor(instantiateMyClass) {
    for (var i = 0; i < 10; i++) {
      instantiateMyClass(i);
    }
  }
}

---

You could also ask for Injector and create a child scope with the custom arguments, but I don't like that. Everytime you ask for Injector, it smells bad, so I would like to cover at least most of the use cases without injecting Injector (at that point it is basically service locator). The code above is pretty verbose, I think we should support this as "prebound constructors". I discussed this more in https://docs.google.com/document/d/1LWxs4urzg-yQSzXOc_R8063Q14lemVqYcxd-Yp8BgZc/edit#bookmark=id.6ehf6thtt33v

[RGBboy]

Thanks @vojtajina. I just figured this out yesterday and came to the same conclusion.

[vojtajina]

Thanks for feedback, this is very valuable.

On Wed, Mar 5, 2014 at 11:54 AM, RGBboy notifications@github.com wrote:

Thanks @vojtajina https://github.com/vojtajina. I just figured this out
yesterday and came to the same conclusion.

Reply to this email directly or view it on GitHubhttps://github.com//issues/22#issuecomment-36785773
.

[jeffbcross]

+1 make this possible.

[vojtajina]

Guys, check out https://docs.google.com/document/d/1xzVDwz-hvkoaVPvHuFnm_FT7hoyvE1jSq2q3ffPB4BQ/edit#heading=h.r5y2l3pb7qvt

[vojtajina]

@RGBboy now, you can try this

class MyClass {
  @Inject(Service, 'some-token')
  constructor(service, custom) {}
}

class Foo {
  constructor(@InjectLazy(MyClass) createMyClass) {
    createMyClass('some-token', 'injected value'); 
    createMyClass('some-token', 'a different value');
  }
}

[RGBboy]

What if instead of defining tokens for the custom arguments the injector just concats what is defined in the Inject annotation with the values you pass to the function provided by the InjectLazy. E.g:

class MyClass {
  @Inject(Service) // note only Service is injected
  constructor(service, custom) {}
}

class Foo {
  constructor(@InjectLazy(MyClass) createMyClass) {
    createMyClass('injected value'); 
    createMyClass('a different value');
  }
}

I am just thinking that it could get quite confusing when you are trying to pass in multiple custom arguments. DI already has a bit of a learning curve and trying to keep its API as simple as possible would benefit everyone using it.

Would this be possible? Are there any downsides to this approach?

[vojtajina]

@RGBboy I'm not super happy with the current API either, but I don't know how to make it better ;-) Definitely something I'm open to a discussion...

I considered your proposal before. The reason why I didn't like it was that MyClass is saying what argument is being injected by the DI and what arguments are passed in by the consumer... I think MyClass should not worry about this. I think the consumer (Foo in your case) should decide. Also, MyClass can not be instantiated with just DI, it does require manually passed arguments.

I definitely want to keep the API as simple as possible.

[joshball]

I am not sure if this is just a ES5/6 syntax that I am missing, but I am trying to figure out how to instantiate an object with parameters, in ES5.
What is the proper syntax for this:

var Car = function (engine, vin, color) {
this.VIN = vin;
this.color = color;
this.engine = engine;
};
di.annotate(Car, new di.Inject(Engine));

var Engine = function (vin, engineSize) {
this.VIN = vin;
this.engineSize = engineSize;
this.state = 'stopped';
};

How do we create this?
This would be traditional:
var engine = new Engine('theVin', 'carEngineSize');
var car = new Car(engine, 'theVin', 'red');

I think I want this:
var carOptions = {
vin: 'theVin',
color: 'red',
engineSize: 'big'
};
var car = injector.get(Car, carOptions);

// DI knows car needs an Engine and a VIN, gets Engine from DI and VIN from parameter.
// DI knows that Engine needs a VIN and Size, and gets it from Car parameters
// Not sure about the annotations. I see InjectLazy, but parameters aren't really things to be created (injected).
// ??? di.annotate(Car, new di.Inject(Engine), new di.InjectLazy(String));

// I could get around this with an init method, but unfortunately in this case, I am wrapping a 3rd party library that takes a key parameter in the constructor (like the VIN in the car).

Thoughts?

[vojtajina]

You can use LazyInject:

di.annotate(Engine, new di.TransientScope);
di.annotate(Car, new di.Inject(Engine, 'vin', 'color'));
function Car(engine, vin, color) {
  // ...
}

di.annotate(Engine, new di.TransientScope);
di.annotate(Engine, new di.Inject('vin', 'engineSize'));
function Engine(vin, size) {
  // ...
}

di.annotate(run, new di.InjectLazy(Car));
function run(createCar) {
  var car1 = createCar(
    'vin', 'theVin', 
    'color', 'red',
    'engineSize', 'big'
  );
  var car2 = createCar(
    'vin', 'theVin2', 
    'color', 'blue',
    'engineSize', 'small'
  );
}

var injector = new di.Injector();
injector.get(run);

Or in your example, it would be shorter to do it manually:

function Engine(vin, size) {
  // ...  
}

function Car(engine, vin, color) {
  // ...
}


di.annotate(createCar, new di.Inject);
function createCar() {
  return function(vin, color, engineSize) {
    return new Car(new Engine(vin, engineSize), vin, color);
  }
}

di.annotate(run, new di.Inject(Car));
function run(createCar) {
  var car1 = createCar('theVin', 'red', 'big');
  var car2 = createCar('theVin2', 'blue', 'small');
}

var injector = new di.Injector();
injector.get(run);

[Rush]

Why can't we have code similar to what @joshball described? I also need ES5 support. The last example is very ugly, I was too looking to use di.js for relatively simple things but this is just scary. Looks like writing my custom tailored DI mechanism would yield nicer code ... I personally want DI to not only have better manageable code but also NICER code. Sorry for this rant but I had high hopes for your module.

[vojtajina]

You can make it nicer using some helper like this https://gist.github.com/vojtajina/9673132

@RushPL What nicer syntax do you suggest?
I think using the annotations looks pretty good.

As for @joshball's suggestion, let's take this code...

var Car = function (engine, vin, color) {
  // ...
};
di.annotate(Car, new di.Inject(Engine));

var Engine = function (vin, engineSize) {
  // ...
};

How would you instantiate Car?

di.annotate(main, new Inject(Car));
function main(car) {
  // ... what here? car can't be instance of Car,
  // you need provide missing dependencies (Car -> vin, Car -> color, Engine -> vin, Engine ->engineSize)
  // HOW? How do you specify what is Engine deps and what Car deps?
}

Any suggestions?