Merge pull request #49 from dolittle/interfaces-to-abstract

Change all interfaces to abstract classes.

Author: jakhog

Source/aggregates/AggregateOf.ts

@@ -1,29 +1,30 @@
 // 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';
 import { AggregateRootVersionIsOutOfOrder, CommittedAggregateEvent, CommittedAggregateEvents, EventSourceId, EventTypeId, EventWasAppliedByOtherAggregateRoot, EventWasAppliedToOtherEventSource, IEventStore, IEventTypes } from '@dolittle/sdk.events';
-import { IAggregateOf } from './IAggregateOf';
-import { IAggregateRootOperations } from './IAggregateRootOperations';
-import { Logger } from 'winston';
 import { Constructor } from '@dolittle/types';
-import { AggregateRootOperations } from './AggregateRootOperations';
+import { Logger } from 'winston';
 import { AggregateRoot } from './AggregateRoot';
 import { AggregateRootDecoratedTypes } from './AggregateRootDecoratedTypes';
-import { OnDecoratedMethods } from './OnDecoratedMethods';
+import { AggregateRootOperations } from './AggregateRootOperations';
+import { IAggregateOf } from './IAggregateOf';
+import { IAggregateRootOperations } from './IAggregateRootOperations';
 import { OnDecoratedMethod } from './OnDecoratedMethod';
-import { Guid } from '@dolittle/rudiments';
+import { OnDecoratedMethods } from './OnDecoratedMethods';
 
 /**
  * Represents an implementation of {@link IAggregateOf<TAggregateRoot>}.
  * @template TAggregateRoot
  */
-export class AggregateOf<TAggregateRoot extends AggregateRoot> implements IAggregateOf<TAggregateRoot> {
+export class AggregateOf<TAggregateRoot extends AggregateRoot> extends IAggregateOf<TAggregateRoot> {
 
     constructor(
         private readonly _type: Constructor<TAggregateRoot>,
         private readonly _eventStore: IEventStore,
         private readonly _eventTypes: IEventTypes,
         private readonly _logger: Logger) {
+        super();
     }
 
     /** @inheritdoc */
@@ -112,4 +113,4 @@ export class AggregateOf<TAggregateRoot extends AggregateRoot> implements IAggre
         }
     }
 
-}
+}

Source/aggregates/AggregateRootOperations.ts

@@ -1,25 +1,26 @@
 // Copyright (c) Dolittle. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { IAggregateRootOperations } from './IAggregateRootOperations';
-import { AggregateRootAction } from './AggregateRootAction';
-import { AggregateRoot } from './AggregateRoot';
-import { AggregateRootVersion, AggregateRootId, CommittedAggregateEvents, IEventStore, UncommittedAggregateEvent, IEventTypes } from '@dolittle/sdk.events';
-import { Logger } from 'winston';
+import { AggregateRootId, AggregateRootVersion, CommittedAggregateEvents, IEventStore, IEventTypes, UncommittedAggregateEvent } from '@dolittle/sdk.events';
 import { Constructor } from '@dolittle/types';
+import { Logger } from 'winston';
+import { AggregateRoot } from './AggregateRoot';
+import { AggregateRootAction } from './AggregateRootAction';
+import { IAggregateRootOperations } from './IAggregateRootOperations';
 
 
 /**
  * Represents an implementation of {@link IAggregateRootOperations<TAggregate>}
  * @template TAggregateRoot
  */
