Product
Introducing License Enforcement in Socket
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
The avvio npm package is designed to handle the asynchronous bootstrapping of applications, particularly those built with Node.js. It allows developers to define a series of asynchronous (or synchronous) tasks that need to be executed in a specific order during the startup phase of an application. This can include initializing databases, setting up dependencies, or any other setup tasks that need to be completed before the application starts serving requests. Avvio ensures that each task is completed before moving on to the next, and it provides a clean API for managing this process.
Plugin System
Avvio allows you to structure your application initialization in a modular way using plugins. Each plugin can be an asynchronous function that performs some initialization tasks. The `use` method is used to register these plugins, and Avvio ensures they are executed in the order they are registered.
const avvio = require('avvio')(app);
avvio.use(function (instance, opts, done) {
// async initialization task
done();
});
Async/Await Support
Avvio supports modern JavaScript async/await syntax out of the box. This allows for cleaner and more readable asynchronous code within your initialization tasks.
const avvio = require('avvio')(app);
avvio.use(async function (instance, opts) {
// async task using await
});
Encapsulation and Context
Avvio provides a mechanism for encapsulation and context sharing across plugins. Using the `decorate` method, you can add properties or methods to the application instance that can be accessed by subsequent plugins, facilitating a shared context.
const avvio = require('avvio')(app);
avvio.use(function (instance, opts, done) {
instance.decorate('utility', () => {});
done();
});
Fastify is a web framework for Node.js that includes a powerful plugin architecture, somewhat similar to Avvio. While Fastify is more focused on building web applications and APIs, it uses an underlying plugin system inspired by Avvio for managing the application lifecycle.
Pino is a very fast JSON logger for Node.js, and while it doesn't offer plugin-based application bootstrapping like Avvio, it can be integrated into applications using Avvio for structured and efficient logging throughout the application lifecycle.
Seneca is a microservices toolkit for Node.js that allows you to write microservices easily and quickly. It offers a plugin system that can be seen as similar to Avvio's, focusing on the modular construction of applications, though it is more oriented towards microservice architecture.
Asynchronous bootstrapping made easy. Wait for all components/plugins to start, and then start your whole app.
avvio
is fully reentrant and graph-based. You can load
components/plugins within plugins, and be still sure that things will
happen in the right order.
To install avvio
, simply use npm:
npm install avvio --save
The example below can be found here and ran using node example.js
. It
demonstrates how to use avvio
to load functions /
plugins in
order.
'use strict'
const boot = require('avvio')()
boot
.use(first, { hello: 'world' })
.after((cb) => {
console.log('after first and second')
cb()
})
.use(third, (err) => {
if (err) {
console.log('something bad happened')
console.log(err)
}
console.log('third plugin loaded')
})
.ready(function () {
console.log('application booted!')
})
function first (instance, opts, cb) {
console.log('first loaded', opts)
instance.use(second, cb)
}
function second (instance, opts, cb) {
console.log('second loaded')
process.nextTick(cb)
}
function third (instance, opts, cb) {
console.log('third loaded')
cb()
}
Start a boot sequence.
instance
will be used as the first
argument of all plugins loaded and use
, after
and ready
function will be
added to that object, keeping the support for the chainable API:
const server = {}
require('avvio')(server)
server.use(function first (s, opts, cb) {
// s is the same of server
s.use(function second (s, opts, cb) {
cb()
}, cb)
}).after(function (cb) {
// after first and second are finished
cb()
})
Options:
expose
: a key/value property to change how use
, after
and ready
are exposed.Events:
'error'
if something bad happens'start'
when the application startsThe boot
function can be used also as a
constructor to inherits from.
Loads a functions asynchronously. The function must have the signature:
function plugin (server, opts, done) {
done()
}
done
must be called only once.
Returns the instance on which use
is called, to support a
chainable API.
If you need to add more than a function and you don't need to use a different options object or callback, you can pass an array of functions to .use
.
boot.use([first, second, third], opts, cb)
The functions will be loaded in the same order as they are inside the array.
Calls a functon after all the previously defined plugins are loaded, including
all their dependencies. The 'start'
event is not emitted yet.
boot.after(function (done) {
done()
})
done
must be called only once.
Returns the instance on which after
is called, to support a
chainable API.
Calls a functon after all the plugins and after
call are
completed, but befer 'start'
is emitted. ready
callbacks are
executed one at a time.
boot.ready(function (done) {
done()
})
done
must be called only once.
Returns the instance on which ready
is called, to support a
chainable API.
Same as:
const app = express()
boot(app, {
expose: {
use: 'load'
}
})
Allows to override the instance of the server for each loading plugin. It allows the creation of an inheritance chain for the server instances.
const boot = require('avvio')
const assert = require('assert')
const server = { count: 0 }
const app = boot(server)
console.log(app !== server, 'override must be set on the Avvio instance')
app.override = function (s) {
// create a new instance with the
// server as the prototype
const res = Object.create(s)
res.count = res.count + 1
return res
}
app.use(function first (s1, opts, cb) {
assert(s1 !== server)
assert(server.isPrototypeOf(s1))
assert(s1.count === 1)
s1.use(second, cb)
function second (s2, opts, cb) {
assert(s2 !== s1)
assert(s1.isPrototypeOf(s2))
assert(s2.count === 2)
cb()
}
})
This project was kindly sponsored by nearForm.
Copyright Matteo Collina 2016, Licensed under MIT.
FAQs
Asynchronous bootstrapping of Node applications
The npm package avvio receives a total of 1,436,946 weekly downloads. As such, avvio popularity was classified as popular.
We found that avvio demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 10 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Product
Ensure open-source compliance with Socket’s License Enforcement Beta. Set up your License Policy and secure your software!
Product
We're launching a new set of license analysis and compliance features for analyzing, managing, and complying with licenses across a range of supported languages and ecosystems.
Product
We're excited to introduce Socket Optimize, a powerful CLI command to secure open source dependencies with tested, optimized package overrides.