Add support for multiple registrations

[jeffijoe]

Add support for multiple registrations

[jeffijoe]

I love these questions!

This is very easy to do because of the way Awilix' resolver system works. 😃

const container = createContainer()
  .register({
    // Let's use a custom resolver!
    createdEventHandlers: asArray([
      asClass(DatabaseEventHandler),
      asClass(MessageBusEventHandler)
    ]),
    deletedEventHandler: asArray([
      asClass(CleanUpEventHandler)
    ])
  })
  
/**
 * Given an array of resolvers, returns a resolver that
 * resolves to an array of resolved values... RESOLVER!
 */
function asArray(resolvers) {
  return {
    resolve: (container, opts) => resolvers.map(r => container.build(r, opts))
  }
}

Thanks for the great question!

EDIT: fix example

[benjcallaghan]

@jeffijoe Thank you for your suggestion. I tweaked your resolver function a little bit to better fit the TypeScript system, as well as my own needs. The following works perfectly for me.

function asArray<T>(resolvers: Resolver<T>[]): Resolver<T[]> {
    return {
        resolve: c => resolvers.map(r => r.resolve(c))
    };
}

container .register({
    // Let's use a custom resolver!
    createdEventHandlers: asArray([
      asClass(DatabaseEventHandler),
      asClass(MessageBusEventHandler)
    ]),
    deletedEventHandler: asArray([
      asClass(CleanUpEventHandler)
    ])
  })

[jeffijoe]

No problem! I forgot that the resolver is an object with a resolve function and not just a function so this was on me. 😄

[jeffijoe]

Happy to help!

[japoneizo]

Hi, @jeffijoe!

I'm trying to do the same thing. But I'm getting a

TypeError: resolver.resolve is not a function

https://github.com/eizonishime/poc-dependency-injection-nodejs/blob/master/index.js#L14

and I'm using asArray as you suggested:
https://github.com/eizonishime/poc-dependency-injection-nodejs/blob/master/helper/AwilixHelper.js#L2

Again, I'm probably doing something very silly.

You can see my tests in this repo: https://github.com/eizonishime/poc-dependency-injection-nodejs

[jeffijoe]

@eizonishime I most likely screwed up my own example 😅

This should work:

/**
 * Given an array of resolvers, returns a resolver that
 * resolves to an array of resolved values... RESOLVER!
 */
function asArray(resolvers) {
  return {
    resolve: (container, opts) => resolvers.map(r => container.build(r, opts))
  }
}

[japoneizo]

Oh sorry, I didn't pay attention to the syntax.
And it worked now.

Thanks again!

[arjangeertsema]

I love these questions!

This is very easy to do because of the way Awilix' resolver system works. smiley

const container = createContainer()
  .register({
    // Let's use a custom resolver!
    createdEventHandlers: asArray([
      asClass(DatabaseEventHandler),
      asClass(MessageBusEventHandler)
    ]),
    deletedEventHandler: asArray([
      asClass(CleanUpEventHandler)
    ])
  })
  
/**
 * Given an array of resolvers, returns a resolver that
 * resolves to an array of resolved values... RESOLVER!
 */
function asArray(resolvers) {
  return {
    resolve: (container, opts) => resolvers.map(r => container.build(r, opts))
  }
}

Thanks for the great question!

EDIT: fix example

@jeffijoe: an even more elegant solution is to register de dependencies and to resolve an array of names so that is is easy to reuse the registrations and change to array contents. Which is ideal for a plugin architecture.

const container = createContainer()
    .register({
        databaseEventHandler: asClass(DatabaseEventHandler),
        messageBusEventHandler: asClass(MessageBusEventHandler),
        cleanUpEventHandler: asClass(CleanUpEventHandler),
        
        // Let's use a custom resolver!
        createdEventHandlers: asArray([
            'databaseEventHandler',
            'messageBusEventHandler'
        ]),
        deletedEventHandler: asArray([
            'cleanUpEventHandler'
        ])
    })


function asArray(names) {
    return {
        resolve: (container, opts) => names.map(name => container.resolve(name, opts))
    }
}

or even better make it possible to register an array of names which is automaticly resolved by the engine:

const container = createContainer()
    .register({
        databaseEventHandler: asClass(DatabaseEventHandler),
        messageBusEventHandler: asClass(MessageBusEventHandler),
        cleanUpEventHandler: asClass(CleanUpEventHandler),
        
        // Let the engine resolve!
        createdEventHandlers: [
            'databaseEventHandler',
            'messageBusEventHandler'
        ],
        deletedEventHandler: [
            'cleanUpEventHandler'
        ]
    })
}