-export class AggregateRootOperations<TAggregateRoot extends AggregateRoot> implements IAggregateRootOperations<TAggregateRoot> {
+export class AggregateRootOperations<TAggregateRoot extends AggregateRoot> extends IAggregateRootOperations<TAggregateRoot> {
     constructor(
         private readonly _aggregateRootType: Constructor<any>,
         private readonly _eventStore: IEventStore,
         private readonly _aggregateRoot: TAggregateRoot,
         private readonly _eventTypes: IEventTypes,
         private readonly _logger: Logger) {
+        super();
     }
 
     /** @inheritdoc */

Source/aggregates/IAggregateOf.ts

@@ -2,26 +2,26 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { EventSourceId } from '@dolittle/sdk.events';
-import { IAggregateRootOperations } from './IAggregateRootOperations';
 import { AggregateRoot } from './AggregateRoot';
+import { IAggregateRootOperations } from './IAggregateRootOperations';
 
 /**
  * Defines a way to work with an {@link AggregateRoot}
  * @template TAggregate
  */
 
-export interface IAggregateOf<TAggregate extends AggregateRoot> {
+export abstract class IAggregateOf<TAggregate extends AggregateRoot> {
 
     /**
      * Create a new {@link AggregateRoot} with a random {@link EventSourceId}
      * @returns {IAggregateRootOperations<TAggregate>}
      */
-    create(): IAggregateRootOperations<TAggregate>;
+    abstract create (): IAggregateRootOperations<TAggregate>;
 
     /**
      * Gets an {@link AggregateRoot} with a given {@link EventSourceId}
      * @param {EventSourceId} eventSourceId {@link EventSourceId} of the {@link AggregateRoot}
      * @returns {IAggregateRootOperations<TAggregate>}
      */
-    get(eventSourceId: EventSourceId): IAggregateRootOperations<TAggregate>;
+    abstract get (eventSourceId: EventSourceId): IAggregateRootOperations<TAggregate>;
 }

Source/aggregates/IAggregateRootOperations.ts

@@ -1,20 +1,20 @@
 // Copyright (c) Dolittle. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { AggregateRootAction } from './AggregateRootAction';
 import { AggregateRoot } from './AggregateRoot';
+import { AggregateRootAction } from './AggregateRootAction';
 
 /**
  * Defines a system for working with operations that can be formed on an {@link AggregateRoot}.
  * @template TAggregate {@link AggregateRoot} type
  */
 
-export interface IAggregateRootOperations<TAggregate extends AggregateRoot> {
+export abstract class IAggregateRootOperations<TAggregate extends AggregateRoot> {
 
     /**
      * Perform an operation on an {@link AggregateRoot}
      * @param {AggregateRootAction<TAggregate> action Callback for working with the aggregate root.
      * @returns {Promise<void>}
      */
-    perform(action: AggregateRootAction<TAggregate>): Promise<void>;
+    abstract perform (action: AggregateRootAction<TAggregate>): Promise<void>;
 }

Source/artifacts/EventTypes.ts

@@ -3,25 +3,26 @@
 
 import { Guid } from '@dolittle/rudiments';
 import { Constructor } from '@dolittle/types';
-import { UnknownType } from './UnknownType';
-import { EventTypeMap } from './EventTypeMap';
-import { IEventTypes } from './IEventTypes';
+import { CannotHaveMultipleEventTypesAssociatedWithType } from './CannotHaveMultipleEventTypesAssociatedWithType';
+import { CannotHaveMultipleTypesAssociatedWithEventType } from './CannotHaveMultipleTypesAssociatedWithEventType';
 import { EventType } from './EventType';
-import { UnknownEventType } from './UnknownEventType';
 import { EventTypeId } from './EventTypeId';
+import { EventTypeMap } from './EventTypeMap';
+import { IEventTypes } from './IEventTypes';
 import { UnableToResolveEventType } from './UnableToResolveEventType';
-import { CannotHaveMultipleEventTypesAssociatedWithType } from './CannotHaveMultipleEventTypesAssociatedWithType';
-import { CannotHaveMultipleTypesAssociatedWithEventType } from './CannotHaveMultipleTypesAssociatedWithEventType';
+import { UnknownEventType } from './UnknownEventType';
+import { UnknownType } from './UnknownType';
 
 /**
  * Represents an implementation of {@link IEventTypes}
  */
-export class EventTypes implements IEventTypes {
+export class EventTypes extends IEventTypes {
     /**
      * Initializes a new instance of {@link EventTypes}
      * @param {EventTypeMap<Constructor<any>>} [associations] Known associations
      */
     constructor(private _associations: EventTypeMap<Constructor<any>> = new EventTypeMap()) {
+        super();
     }
     /** @inheritdoc */
     hasTypeFor(input: EventType): boolean {

Source/artifacts/IEventTypes.ts

@@ -3,41 +3,41 @@
 
 import { Guid } from '@dolittle/rudiments';
 import { Constructor } from '@dolittle/types';
-import { EventType } from './EventType';
+import { EventType } from './EventType';
 import { EventTypeId } from './EventTypeId';
 
 /**
  * Defines the system for working with {@link EventType}
  */
-export interface IEventTypes {
+export abstract class IEventTypes {
 
     /**
      * Check if there is a type associated with an artifact.
      * @param {EventType} input Artifact.
      * @returns {boolean} true if there is, false if not.
      */
-    hasTypeFor(input: EventType): boolean;
+    abstract hasTypeFor (input: EventType): boolean;
 
     /**
      * Get type for a given artifact.
      * @param {EventType} input Artifact.
      * @returns type for artifact.
      */
-    getTypeFor(input: EventType): Constructor<any>;
+    abstract getTypeFor (input: EventType): Constructor<any>;
 
     /**
      * Check if there is an {Artifact} definition for a given type.
      * @param {Function} type Type to check for.
      * @returns true if there is, false if not.
      */
-    hasFor(type: Constructor<any>): boolean;
+    abstract hasFor (type: Constructor<any>): boolean;
 
     /**
      * Get {Artifact} definition for a given type.
      * @param {Function} type Type to get for.
      * @returns {EventType} The artifact associated.
      */
-    getFor(type: Constructor<any>): EventType;
+    abstract getFor (type: Constructor<any>): EventType;
 
     /**
      * Resolves an artifact from optional input or the given object.
@@ -46,12 +46,12 @@ export interface IEventTypes {
      * @returns {EventType} Resolved event type.
      * @throws {UnableToResolveArtifact} If not able to resolve artifact.
      */
-    resolveFrom(object: any, input?: EventType | EventTypeId | Guid | string): EventType;
+    abstract resolveFrom (object: any, input?: EventType | EventTypeId | Guid | string): EventType;
 
     /**
      * Associate a type with a unique artifact identifier and optional generation.
      * @param {Constructor<any>} type Type to associate.
      * @param {EventType} eventType Artifact to associate with.
      */
-    associate(type: Constructor<any>, eventType: EventType): void;
+    abstract associate (type: Constructor<any>, eventType: EventType): void;
 }

Source/common/Container.ts

@@ -2,13 +2,13 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Constructor } from '@dolittle/types';
-import { IContainer } from './IContainer';
 import { DefaultContainerDoesNotSupportConstructorArguments } from './DefaultContainerDoesNotSupportConstructorArguments';
+import { IContainer } from './IContainer';
 
 /**
  * Represents an implementation of {@link IContainer}.
  */
-export class Container implements IContainer {
+export class Container extends IContainer {
 
     /** @inheritdoc */
     get(service: Constructor) {

Source/common/IContainer.ts

@@ -6,13 +6,12 @@ import { Constructor } from '@dolittle/types';
 /**
  * Defines an IoC Container for dependency inversion.
  */
-export interface IContainer {
+export abstract class IContainer {
 
     /**
      * Get the instance of a service.
      * @param {Function} service Type of service by its constructor to get
      * @returns The instance.
      */
-    get(service: Constructor): any;
+    abstract get (service: Constructor): any;
 }
-

Source/eventHorizon/EventHorizons.ts

@@ -2,24 +2,24 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Guid } from '@dolittle/rudiments';
-import { Logger } from 'winston';
-import * as grpc from '@grpc/grpc-js';
-import { ExecutionContext } from '@dolittle/sdk.execution';
-import { callContexts, failures, guids } from '@dolittle/sdk.protobuf';
 import { SubscriptionsClient } from '@dolittle/runtime.contracts/EventHorizon/Subscriptions_grpc_pb';
 import { Subscription as PbSubscription, SubscriptionResponse as PbSubscriptionResponse } from '@dolittle/runtime.contracts/EventHorizon/Subscriptions_pb';
+import { ExecutionContext } from '@dolittle/sdk.execution';
+import { callContexts, failures, guids } from '@dolittle/sdk.protobuf';
+import * as grpc from '@grpc/grpc-js';
+import { Logger } from 'winston';
+import { IEventHorizons } from './IEventHorizons';
+import { Subscription } from './Subscription';
+import { SubscriptionCallbacks } from './SubscriptionCallbacks';
+import { SubscriptionDoesNotExist } from './SubscriptionDoesNotExist';
+import { SubscriptionResponse } from './SubscriptionResponse';
+import { TenantWithSubscriptions } from './TenantWithSubscriptions';
 
-import { Subscription } from './Subscription';
-import { IEventHorizons } from './IEventHorizons';
-import { SubscriptionResponse } from './SubscriptionResponse';
-import { TenantWithSubscriptions } from './TenantWithSubscriptions';
-import { SubscriptionCallbacks } from './SubscriptionCallbacks';
-import { SubscriptionDoesNotExist } from './SubscriptionDoesNotExist';
 
 /**
  * Represents an implementation of {@link IEventHorizons}.
  */
-export class EventHorizons implements IEventHorizons {
+export class EventHorizons extends IEventHorizons {
     private _subscriptionResponses: Map<Subscription, SubscriptionResponse> = new Map();
 
     /**
@@ -36,6 +36,7 @@ export class EventHorizons implements IEventHorizons {
         readonly subscriptions: TenantWithSubscriptions[],
         readonly callbacks: SubscriptionCallbacks,
         private _logger: Logger) {
+        super();
         this.subscribeAll();
     }
 

Source/eventHorizon/IEventHorizons.ts

@@ -1,23 +1,23 @@
 // Copyright (c) Dolittle. All rights reserved.
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
-import { Subscription } from './Subscription';
-import { TenantWithSubscriptions } from './TenantWithSubscriptions';
+import { Subscription } from './Subscription';
 import { SubscriptionResponse } from './SubscriptionResponse';
+import { TenantWithSubscriptions } from './TenantWithSubscriptions';
 
 /**
  * Defines the capabilities of the event horizons.
  */
-export interface IEventHorizons {
+export abstract class IEventHorizons {
     /**
      * Subscriptions by tenant.
      */
-    readonly subscriptions: TenantWithSubscriptions[];
+    abstract readonly subscriptions: TenantWithSubscriptions[];
 
     /**
      * Gets response for a specific {@link Subscription}.
      * @param {Subscription} subscription Subscription to get response for.
      * @throws {SubscriptionDoesNotExist} If subscription does not exist.
      */
-    getResponseFor(subscription: Subscription): SubscriptionResponse;
+    abstract getResponseFor (subscription: Subscription): SubscriptionResponse;
 }