What's new?

• Awesome fix for the awesome "initialize" method to awesomely call only once. Succeeding awesome calls to awesome App.start() will not trigger the awesome "initialize" method. This was supposed to be part of the initial design but was missed as I was blinded by how awesome it was already working and I was excited to release it.

What's new?

• Multiple App and Kontext
• Redesigned APIs

This release is not backwards compatible with the alpha release.

Kola

    npm install kola --save

Getting Started

App

Everything is an app in kola. To create an app, you extend kola.App and define your application's startup paramater type.
Here we have a MailingList App that will accept any object that has a property host of type string

import kola = require("kola");

export class MailingList extends kola.App<{host: string}> {

}

App.initialize(kontext: kola.Kontext, opts?:T)

This is where you can setup your application's kontext. The opts parameter is the one being passed through App.start(opts);

import kola = require('kola');
import hooks = require('kola-hooks');

class MailingList extends kola.App<{host: string}> {

    initialize(kontext: kola.Kontext, opts?: string): void {
        kontext.setSignal<{email: string}>('register',
                                hooks.executes([cmd.validateEmail, cmd.registerEmail, cmd.congratulateUser])
                                    .breakChainOnError(true),
                                    .onError(cmd.apologizeToUser)
                                );

        kontext.setSignal<{email: string}>('unregister',
                                hooks.executes([cmd.validateEmail, cmd.unregisterEmail])
                                    .breakChainOnError(true),
                                    .onError(cmd.apologizeToUser)

        kontext.setInstance('service.mailingList', () => {
            return new MailingListService()
        }.asSingleton();
    }

}

Kontext

The Kontext is where you can store instances and signals for your application.

Kontext.setSignal(name: string, hook: Hook): SignalHook

Kontext.setSignal() allows you to define a signal name and a hook which is any object that implements Hook. This will
return a SignalHook instance where you can define if this hook should only run once.

    kontext.setSignal<any>('initialize', {
        execute: (payload: any, kontext: Kontext) => {
            //do funky initialization stuff here!
        }
    }).runOnce(); //run initialization only once

There is kola-hooks which you can use as a factory to create your hook.

Kontext.getSignal(name: string): signals.Dispatcher

This will return an instance of signals.Dispatcher with the name you've define in setSignal(). This will return null
if you haven't define any.

Kontext.setInstance(name: string, factory: () => T): void

Kontext.setInstance() allows you to define a factory with a given name. This returns a KontextFactory instance where you
can set if the factory is singleton or not.

kontext.setInstance<MailingListService>('service.mailingList', () => {
    return new MailingListService();
}).asSingleton(); //returns only one instance.

kontext.setInstance<Request>('service.request', () => {
    return new Request();
}) //returns a new instance everytime you call kontext.getInstance()

App.start(opts?: T): kola.App

It is where you can pass arguments for your application to use before it sets up the kontext.

App.onStart(): void

This is called after initialization. This method is meant to be overridden by the application to do custom behaviour when
application starts.

App.onStop(): void

This is called when App.stop() is called. This method is meant to be overridden to do custom behaviour when application stops.

Multiple App and Kontext

When creating a kola App, you can choose whether to extend another App or a standalone. By extending another App you get
to inherit all its Kontext instances and signals.

import parent = require('./parent/app');
import child = require('./child/app');

var parentApp = new parent.App();
var childApp = new child.App(parentApp); //this enables us to inherit instances and signals from parent.

Kontext.setInstance() on a child App

When you set an instance in a child App, that instance will only be available to that child. Even if you try to set it with a
key that has the same name in the parent.

Kontext.getInstance() from a child App

As everything is inherited from the parent, getting an instance with a key that was define in the parent will return you
an instance from that parent. The logic when getting an instance is that it would check first locally if a factory is define for
that instance otherwise it would check its parent. If you have a deep hierarchy of apps, the check will be perform recursively until
it finds the factory or until it reached its root parent.

Kontext.setSignal() on a child App

Setting a signal works differently from setting an instance. When you set a signal, it checks first if that signal is already
defined in the current Kontext and if you have a hierarchy of apps, it will recursively look for that signal until it reaches the root. When
it finds one, it will Kontext will create a SignalHook for that signal. Otherwise a new signal instance is created for the current Kontext.

Kontext.getSignal() on a child App

Same as getInstance, you'll be able to inherit signals from parent.

This release is a proof of concept of Kola