What about multibindings?

[agibalov]

Hinoki seems to be the least surprising IoC container available for Node. I definitely do like its ascetic worldview. Thanks a lot for this! Yet, are there any plans for the future releases?

I was wondering if it's possible to achieve something like this with the current 0.3.0-beta.16:

var container = {
  values: { a: 11, b: 22, c: 33 },
  factories: {
    handlers: [ // factory functions may return promises as well
      function(a, b) { return new HandlerA(a, b); },
      function(a, c) { return new HandlerB(a, c); },
      function(a, b, c) { return new HandlerC(a, b, c); }
    ]
  }
};

hinoki.get(container, 'handlers').then(function(handlers) {
  // handlers[0] - an instance of HandlerA
  // handlers[1] - an instance of HandlerB
  // handlers[2] - an instance of HandlerC
});

[snd]

hey andrey,

i'm glad you like it !

what you propose is an interesting idea.

lets call it factory-arrays:
if a factory is an array treat it as an array of factories, inject dependencies into each factory, collect the products and make that array of products the final product of the factory-array.

the idea could be extended to factory-objects:

// example code 1
var container = {
  values: { a: 11, b: 22, c: 33 },
  factories: {
    handlers:
      handlerA: function(a, b) { return new HandlerA(a, b); },
      handlerB: function (a, c) { return new HandlerB(a, c); },
      handlerC: function(a, b, c) { return new HandlerC(a, b, c); }
    ]
  }
};

hinoki.get(container, 'handlers').then(function(handlers) {
  // handlers.handlerA - an instance of HandlerA
  // handlers.handlerB - an instance of HandlerB
  // handlers.handlerC - an instance of HandlerC
});

both factory-arrays and factory-objects are not currently implemented.
i never had a use case for that.

i am kind of hesitant to implement it right now as it would introduce additional complexity.

you can achieve something very similar like this:

// example code 2
var container = {
  values: { a: 11, b: 22, c: 33 },
  factories: {
    handlers: function(a, b, c) {
      return [
        new HandlerA(a, b),
        new HandlerB(a, c),
        new HandlerC(a, b, c)
      ];
    }
  }
};

// this stays identical to your example
hinoki.get(container, 'handlers').then(function(handlers) {
  // handlers[0] - an instance of HandlerA
  // handlers[1] - an instance of HandlerB
  // handlers[2] - an instance of HandlerC
});

at the moment i don't see the advantages of adding the factory-arrays feature over example code 2.
i try to keep the code small and simple. sometimes that means leaving out features.
i'll implement factory-arrays if you give me an example where factory-arrays have a significant benefit over other solutions.

---

as for the future of hinoki and plans for future releases:

the current 0.3.0-beta.16 is very stable, thoroughly tested and used in production.
the documentation is seriously lacking however.

i didn't expect there to be any other users of hinoki at the moment because its such an abstract library.
that's the reason for the lack of good documentation right now.

you can expect a real, non-beta release sometime during april.
that release will include good documentation and replace hinoki's resolvers with something that is simpler and less surprising.

hinoki is at the core of a library (fragments) we (a loose collective of developers)
are using as the base for every nodejs project.
we are heavily invested in hinoki and will support it for a long time.

there haven't been many changes to hinoki lately because its there silently working in the background reliably doing everything we need it to.

---

Hinoki seems to be the least surprising IoC container available for Node. I definitely do like its ascetic worldview. Thanks a lot for this!

i really like your choice of words here.

can i use that in the upcoming readme ? :)

best,

max

[agibalov]

Hi @snd,

Thanks a lot for answering. Let me describe to you my motivation for the factory-arrays feature:

// example code 3
var container = {
  values: { 
    Router: require('koa-router')
  },
  factories: {
    handlers: [
      require('/api/routes/createThing'),
      require('/api/routes/getThing'),
      require('/api/routes/updateThing')
      // let's say there are 10 of them
    ],
    theMiddleware: function(Router, handlers) {
      var router = new Router();
      handlers.forEach(function(registerHandler) {
        registerHandler(router);
      });
      return router.middleware();
    }
  }
};

// the createThing.js is:
module.exports = function(thingValidator, thingRepository, thingFactory, thingMapper) {
  return function(router) {
    router.post('/things', function *() {
      var body = this.request.body;
      thingValidator.throwIfNotValid(body);
      var thing = thingFactory.makeThing(body);
      thing = thingRepository.saveThing(thing);
      var thingDTO = thingMapper.makeThingDTO(thing);
      this.status = 201;
      this.body = thingDTO;      
    });
  };
};

So basically, there's a bunch of handlers, I want to instantiate them via DI, but I never need to refer to the individual instances.

you can expect a real, non-beta release sometime during april.
that release will include good documentation and replace hinoki's resolvers with something that is simpler and less surprising.

That's good to hear! Thanks!

can i use that in the upcoming readme ? :)

Sure :-)

[snd]

thanks for giving a real world example of your use-case.
now i get why you want factory-arrays.

after thinking about this a bit i found a use-case for factory-objects that i'm exited to use myself.

i'll implement both factory-arrays and factory-objects !

[agibalov]

Hey, that's great news, thanks! What's your use-case for the factory-objects?

[snd]

hey andrey,

i wanted to give you an update:
both factory-objects and factory-arrays are fully implemented and tested.
along with many other useful changes.
see this branch if you like: https://github.com/snd/hinoki/tree/resolver-reform

it's not yet released as i still need to document it.
soon! i'll let you know.

[agibalov]

@snd, thanks a lot!

[snd]

i've released release candidate 1 for version 1.0.0 to npm (1.0.0-rc.1).
check it out !

there are some breaking changes.
i've changed fundamental things (abstractions) about hinoki which seem to fit better overall.
it's probably best to read the readme again: https://github.com/snd/hinoki
the readme is not finished. it should already be useful though.

everywhere you read factory you can use a factory-object or factory-array as well.

if you have any questions: i'm happy to answer !