feat(event-manager): new extension

API.md

@@ -193,4 +193,8 @@ See the documentation: [here](src/extensions/http-server/README.md)
 
 # Socket Server Extension
 
-See the documentation: [here](src/extensions/socket-server/README.md)
+See the documentation: [here](src/extensions/socket-server/README.md)
+
+# EventManager Extension
+
+See the documentation: [here](src/extensions/event-manager/README.md)

README.md

@@ -87,15 +87,15 @@ $ yarn add @hapiness/core rxjs
 
 ```javascript
 "dependencies": {
-    "@hapiness/core": "^1.4.0",
+    "@hapiness/core": "^1.5.0",
     //...
 }
 //...
 ```
 
 ### Use Hapiness API
 
-Actually, we're in : **v1.4.0**
+Actually, we're in : **v1.5.0**
 
 See [API](https://github.com/hapinessjs/hapiness/blob/master/API.md) Reference to know what's already implemented.
 
@@ -115,6 +115,9 @@ To set up your development environment:
 [Back to top](#table-of-contents)
 
 ## Change History
+* v1.5.0 (2018-03-27)
+    * EventManager Extension
+    * Documentation
 * v1.4.0 (2018-03-26)
     * Extensions: add timeout
     * Extensions: shutdown

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@hapiness/core",
-    "version": "1.4.0",
+    "version": "1.5.0",
     "description": "Project to have a HapiJS (https://hapijs.com/) based framework to create easier NodeJS back-end with some awesome features",
     "main": "commonjs/index.js",
     "types": "index.d.ts",

src/extensions/event-manager/README.md

@@ -0,0 +1,51 @@
+# EventManager Extension
+
+Extension that allow to send events through all modules
+
+## Usage
+
+```javascript
+
+    @HapinessModule({
+        version: '...',
+        providers: [ EventService ]
+    })
+    class SubModule {
+
+        constructor(private event: EventService) {}
+
+        onRegister() {
+            this.event
+                .on('type')
+                .subscribe(_ => console.log(_.data));
+        }
+    }
+
+    @HapinessModule({
+        version: '...',
+        providers: [ EventService ],
+        imports: [ SubModule ]
+    })
+    class Module {
+
+        constructor(private event: EventService) {}
+
+        onStart() {
+            this.event.emit('type', { data: {} });
+        }
+    }
+
+    Hapiness.bootstrap(Module,
+        [
+            EventManagerExt
+        ]
+    );
+```
+
+## Extension provider
+
+```javascript
+    ...
+    constructor(@Inject(EventManagerExt) private eventManager: EventManager) {}
+    ...
+```

src/extensions/event-manager/extension.ts

@@ -0,0 +1,37 @@
+import { CoreModule, Extension, OnExtensionLoad, OnShutdown } from '../../core/interfaces';
+import { Observable } from 'rxjs/Observable';
+import { ExtensionShutdown, ExtensionShutdownPriority } from '../../core';
+import { EventManager } from './manager';
+
+export class EventManagerExt implements OnExtensionLoad, OnShutdown {
+
+    /**
+     * Initilization of the extension
+     *
+     * @param  {CoreModule} module
+     * @returns Observable
+     */
+    onExtensionLoad(module: CoreModule): Observable<Extension> {
+        return Observable
+            .of(new EventManager())
+            .map(_ => ({
+                instance: this,
+                token: EventManagerExt,
+                value: _
+            }));
+    }
+
+    /**
+     * Shutdown Event manager
+     *
+     * @param  {CoreModule} module
+     * @param  {EventManager} manager
+     * @returns ExtensionShutdown
+     */
+    onShutdown(module: CoreModule, manager: EventManager): ExtensionShutdown {
+        return {
+            priority: ExtensionShutdownPriority.NORMAL,
+            resolver: Observable.of(manager.close())
+        }
+    }
+}

src/extensions/event-manager/index.ts

@@ -0,0 +1,3 @@
+export * from './extension';
+export * from './manager';
+export * from './service';

src/extensions/event-manager/manager.ts

@@ -0,0 +1,53 @@
+import { Subject, Observable } from 'rxjs';
+import { InternalLogger } from '../../core';
+
+export interface EventData {
+    type: string;
+    data: any;
+}
+
+export class EventManager {
+
+    private stream$ = new Subject<EventData>();
+    private logger = new InternalLogger('event-manager');
+
+    /**
+     * Add a listener filtered on type
+     *
+     * @param  {string} type
+     * @returns Observable
+     */
+    public on(type: string): Observable<EventData> {
+        this.logger.debug(`listener added on ${type}`);
+        return this
+            .stream$
+            .filter(_ => !!_ && _.type === type);
+    }
+
+    /**
+     * Emit data for type
+     *
+     * @param  {string} type
+     * @param  {any} data
+     * @returns void
+     */
+    public emit(type: string, data: any): void {
+        this.logger.debug(`send data on ${type}`);
+        this
+            .stream$
+            .next({ type, data });
+    }
+
+    /**
+     * Close the stream event
+     *
+     * @returns void
+     */
+    public close(): void {
+        this.logger.debug(`manager closed`);
+        this
+            .stream$
+            .complete();
+    }
+
+}

src/extensions/event-manager/service.ts

@@ -0,0 +1,32 @@
+import { Injectable, Inject } from '../../core';
+import { EventManagerExt, EventManager, EventData } from './';
+import { Observable } from 'rxjs';
+
+@Injectable()
+export class EventService {
+
+    constructor(
+        @Inject(EventManagerExt) private manager: EventManager
+    ) {}
+
+    /**
+     * Add listener on type
+     *
+     * @returns EventData
+     */
+    on(type: string): Observable<EventData> {
+        return this.manager.on(type);
+    }
+
+    /**
+     * Send data for type
+     *
+     * @param  {string} type
+     * @param  {any} data
+     * @returns void
+     */
+    emit(type: string, data: any): void {
+        this.manager.emit(type, data);
+    }
+
+}

src/extensions/socket-server/extension.ts

@@ -1,4 +1,4 @@
-import { CoreModule, Extension, ExtensionWithConfig, OnExtensionLoad, OnModuleInstantiated } from '../../core/interfaces';
+import { CoreModule, Extension, ExtensionWithConfig, OnExtensionLoad, OnModuleInstantiated, OnShutdown } from '../../core/interfaces';
 import { Observable } from 'rxjs/Observable';
 import { WebSocketServer } from './server';
 import { ExtensionShutdown, ExtensionShutdownPriority } from '../../core';
@@ -16,7 +16,7 @@ export interface SocketConfig {
     }
 }
 
-export class SocketServerExt implements OnExtensionLoad, OnModuleInstantiated {
+export class SocketServerExt implements OnExtensionLoad, OnModuleInstantiated, OnShutdown {
 
     public static setConfig(config: SocketConfig): ExtensionWithConfig {
         return {

src/index.ts

@@ -25,7 +25,8 @@ export {
     DependencyInjection,
     errorHandler,
     ExtensionShutdown,
-    ExtensionShutdownPriority
+    ExtensionShutdownPriority,
+    OnShutdown
 } from './core';
 
 export {
@@ -41,3 +42,10 @@ export {
     WebSocketServer,
     SocketServerService
 } from './extensions/socket-server';
+
+export {
+    EventManagerExt,
+    EventManager,
+    EventService,
+    EventData
+} from './extensions/event-manager';

test/integration/event-manager.test.ts

@@ -0,0 +1,104 @@
+import { suite, test } from 'mocha-typescript';
+import { Hapiness, HapinessModule, OnStart, OnRegister } from '../../src/core';
+import * as unit from 'unit.js';
+import { EventManagerExt, EventService } from '../../src/extensions/event-manager';
+
+@suite('Integration - EventManager')
+export class TestSuite {
+
+    @test('EventManager - event inter modules')
+    test1(done) {
+
+        @HapinessModule({
+            version: '',
+            providers: [ EventService ]
+        })
+        class SubModule1 implements OnRegister {
+
+            constructor(private event: EventService) {}
+
+            onRegister() {
+                this
+                    .event
+                    .on('test')
+                    .subscribe(
+                        _ => {
+                            unit.number(_.data).is(1);
+                            done();
+                        }
+                    )
+            }
+
+        }
+
+        @HapinessModule({
+            version: '',
+            providers: [ EventService ],
+            imports: [ SubModule1 ]
+        })
+        class Module1 implements OnStart {
+
+            constructor(private event: EventService) {}
+
+            onStart() {
+                this.event.emit('test', 1);
+            }
+
+        }
+
+        Hapiness
+            .bootstrap(Module1, [ EventManagerExt ]);
+
+    }
+
+    @test('EventManager - event inter modules multiple times')
+    test2(done) {
+
+        @HapinessModule({
+            version: '',
+            providers: [ EventService ]
+        })
+        class SubModule1 implements OnRegister {
+
+            incr = 0;
+
+            constructor(private event: EventService) {}
+
+            onRegister() {
+                this
+                    .event
+                    .on('test')
+                    .subscribe(
+                        _ => {
+                            this.incr++;
+                            if (this.incr === 3) {
+                                done();
+                            }
+                        }
+                    )
+            }
+
+        }
+
+        @HapinessModule({
+            version: '',
+            providers: [ EventService ],
+            imports: [ SubModule1 ]
+        })
+        class Module1 implements OnStart {
+
+            constructor(private event: EventService) {}
+
+            onStart() {
+                this.event.emit('test', 1);
+                this.event.emit('test', 1);
+                this.event.emit('test', 1);
+            }
+
+        }
+
+        Hapiness
+            .bootstrap(Module1, [ EventManagerExt ]);
+
+    }
+}