Merge branch 'in-scope' of github.com:dolittle/JavaScript.SDK into event-type

Author: joelhoisko

Samples/Basic/MyEventHandler.ts

@@ -5,7 +5,7 @@ import { eventHandler, handles } from '@dolittle/sdk.events.handling';
 import { MyEvent } from './MyEvent';
 
 
-@eventHandler('a27074a7-5b01-43c9-b4f0-c1d59668d844')
+@eventHandler('a27074a7-5b01-43c9-b4f0-c1d59668d844', { inScope: '406d6473-7cc9-44a6-a55f-775c1021d957' })
 export class MyEventHandler {
 
     @handles(MyEvent)

Samples/Environment/docker-compose.yml

@@ -9,7 +9,7 @@ services:
       - 27017:27017
 
   runtime-basic:
-    image: dolittle/runtime:5.0.1
+    image: dolittle/runtime:5.0.2
     volumes:
       - ${PWD}/resources-basic.json:/app/.dolittle/resources.json
       - ${PWD}/tenants.json:/app/.dolittle/tenants.json
@@ -22,7 +22,7 @@ services:
       - 50053:50053
 
   runtime-eventhorizon:
-    image: dolittle/runtime:5.0.1
+    image: dolittle/runtime:5.0.2
     volumes:
       - ${PWD}/resources-eventhorizon.json:/app/.dolittle/resources.json
       - ${PWD}/tenants.json:/app/.dolittle/tenants.json

Samples/EventHorizon/MyEventHandler.ts

@@ -1,12 +1,11 @@
 // Copyright (c) Dolittle. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 import { EventContext } from '@dolittle/sdk.events';
-import { eventHandler, handles, inScope } from '@dolittle/sdk.events.handling';
+import { eventHandler, handles } from '@dolittle/sdk.events.handling';
 import { MyEvent } from './MyEvent';
 
 
-@eventHandler('62f7d968-9e70-47a6-9bb7-b21e1b3ed71c')
-@inScope('406d6473-7cc9-44a6-a55f-775c1021d957')
+@eventHandler('62f7d968-9e70-47a6-9bb7-b21e1b3ed71c', { inScope: '406d6473-7cc9-44a6-a55f-775c1021d957' })
 export class MyEventHandler {
 
     @handles(MyEvent)

Source/events.handling/EventHandler.ts

@@ -7,6 +7,7 @@ import { Artifact, ArtifactMap } from '@dolittle/sdk.artifacts';
 import { EventContext, ScopeId } from '@dolittle/sdk.events';
 
 import { EventHandlerDecoratedTypes, IEventHandler, EventHandlerSignature, MissingEventHandlerForType, EventHandlerId } from './index';
+import { EventHandlerOptions } from './EventHandlerOptions';
 
 /**
  * Represents an implementation of {@link IEventHandler}.
@@ -43,17 +44,16 @@ export class EventHandler implements IEventHandler {
     }
 }
 
-export function eventHandler(eventHandlerId: Guid | string) {
+/**
+ * Decorator to mark a class as an EventHandler.
+ * @param {Guid | string} eventHandlerId EventHandler's given id
+ * @param {EventHandlerOptions} [options={}] Options to give to the EventHandler
+ */
+export function eventHandler(eventHandlerId: Guid | string, options: EventHandlerOptions = {}) {
     return function (target: any) {
         EventHandlerDecoratedTypes.registerEventHandler(
             EventHandlerId.from(eventHandlerId),
             target);
-    };
-}
-export function inScope(scopeId: Guid | string) {
-    return function (target: any) {
-        EventHandlerDecoratedTypes.registerScope(
-            ScopeId.from(scopeId),
-            target);
+        EventHandlerDecoratedTypes.registerOptions(options, target);
     };
 }

Source/events.handling/EventHandlerDecoratedType.ts

@@ -9,6 +9,6 @@ import { EventHandlerId } from './index';
  * Represents an event handler created from the decorator
  */
 export class EventHandlerDecoratedType {
-    constructor(readonly eventHandlerId: EventHandlerId, readonly scopeId: ScopeId, readonly type: Function) {
+    constructor(readonly eventHandlerId: EventHandlerId, readonly scopeId: ScopeId, readonly partitioned: boolean, readonly type: Function) {
     }
 }

Source/events.handling/EventHandlerDecoratedTypes.ts

@@ -1,25 +1,53 @@
 // Copyright (c) Dolittle. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { ReplaySubject } from 'rxjs';
 import { ScopeId } from '@dolittle/sdk.events';
+import { EventHandlerDecoratedType, EventHandlerId, EventHandlerIdAlreadyInUse, EventHandlerOptions  } from './index';
 
-import { EventHandlerDecoratedType, EventHandlerId } from './index';
-
+/**
+ * Handles registering and mappings between @eventHandler decorated classes and their given id and options.
+ */
 export class EventHandlerDecoratedTypes {
-    private static readonly _eventHandlers = new Map<Function, EventHandlerId>();
+    private static readonly _eventHandlers = new Map<Function, EventHandlerId>() ;
     private static readonly _scopes  = new Map<Function, ScopeId>();
-    static registerEventHandler(eventHandlerId: EventHandlerId, type: Function) {
-        this._eventHandlers.set(type, eventHandlerId);
+    private static readonly _unpartitioned  = new Map<Function, boolean>();
+
+    /**
+     * Registers an @EventHandlerId to a specific type.
+     * @param {EventHandlerId} eventHandlerId EventHandlerId to register the type with.
+     * @param {Function} eventHandlerType Type of the event handler.
+     */
+    static registerEventHandler(eventHandlerId: EventHandlerId, eventHandlerType: Function) {
+        for (const [func, id] of this._eventHandlers) {
+            if (id.equals(eventHandlerId)) throw new EventHandlerIdAlreadyInUse(eventHandlerId, eventHandlerType, func);
+        }
+        this._eventHandlers.set(eventHandlerType, eventHandlerId);
     }
-    static registerScope(scopeId: ScopeId, type: Function) {
-        this._scopes.set(type, scopeId);
+
+    /**
+     *  Registers @EventHandlerOptions to a specific type.
+     * @param options EventHandlerOptions to register the type with.
+     * @param eventHandlerType Type of the event handler.
+     */
+    static registerOptions(options: EventHandlerOptions, eventHandlerType: Function) {
+        if (options.inScope) {
+            this._scopes.set(eventHandlerType, ScopeId.from(options.inScope));
+        }
+        if (options.unpartitioned) {
+            this._unpartitioned.set(eventHandlerType, true);
+        }
     }
+
+    /**
+     * Creates an array of EventhandlerDecoratedType's and calls the callback on each one of them.
+     * @param callback
+     */
     static forEach(callback: (eventHandlerDecoratedType: EventHandlerDecoratedType) => void) {
         const eventHandlerDecoratedTypes: EventHandlerDecoratedType[] = [];
-        for (const [func, eventHandlerId] of this._eventHandlers) {
+        for (const [func, id] of this._eventHandlers) {
             const scopeId = this._scopes.has(func) ? this._scopes.get(func)! : ScopeId.default;
-            eventHandlerDecoratedTypes.push(new EventHandlerDecoratedType(eventHandlerId, scopeId, func));
+            const partitioned = !this._unpartitioned.has(func);
+            eventHandlerDecoratedTypes.push(new EventHandlerDecoratedType(id, scopeId, partitioned, func));
         }
 
         for (const eventHandlerDecoratedType of eventHandlerDecoratedTypes) {

Source/events.handling/EventHandlerIdAlreadyInUse.ts

@@ -0,0 +1,11 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Exception } from '@dolittle/rudiments';
+import { EventHandlerId } from './index';
+
+export class EventHandlerIdAlreadyInUse extends Exception {
+    constructor(eventHandlerId: EventHandlerId, type: Function, alreadyUsedType: Function) {
+        super(`EventHandlerId '${eventHandlerId}' in EventHandler '${type.name}' is already in use in type '${alreadyUsedType.name}'`);
+    }
+}

Source/events.handling/EventHandlerOptions.ts

@@ -0,0 +1,6 @@
+// Copyright (c) Dolittle. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Guid } from '@dolittle/rudiments';
+
+export type EventHandlerOptions = { inScope?: Guid | string, unpartitioned?: boolean };

Source/events.handling/EventHandlers.ts

@@ -69,7 +69,7 @@ export class EventHandlers implements IEventHandlers {
             }
             this._logger.debug(`Register EventHandler '${_.eventHandlerId}'`);
 
-            const eventHandler = new EventHandler(_.eventHandlerId, _.scopeId, true, this.getEventHandlerMethodsByArtifact(_.type));
+            const eventHandler = new EventHandler(_.eventHandlerId, _.scopeId, _.partitioned, this.getEventHandlerMethodsByArtifact(_.type));
             this.register(eventHandler, this._cancellation);
         });
     }

Source/events.handling/index.ts

@@ -10,10 +10,12 @@ export { HandlesDecoratedMethods } from './HandlesDecoratedMethods';
 export { EventHandlerDecoratedType } from './EventHandlerDecoratedType';
 export { EventHandlerDecoratedTypes } from './EventHandlerDecoratedTypes';
 export { IEventHandler } from './IEventHandler';
-export { EventHandler, eventHandler, inScope } from './EventHandler';
+export { EventHandler, eventHandler } from './EventHandler';
 export { EventHandlerBuilder, EventHandlerBuilderCallback } from './EventHandlerBuilder';
 export { IEventHandlers } from './IEventHandlers';
 export { EventHandlers } from './EventHandlers';
 export { EventHandlersBuilder, EventHandlersBuilderCallback } from './EventHandlersBuilder';
+export { EventHandlerIdAlreadyInUse } from './EventHandlerIdAlreadyInUse';
+export { EventHandlerOptions } from './EventHandlerOptions';
 export { handles } from './handles';
 export * as internal from './Internal';