Koa-app-party NPM

koa-app-party

Enjoy the dark art of sub-app in koa

Usage

Mounting

var ap = require('koa-app-party');

var App1 = ap.extend(function() {
  this.use(require('./middleware/foo'));
});

var App2 = ap.extend(function() {
  this.use(require('./middleware/bar'));
});

var Root = ap.Container.extend(function() {
  this.mount('/foo', App1);
  this.mount('/bar', App2);
});

Namespace chaining

Namespace is a special container that can be shared across constructor calls of ap.App and koa contexts.

To inject dependencies into namespace, App.design is used to create a app subclass and define its namespace.

To learn more about namespace, visit othiym23/node-continuation-local-storage.

var App = ap.design('myapp', function(ns) {
  ns.set('foo', 'bar');
  assert(ns.get('origin') === 'container');
});
var Container = ap.Container.design('mycontaier', function(ns) {
  ns.set('origin', 'container');
  this.mount('foo', App);
  this.use(function*() {
    this.body = this.ns.get('foo');
  });
});

a new context is created in the constructor call of every App
if an app is mounted onto a container, in the runtime, all middlewares of this app will be run in a context that are merged from both container and app itself.
namespace will be re-created in every request session and will be deserted after response

More examples can be found in test/container_test.coffee.

API

var ap = require('koa-app-party');

ap

ap.design
Alias for ap.App.design
ap.extend
Alais for ap.App.extend
ap.App
Atomic app unit
ap.Container
Container app. Useful for mounting multiple atomic apps.

App = ap.App

App.extend(configurator)
Create a subclass from current App. A configurator function will be invoked during constructor call with app instance as current context and other arguments passed to the constructor.
App.extend(props)
A plain object can be passed to extend the prototype of subclass. props.init will be called during constructor call. And a reference to super method (if any), is available as this.super.
App.design(name, designer)
Like App.extend, but designer will be run with the namespace instance as a single argument. designer is intended to modify the namespace during the constructor call.
App.create(options)
Create a App instance with options.

var app = new App(options)

app.listen(port, callback)
Startup http server at local port assigned by port, and run callback.
app.acceptServer(server, callback) -> Promise
Before the call of server.listen(), the server instance is passed to this method to do everything you need. Return a promise to continue. Defaults to return a Promise.resolve(true).
app.inject(injector)
Run injector with namespace and callback before server.listen. Ensure callback is run, or the server will never listen.

Container = ap.Container

Subclass of App. Following class methods work just like the one on App:

Container.create
Container.design
Container.extend

var container = new ap.Container()

container.mount(prefix, app)
Mount an app at location of prefix.
container.design(info)
info is an object describing the layout of this container, such as
```
{
  '/app1': App1,
  '/app2': App2
  '/': '/app1'
}
```

Subclassing notes

Container.prototype.acceptServer is pre-defined. You should call this method if you are writing an override version of acceptServer on a container.
Always run extend or design to create subclasses.