inversio-loader

Convention based initialization of inversio containers.

Load components and dependencies from file structure using file patterns, single file components and modules.

API

cwd (current working directory) denotes root folder for searches.

filter should either be a

• predicate as in path -> boolean
• string (glob) that will be converted to a minimatch predicate.

new Loader({pattern?})

Construct new loader instance. If pattern is specified, it will be passed as default to discover({cwd, pattern}).

create({pattern?}) -> Loader

Shorthand for creating Loader instance.

const loader = require('inversio-loader').create

let continer = await loader().use(...).discover(...).component(...).load()

.use(module) -> Loader

Allow module to register. Module should be a

function moduleFunction (loader) {
    // loader.discover(...)
    // loader.use(...)
    // loader.component(...)
  }

or

async function asyncModuleFunction (loader) { ... }

.use(...modules) -> Loader

Register multiple modules.

.discover({cwd, pattern}) -> Loader

pattern defaults to pattern specified in constructor. cwd is root folder for single file component search.

Single file components should be like

module.exports.install = container =>
  container.component(...)

container is an inversio container instance.

.component({name, factory, depends?, tags?, order?, ...}) -> Loader

Shorthand for registering a component the inversio way.

.component(...components) -> Loader

Register multiple components.

.load() -> Promise(container)

Return inversio container with all components registered.

Example:

// ./app/foo.comp.js
// single file component 'foo'
module.exports.install = container => container.component({
  name: 'foo',
  factory: () => new Bar()
})

// ./modules/module-x.js
// module referring to multiple components in modules/**/*.comp.js
module.exports = loader => loader.discover({
  cwd: __dirname,
  filter: '*.comp.js'
})

// index.js
var Loader = require('inversio-loader')

let container = await new Loader()
  .use(require('./modules/module-x.js'))
  .discover({
    cwd: './app',
    filter: '*.comp.js'
  })
  .load()

// resolve component
let foo = await container.resolve('foo') // -> instance of Bar