Framework for rapidly creating high quality, server-side node.js applications, using plugins like building blocks
The 'base' npm package is a framework for rapidly building high-quality node.js applications, using plugins like building blocks. It's designed to be a foundation on which to build complex applications.
Plugin Management
Base allows you to easily manage and use plugins, enabling modular application development. Plugins can add specific functionalities to the base application, which can be initialized and used as needed.
const Base = require('base');
const app = new Base();
app.use(require('some-plugin'));
app.init();Event Handling
Base provides an event handling system. You can define custom events and handlers, making it easy to manage events within your application.
const Base = require('base');
const app = new Base();
app.on('event', () => console.log('Event triggered!'));
app.emit('event');Task Execution
Base supports defining and running tasks. This feature allows you to organize code into tasks that can be executed on demand, simplifying complex operations into manageable units.
const Base = require('base');
const app = new Base();
app.task('do something', () => console.log('Task done!'));
app.run('do something');Express is a web application framework for Node.js, designed for building web applications and APIs. It differs from Base in that it's specifically tailored for HTTP server functionality, whereas Base is more generalized and plugin-oriented.
Hapi is another Node.js framework for building applications and services. Hapi is similar to Base in that it supports plugins, but it is more focused on server-side applications and provides a robust configuration-led approach, compared to Base's flexible plugin system.
Base is a foundation for creating modular, unit testable and highly pluggable server-side node.js APIs.
Most importantly, once you learn Base, you will be familiar with the core API of all applications built on Base. This means you will not only benefit as a developer, but as a user as well.
The core team follows these principles to help guide API decisions:
Compact API surface: The smaller the API surface, the easier the library will be to learn and use.
Easy to extend: Implementors can use any npm package, and write plugins in pure JavaScript. If you're building complex apps, Base dramatically simplifies inheritance.
Easy to test: No special setup should be required to unit test Base or base plugins
100% Node.js core style
The API was designed to provide only the minimum necessary functionality for creating a useful application, with or without plugins.
Base core
Base itself ships with only a handful of useful methods, such as:
.set: for setting values on the instance.get: for getting values from the instance.has: to check if a property exists on the instance.define: for setting non-enumerable values on the instance.use: for adding pluginsBe generic
When deciding on method to add or remove, we try to answer these questions:
Plugin system
It couldn't be easier to extend Base with any features or custom functionality you can think of.
Base plugins are just functions that take an instance of Base:
var base = new Base();
function plugin(base) {
// do plugin stuff, in pure JavaScript
}
// use the plugin
base.use(plugin);
Add "smart plugin" functionality with the base-plugins plugin.
Inheritance
Easily inherit Base using .extend:
var Base = require('base');
function MyApp() {
Base.call(this);
}
Base.extend(MyApp);
var app = new MyApp();
app.set('a', 'b');
app.get('a');
//=> 'b';
Inherit or instantiate with a namespace
By default, the .get, .set and .has methods set and get values from the root of the base instance. You can customize this using the .namespace method exposed on the exported function. For example:
var Base = require('base');
// get and set values on the `base.cache` object
var base = Base.namespace('cache');
var app = base();
app.set('foo', 'bar');
console.log(app.cache.foo);
//=> 'bar'
NPM
Install with npm:
$ npm install --save base
yarn
Install with yarn:
$ yarn add base && yarn upgrade
var Base = require('base');
var app = new Base();
// set a value
app.set('foo', 'bar');
console.log(app.foo);
//=> 'bar'
// register a plugin
app.use(function() {
// do stuff (see API docs for ".use")
});
Create an instance of Base with the given config and options.
Params
config {Object}: If supplied, this object is passed to cache-base to merge onto the the instance upon instantiation.options {Object}: If supplied, this object is used to initialize the base.options object.Example
// initialize with `config` and `options`
var app = new Base({isApp: true}, {abc: true});
app.set('foo', 'bar');
// values defined with the given `config` object will be on the root of the instance
console.log(app.baz); //=> undefined
console.log(app.foo); //=> 'bar'
// or use `.get`
console.log(app.get('isApp')); //=> true
console.log(app.get('foo')); //=> 'bar'
// values defined with the given `options` object will be on `app.options
console.log(app.options.abc); //=> true
Set the given name on app._name and app.is* properties. Used for doing lookups in plugins.
Params
name {String}returns {Boolean}Example
app.is('foo');
console.log(app._name);
//=> 'foo'
console.log(app.isFoo);
//=> true
app.is('bar');
console.log(app.isFoo);
//=> true
console.log(app.isBar);
//=> true
console.log(app._name);
//=> 'bar'
Returns true if a plugin has already been registered on an instance.
Plugin implementors are encouraged to use this first thing in a plugin to prevent the plugin from being called more than once on the same instance.
Params
name {String}: The plugin name.register {Boolean}: If the plugin if not already registered, to record it as being registered pass true as the second argument.returns {Boolean}: Returns true if a plugin is already registered.Events
emits: plugin Emits the name of the plugin being registered. Useful for unit tests, to ensure plugins are only registered once.Example
var base = new Base();
base.use(function(app) {
if (app.isRegistered('myPlugin')) return;
// do stuff to `app`
});
// to also record the plugin as being registered
base.use(function(app) {
if (app.isRegistered('myPlugin', true)) return;
// do stuff to `app`
});
Define a plugin function to be called immediately upon init. Plugins are chainable and expose the following arguments to the plugin function:
app: the current instance of Basebase: the first ancestor instance of BaseParams
fn {Function}: plugin function to callreturns {Object}: Returns the item instance for chaining.Example
var app = new Base()
.use(foo)
.use(bar)
.use(baz)
The .define method is used for adding non-enumerable property on the instance. Dot-notation is not supported with define.
Params
key {String}: The name of the property to define.value {any}returns {Object}: Returns the instance for chaining.Example
// arbitrary `render` function using lodash `template`
app.define('render', function(str, locals) {
return _.template(str)(locals);
});
Mix property key onto the Base prototype. If base is inherited using Base.extend this method will be overridden by a new mixin method that will only add properties to the prototype of the inheriting application.
Params
key {String}val {Object|Array}returns {Object}: Returns the base instance for chaining.Example
app.mixin('foo', function() {
// do stuff
});
Getter/setter used when creating nested instances of Base, for storing a reference to the first ancestor instance. This works by setting an instance of Base on the parent property of a "child" instance. The base property defaults to the current instance if no parent property is defined.
Example
// create an instance of `Base`, this is our first ("base") instance
var first = new Base();
first.foo = 'bar'; // arbitrary property, to make it easier to see what's happening later
// create another instance
var second = new Base();
// create a reference to the first instance (`first`)
second.parent = first;
// create another instance
var third = new Base();
// create a reference to the previous instance (`second`)
// repeat this pattern every time a "child" instance is created
third.parent = second;
// we can always access the first instance using the `base` property
console.log(first.base.foo);
//=> 'bar'
console.log(second.base.foo);
//=> 'bar'
console.log(third.base.foo);
//=> 'bar'
Static method for adding global plugin functions that will be added to an instance when created.
Params
fn {Function}: Plugin function to use on each instance.returns {Object}: Returns the Base constructor for chainingExample
Base.use(function(app) {
app.foo = 'bar';
});
var app = new Base();
console.log(app.foo);
//=> 'bar'
Static method for inheriting the prototype and static methods of the Base class. This method greatly simplifies the process of creating inheritance-based applications. See static-extend for more details.
Params
Ctor {Function}: constructor to extendmethods {Object}: Optional prototype properties to mix in.returns {Object}: Returns the Base constructor for chainingExample
var extend = cu.extend(Parent);
Parent.extend(Child);
// optional methods
Parent.extend(Child, {
foo: function() {},
bar: function() {}
});
Used for adding methods to the Base prototype, and/or to the prototype of child instances. When a mixin function returns a function, the returned function is pushed onto the .mixins array, making it available to be used on inheriting classes whenever Base.mixins() is called (e.g. Base.mixins(Child)).
Params
fn {Function}: Function to callreturns {Object}: Returns the Base constructor for chainingExample
Base.mixin(function(proto) {
proto.foo = function(msg) {
return 'foo ' + msg;
};
});
Static method for running global mixin functions against a child constructor. Mixins must be registered before calling this method.
Params
Child {Function}: Constructor function of a child classreturns {Object}: Returns the Base constructor for chainingExample
Base.extend(Child);
Base.mixins(Child);
Similar to util.inherits, but copies all static properties, prototype properties, and getters/setters from Provider to Receiver. See class-utils for more details.
Params
Receiver {Function}: Receiving (child) constructorProvider {Function}: Providing (parent) constructorreturns {Object}: Returns the Base constructor for chainingExample
Base.inherit(Foo, Bar);
Base is used as the foundation for all of the applications in the toolkit suite (except for enquirer):
Building blocks
Lifecycle
Developer frameworks and command line tools that address common phases of the software development lifecycle. Each of these tools can be used entirely standalone, but they work even better together.
data method to base-methods. | homepagebase application. | homepageoption, enable and disable. See the readme… more | homepagepkg method that exposes pkg-store to your base application. | homepageRunning and reviewing unit tests is a great way to get familiarized with a library and its API. You can install dependencies and run tests with the following command:
$ npm install && npm test
Pull requests and stars are always welcome. For bugs and feature requests, please create an issue.
If Base doesn't do what you need, please let us know.
Changelog entries are classified using the following labels from keep-a-changelog:
added: for new featureschanged: for changes in existing functionalitydeprecated: for once-stable features removed in upcoming releasesremoved: for deprecated features removed in this releasefixed: for any bug fixesCustom labels used in this changelog:
dependencies: bumps dependencieshousekeeping: code re-organization, minor edits, or other changes that don't fit in one of the other categories.Heads up!
Please let us know if any of the following heading links are broken. Thanks!
Fixed
__callbacks and super_ are non-enumberableAdded
app.type when app.is('foo') is called. This allows Base instances to be used more like AST nodes, which is especially helpful with smart pluginsMajor breaking changes!
.use and .run methods are now non-enumerableMajor breaking changes!
.is no longer takes a function, a string must be passed.debug code has been removedapp._namespace was removed (related to debug).plugin, .use, and .define no longer emit events.assertPlugin was removed.lazy was removed(Changelog generated by helper-changelog)
Jon Schlinkert
Brian Woodward
Copyright © 2017, Jon Schlinkert. MIT
This file was generated by verb-generate-readme, v0.6.0, on December 17, 2017.
FAQs
Framework for rapidly creating high quality, server-side node.js applications, using plugins like building blocks
The npm package base receives a total of 12,506,041 weekly downloads. As such, base popularity was classified as popular.
We found that base demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 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.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.