Installation ❘ Features ❘ Usage | Examples
npm install injectX
This package can be used either in frontend or backend with the same installation and the same examples described bellow
- it's designed to do dependency injection for your functions using higher order functions
- simple configuration and better code organization
- built in dependency injection container
- leverage inversion of control princple usage
- can be used either on frontend or backend
- can be used either in js code or typescript
This library is based on four main components:
- A dependency that needs to be used in other code parts, it's called (dependency)
- A consumer that consumes that injected dependency
- A dependency injection container that holds all dependencies
- A dependencies resolver, its a function that resolve the needed dependencies at runtime
The injection of the dependencies is run at runtime, so don't worry about the order of dependencies injection
The dependency could be anything, it could be an object, array, variable, function, class or any value you want
I will declare a function as a dependency
const getUserName = () => {
return "john-smith"
}
It's a normal function, no magic here How can I use this function as a dependency?
you need at first bind it to the container, so you can access it from other code parts
GetContainer("default").Bind(getUsername)
GetContainer
is a function exposed from InjectX, it's responsible for binding this dependency to the container, so you can access it from somewhere else. This GetContainer
takes one param, which is the container name
As we discussed eariler, the container is a key component in injectX, it holds a reference to all the dependencies, and because your application might scale and has multiple modules, you can define multiple containers for each module, to keep each module has it's isolated dependencis
For example supposing you have the following module:
- OrdersModule
- UsersModule
- CatalogModule
Each module of these should have its own dependencies and you should avoid mixing dependencies between different modules, and to achieve that, you can define a different container for each module
The default container name for injectX is default
so you can call GetContainer
without passing the container name, and it will be resolved automatically to the default container
GetContainer().Bind(getUsername)
To Bind a dependency to the container you have to call Bind
function which takes the following arguments
argument name | type | required | description |
---|---|---|---|
dependency | any | true | this is the dependency you want to bind to the container, it could be any thing(number, string, object, array, function, class, map, symbol) |
options | object | false | some options you can define for the injected dependency |
options.name | string | false | you can define this to customize the name of the injected dependency, for example you can bind a number and make it's name as myValue so you can access it from anywhere using that defined name |
InjectX uses a friendly way for defining functions, which are higher order functions
Any dependency you want to declare you can define it as a higher order function, the first params of the dependency are the dependencies you want to inject in, and the second parameter is the actual params you are expecting to be sent to your function
for example suppose we have a repository function like this:
const getUserRepository = (username: string) => {
return db.users.find(user => user.username === username)
}
You need to provide db
to be able to use this function, in normal cases you will import the db into the global scope as the following:
import db from './db';
const getUserRepository = (username: string) => {
return db.users.find(user => user.username === username)
}
but this violates the inversion of control principle, so to use the dependency injection, you want to inject db object somehow into getUserRepository
You can use higher order function to do that, so your code will be changed to this
export const GetUserRepository = ({ db }: { db: DB }) => (username: string) => {
return db.users.find(user => user.username === username)
}
In this updated example, we are defining a higher order function, the first function takes the dependencies you want to inject, and it returns another function that holds the actual implementation
Without InjectX you can still use higher order function pattern to do dependency injection, but you will need when you call this function to pass to it the needed dependencies, which makes it complex
With injectX there is a function called InjectIn
it resolves the needed dependencies that this higher order function needs and returns a new resolved function contains the actual implementation
this function takes the following arguments:
argument name | type | required | description |
---|---|---|---|
the higher order function | higher order function | true | this is the higher order function |
options | object | false | some options you can define to resolve the higher order function |
options.containers | string[] | false | in case you want to resolve multiple dependencies from multiple containers, then you can use this option |
options.resolveType | enum: `lazy | eager` | false |
callbackName | string | false | in case you want to change the signature name of the returned function |
Example:
export const getUserReposistory = InjectIn(GetUserRepository)
the returned const getUserRepository
is basically a normal function (it's the same function that you defined) but after resolving the dependencies, then u can use this function to be injected in another consumers or call it directly
Calling the resolved function
console.log(getUserRepository("username"))
Sometimes you would have multiple containers and you want to inject dependencies from these containers in a function, to do that you can use options.containers
Example:
Suppose you have two containers:
- orders
- default
and you want to inject dependencies from each container, you can do as the following:
export const getUserReposistory = InjectIn(GetUserRepository, { containers: ['default', 'orders'] })
in this way it will inject the needed dependencies from both containers, but you also need to change the higher order function a little bit
export const GetUserRepository = ({ default: { db }, orders: { orderService } }: { default: { db: DB }, orders: { orderService: any } }) => (username: string) => {
const user = db.users.find(user => user.username === username)
const orders = orderService.getAllOrdersByUserId(user.id)
return { orders, user }
}
In the above example instead of accepting one object in the higher order function, we accept two objects for the two containers, one for default container and the another for orders