Navigator Prefabricating Marinates

    samurai-inject

    1.0.3 • Public • Published

    Samurai Inject

    A Simple IOC Container

    Coverage Status JavaScript Style Guide npm

    Installation

    Install with npm

    npm install samurai-inject --save
    

    How to use

    /*
    * Get container factory function
    */
    const { Container } =  require('samurai-inject')
    
    // Create the instance of the container
    const  container  =  Container() 
    
    class Foo {
      print () {
       console.log('Foo')
      }
    }
    
    class Bar {
      print () {
       console.log('Bar')
      }
    }
    
    // We can register classes or functions
    container.register('foo', Foo)
    container.register('bar', Bar)
    
    // And then we can resolve those classes and get the instances
    const foo = constainer.resolve('foo')
    const bar = constainer.resolve('bar')
    
    foo.print() // Output: Foo
    bar.print() // Output: Bar

    Class vs Factories

    We can use classes or factories patterns

    const { Container } =  require('samurai-inject')
    const  container  =  Container() 
    
    const Baz = () => {
      const print = () => {
        console.log('Baz')
      }
      return {
        print
      }
    }
    
    class Qux {
      print () {
       console.log('Qux')
      }
    }
    
    // We can register classes or functions
    container.register('qux', Qux)
    container.register('Baz', Baz)
    
    // And then we can resolve those classes and get the instances
    const qux = constainer.resolve('qux')
    const baz = constainer.resolve('baz')
    
    qux.print() // Output: Qux
    baz.print() // Output: Baz

    Resolve parameters as dependencies (default behavior)

    The default behavior to solve the parameters which are other objects is passing the data as a single parameter object.

    const { Container } =  require('samurai-inject')
    const  container  =  Container() 
    
    class Corge {
      // The default behavior pass an object to the constructor
      // So we can destructure the object and get the param than we want
      constructor ({
        grault
      }) {
        this.grault = grault
      }
      print () {
        console.log('Corge')
        this.grault.print()
      }
    }
    
    class Grault {
      print () {
        console.log('Grault')
      }
    }
    
    // We can register classes or functions
    // In this case we specify the dependencies in the third parameter
    container.register('corge', Corge, ['grault'])
    container.register('grault', Grault)
    
    // And then we can resolve those classes and get the instances
    const corge = constainer.resolve('corge')
    const grault = constainer.resolve('grault')
    
    corge.print() // Output: Corge Grault
    grault.print() // Output: Grault

    Resolve parameters individually

    We can override the default behavior to solve the parameters one by one sending it separately as a classical pattern used by the begin of the times.

    const { Container, PARAMS_MODE } =  require('samurai-inject')
    const  container  =  Container() 
    
    class Garply {
      constructor (waldo) {
        this.waldo = waldo
      }
      print () {
        console.log('Garply')
        this.waldo.print()
      }
    }
    class Waldo {
      print () {
        console.log('Waldo')
      }
    }
    
    // We can register classes or functions
    // In this case we specify the dependencies in the third parameter
    // In this case we specify that the parameter are gonna pass it individually
    container.register('garply', Garply, ['waldo'], PARAMS_MODE.asIndividualParams)
    container.register('waldo', Waldo)
    
    // And then we can resolve those classes and get the instances
    const garply = constainer.resolve('garply')
    const waldo = constainer.resolve('waldo')
    
    garply.print() // Output: Garply Waldo
    waldo.print() // Output: Waldo

    Static params

    Sometimes we want to pass some fixed/static parameters to our objects like a connection strings or something like that.

    const { Container } =  require('samurai-inject')
    const  container  =  Container() 
    
    class Fred {
      constructor ({
        plugh,
        connectionString
      }) {
        this.plugh = plugh
        this.connectionString = connectionString
      }
      connect () {
        console.log('Connection to ' + this.connectionString)
        console.log('Limit of rows is ' + this.plugh.getLimitOfRows)
      }
    }
    class Plugh {
      constructor ({
        limitOfRows
      }){
        this.limitOfRows = limitOfRows
      }
      getLimitOfRows () {
        return this.limitsOfRows
      }
    }
    
    // We can register classes or functions
    // In this case we specify the dependencies in the third parameter
    // In this case we can specify the static parameter using an object instead an string
    container.register('fred', Fred, ['plugh',
      { connectionString: 'mongo:mylocalmongo:2727/testdb' }
    ])
    container.register('plugh', Plugh, [
      { limitsOfRows: 100 }
    ])
    
    // And then we can resolve those classes and get the instances
    const fred = constainer.resolve('fred')
    const plugh = constainer.resolve('plugh')
    
    fred.print() 
    // Output: Connection to mongo:mylocalmongo:2727/testdb
    // Output: Limit of rows is 100
    plugh.getLimitOfRows() // Output: 100

    Install

    npm i samurai-inject

    DownloadsWeekly Downloads

    1

    Version

    1.0.3

    License

    ISC

    Unpacked Size

    14 kB

    Total Files

    13

    Last publish

    Collaborators

    • pabloitto