Merge pull request #100 from dolittle/module-loading-registration

jakhog · web-flow · commit 84632497f68e · 2021-12-15T08:12:58.000+01:00
Register all decorated types in the imported files automatically
diff --git a/Samples/Tutorials/GettingStarted/index.ts b/Samples/Tutorials/GettingStarted/index.ts
@@ -6,15 +6,11 @@
 import { DolittleClient } from '@dolittle/sdk';
 import { TenantId } from '@dolittle/sdk.execution';
 import { DishPrepared } from './DishPrepared';
-import { DishHandler } from './DishHandler';
+import './DishHandler';
 
 (async () => {
     const client = await DolittleClient
-        .setup(builder => builder
-            .withEventTypes(eventTypes =>
-                eventTypes.register(DishPrepared))
-            .withEventHandlers(builder =>
-                builder.registerEventHandler(DishHandler)))
+        .setup()
         .connect();
 
     const preparedTaco = new DishPrepared('Bean Blaster Taco', 'Mr. Taco');
diff --git a/Source/aggregates/_exports.ts b/Source/aggregates/_exports.ts
@@ -21,5 +21,5 @@ export { IAggregateRootTypes } from './IAggregateRootTypes';
 export { MissingAggregateRootDecoratorFor } from './MissingAggregateRootDecoratorFor';
 export { OnDecoratedMethod } from './OnDecoratedMethod';
 export { OnMethodSignature } from './OnMethodSignature';
-export { aggregateRoot, getDecoratedAggregateRootType } from './aggregateRootDecorator';
+export { aggregateRoot, isDecoratedAggregateRootType, getDecoratedAggregateRootType } from './aggregateRootDecorator';
 export { on } from './onDecorator';
diff --git a/Source/aggregates/aggregateRootDecorator.ts b/Source/aggregates/aggregateRootDecorator.ts
@@ -28,6 +28,15 @@ export function aggregateRoot(aggregateRootId: AggregateRootIdLike, options: Agg
     });
 }
 
+/**
+ * Checks whether the specified class is decorated with an aggregate root type.
+ * @param {Constructor<any>} type - The class to check the decorated aggregate root type for.
+ * @returns {boolean} True if the decorator is applied, false if not.
+ */
+export function isDecoratedAggregateRootType(type: Constructor<any>): boolean {
+    return getMetadata(type, false, false) !== undefined;
+}
+
 /**
  * Gets the decorated aggregate root type of the specified class.
  * @param {Constructor<any>} type - The class to get the decorated aggregate root type for.
diff --git a/Source/common/Decorators/_exports.ts b/Source/common/Decorators/_exports.ts
@@ -6,7 +6,7 @@ export { createMetadataDecorator } from './createMetadataDecorator';
 export { Decorator } from './Decorator';
 export { DecoratorAppliedMultipleTimes } from './DecoratorAppliedMultipleTimes';
 export { DecoratorTarget } from './DecoratorTarget';
-export { ensureDecoratorMetadataMap } from './ensureDecoratorMetadataMap';
+export { hasDecoratorMetadataMap, ensureDecoratorMetadataMap } from './decoratorMetadataMap';
 export { getAppliedDecorators } from './getAppliedDecorators';
 export { getDecoratedTarget } from './getDecoratedTarget';
 export { getDecoratorMetadata } from './getDecoratorMetadata';
diff --git a/Source/common/Decorators/createMetadataDecorator.ts b/Source/common/Decorators/createMetadataDecorator.ts
@@ -13,8 +13,8 @@ import { RequiredDecoratorNotApplied } from './RequiredDecoratorNotApplied';
 import { setDecoratorMetadata } from './setDecoratorMetadata';
 
 type GetMetadataValue<TData> =
-    ((type: Constructor<any>, required?: false) => TData | undefined) &
-    ((type: Constructor<any>, required: true, reason: string) => TData);
+    ((type: Constructor<any>, required?: false, createMetadata?: boolean) => TData | undefined) &
+    ((type: Constructor<any>, required: true, reason: string, createMetadata?: boolean) => TData);
 
 type Decorator<TCallback> = (callback: TCallback) => (target: Function | Object, propertyKey?: string | symbol, descriptorOrIndex?: PropertyDescriptor | number) => void;
 
@@ -55,7 +55,7 @@ export function createMetadataDecorator<TData>(name: string, displayName: string
                     throw new DecoratorAppliedMultipleTimes(displayName, decoratedTarget, constructor, target, propertyKey, descriptorOrIndex);
                 }
 
-                const value = getDecoratorMetadata<TData>(name, constructor);
+                const value = getDecoratorMetadata<TData>(name, constructor, true);
                 const newValue = callback(decoratedTarget, constructor, propertyKey, descriptorOrIndex, value);
                 setDecoratorMetadata<TData>(name, constructor, newValue);
 
@@ -64,11 +64,16 @@ export function createMetadataDecorator<TData>(name: string, displayName: string
                 }
             };
         },
-        function (type: Constructor<any>, required?: boolean, reason?: string) {
-            const value = getDecoratorMetadata<TData>(name, type);
+        function (type: Constructor<any>, required?: boolean, maybeRasonOrCreateMetadata?: string | boolean, maybeCreateMetadata?: boolean) {
+            const createMetadata =
+                typeof maybeCreateMetadata === 'boolean' ? maybeCreateMetadata :
+                typeof maybeRasonOrCreateMetadata === 'boolean' ? maybeRasonOrCreateMetadata :
+                true;
 
-            if (value === undefined && required) {
-                throw new RequiredDecoratorNotApplied(displayName, validTargets, type, reason!);
+            const value = getDecoratorMetadata<TData>(name, type, createMetadata);
+
+            if (value === undefined && required === true) {
+                throw new RequiredDecoratorNotApplied(displayName, validTargets, type, maybeRasonOrCreateMetadata as string);
             }
 
             return value;
diff --git a/Source/common/Decorators/decoratorMetadataMap.ts b/Source/common/Decorators/decoratorMetadataMap.ts
@@ -5,6 +5,16 @@ import { Constructor } from '@dolittle/types';
 
 const DECORATOR_METADATA_KEY = '@dolittle/sdk.common/Decorators';
 
+/**
+ * Checks whether or not the decorator metadata map exists on the provided type.
+ * @param {Constructor<any>} type - The type to check if the map exists on.
+ * @returns {boolean} True if the type has the decorator metadata map, false if not.
+ */
+export function hasDecoratorMetadataMap(type: Constructor<any>): boolean {
+    const descriptor = Object.getOwnPropertyDescriptor(type, DECORATOR_METADATA_KEY);
+    return descriptor !== undefined && descriptor.value instanceof Map;
+}
+
 /**
  * Ensures that the decorator metadata map exists on the provided type.
  * @param {Constructor<any>} type - The type to ensure the map exists on.
diff --git a/Source/common/Decorators/getAppliedDecorators.ts b/Source/common/Decorators/getAppliedDecorators.ts
@@ -25,7 +25,7 @@ export type AppliedDecorator = {
  * @returns {AppliedDecorator[]} The applied decorators.
  */
 export function getAppliedDecorators(type: Constructor<any>): AppliedDecorator[] {
-    let decorators = getDecoratorMetadata<AppliedDecorator[]>(APPLIED_DECORATORS_NAME, type);
+    let decorators = getDecoratorMetadata<AppliedDecorator[]>(APPLIED_DECORATORS_NAME, type, true);
 
     if (decorators === undefined) {
         decorators = [];
diff --git a/Source/common/Decorators/getDecoratorMetadata.ts b/Source/common/Decorators/getDecoratorMetadata.ts
@@ -2,16 +2,22 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Constructor } from '@dolittle/types';
-import { ensureDecoratorMetadataMap } from './ensureDecoratorMetadataMap';
+
+import { ensureDecoratorMetadataMap, hasDecoratorMetadataMap } from './decoratorMetadataMap';
 
 /**
  * Gets the named data in the metadata of the specified type.
  * @param {string} name - The metadata name to get.
  * @param {Constructor<any>} type - The type to get metadata on.
+ * @param {boolean} [createMetadata] - An optional boolean to specify whether or not to create the metadata map if it doesn't exist.
  * @returns {T | undefined} The value of the named data.
- * @template T The type of the metadata value.
+ * @template T The Type of the metadata value.
  */
-export function getDecoratorMetadata<T>(name: string, type: Constructor<any>): T | undefined {
+export function getDecoratorMetadata<T>(name: string, type: Constructor<any>, createMetadata?: boolean): T | undefined {
+    if (createMetadata === false && !hasDecoratorMetadataMap(type)) {
+        return undefined;
+    }
+
     const metadata = ensureDecoratorMetadataMap(type);
     return metadata.get(name);
 }
diff --git a/Source/common/Decorators/hasDecoratorMetadata.ts b/Source/common/Decorators/hasDecoratorMetadata.ts
@@ -3,15 +3,20 @@
 
 import { Constructor } from '@dolittle/types';
 
-import { ensureDecoratorMetadataMap } from './ensureDecoratorMetadataMap';
+import { ensureDecoratorMetadataMap, hasDecoratorMetadataMap } from './decoratorMetadataMap';
 
 /**
  * Checks whether or not the metadata of the specified type has the named data.
  * @param {string} name - The metadata name to check for.
  * @param {Constructor<any>} type - The type to check metadata on.
+ * @param {boolean} [createMetadata] - An optional boolean to specify whether or not to create the metadata map if it doesn't exist.
  * @returns {boolean} True if it is set, false if not.
  */
-export function hasDecoratorMetadata(name: string, type: Constructor<any>): boolean {
+export function hasDecoratorMetadata(name: string, type: Constructor<any>, createMetadata?: boolean): boolean {
+    if (createMetadata === false && !hasDecoratorMetadataMap(type)) {
+        return false;
+    }
+
     const metadata = ensureDecoratorMetadataMap(type);
     return metadata.has(name);
 }
diff --git a/Source/common/Decorators/setDecoratorMetadata.ts b/Source/common/Decorators/setDecoratorMetadata.ts
@@ -2,7 +2,7 @@
 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
 
 import { Constructor } from '@dolittle/types';
-import { ensureDecoratorMetadataMap } from './ensureDecoratorMetadataMap';
+import { ensureDecoratorMetadataMap } from './decoratorMetadataMap';
 
 /**
  * Sets the named data in the metadata of the specified type.
diff --git a/Source/embeddings/Builders/EmbeddingClassBuilder.ts b/Source/embeddings/Builders/EmbeddingClassBuilder.ts
@@ -15,7 +15,7 @@ import { EmbeddingUpdateCallback } from '../EmbeddingUpdateCallback';
 import { Embedding } from '../Internal/Embedding';
 import { IEmbedding } from '../Internal/IEmbedding';
 import { CannotRegisterEmbeddingThatIsNotAClass } from './CannotRegisterEmbeddingThatIsNotAClass';
-import { embedding as embeddingDecorator, getEmbeddingDecoratedType } from './embeddingDecorator';
+import { embedding as embeddingDecorator, getDecoratedEmbeddingType } from './embeddingDecorator';
 import { getOnDecoratedMethods } from './onDecorator';
 import { OnDecoratedEmbeddingMethod } from './OnDecoratedEmbeddingMethod';
 import { DeletionDecoratedMethod } from './DeletionDecoratedMethod';
@@ -53,7 +53,7 @@ export class EmbeddingClassBuilder<T> {
      */
     build(eventTypes: IEventTypes, results: IClientBuildResults): IEmbedding<any> | undefined {
         results.addInformation(`Building embedding of type ${this._embeddingType.name}`);
-        const decoratedType = getEmbeddingDecoratedType(this._embeddingType);
+        const decoratedType = getDecoratedEmbeddingType(this._embeddingType);
         if (decoratedType === undefined) {
             results.addFailure(`The embedding class ${this._embeddingType.name} must be decorated with an @${embeddingDecorator.name} decorator`);
             return;
diff --git a/Source/embeddings/Builders/_exports.ts b/Source/embeddings/Builders/_exports.ts
@@ -22,7 +22,7 @@ export { IEmbeddingsBuilder } from './IEmbeddingsBuilder';
 export { OnDecoratedEmbeddingMethod } from './OnDecoratedEmbeddingMethod';
 export { ReadModelAlreadyDefinedForEmbedding } from './ReadModelAlreadyDefinedForEmbedding';
 export { UpdateDecoratedMethod } from './UpdateDecoratedMethod';
-export { embedding, getEmbeddingDecoratedType } from './embeddingDecorator';
+export { embedding, isDecoratedEmbeddingType, getDecoratedEmbeddingType } from './embeddingDecorator';
 export { on, getOnDecoratedMethods } from './onDecorator';
 export { resolveDeletionToEvents, getDeletionDecoratedMethod } from './resolveDeletionToEventsDecorator';
 export { resolveUpdateToEvents, getUpdateDecoratedMethod } from './resolveUpdateToEventsDecorator';
diff --git a/Source/embeddings/Builders/embeddingDecorator.ts b/Source/embeddings/Builders/embeddingDecorator.ts
@@ -27,11 +27,20 @@ export function embedding(id: EmbeddingId | Guid | string): Decorators.Decorator
     });
 }
 
+/**
+ * Checks whether the specified class is decorated with an embedding type.
+ * @param {Constructor<any>} type - The class to check the decorated embedding type for.
+ * @returns {boolean} True if the decorator is applied, false if not.
+ */
+export function isDecoratedEmbeddingType(type: Constructor<any>): boolean {
+    return getMetadata(type, false, false) !== undefined;
+}
+
 /**
  * Gets the {@link EmbeddingDecoratedType} of the specified class.
  * @param {Constructor<any>} type - The class to get the decorated embedding type for.
  * @returns {EmbeddingDecoratedType | undefined} The decorated embedding type if decorated.
  */
-export function getEmbeddingDecoratedType(type: Constructor<any>): EmbeddingDecoratedType | undefined {
+export function getDecoratedEmbeddingType(type: Constructor<any>): EmbeddingDecoratedType | undefined {
     return getMetadata(type);
 }
diff --git a/Source/embeddings/index.ts b/Source/embeddings/index.ts
@@ -26,7 +26,8 @@ export {
     ReadModelAlreadyDefinedForEmbedding,
     UpdateDecoratedMethod,
     embedding,
-    getEmbeddingDecoratedType,
+    isDecoratedEmbeddingType,
+    getDecoratedEmbeddingType,
     on,
     getOnDecoratedMethods,
     resolveDeletionToEvents,
diff --git a/Source/events.handling/Builders/EventHandlerClassBuilder.ts b/Source/events.handling/Builders/EventHandlerClassBuilder.ts
@@ -14,7 +14,7 @@ import { EventHandlerSignature } from '../EventHandlerSignature';
 import { IEventHandler } from '../IEventHandler';
 import { CannotRegisterEventHandlerThatIsNotAClass } from './CannotRegisterEventHandlerThatIsNotAClass';
 import { CouldNotCreateInstanceOfEventHandler } from './CouldNotCreateInstanceOfEventHandler';
-import { eventHandler as eventHandlerDecorator, getEventHandlerDecoratedType } from './eventHandlerDecorator';
+import { eventHandler as eventHandlerDecorator, getDecoratedEventHandlerType } from './eventHandlerDecorator';
 import { HandlesDecoratedMethod } from './HandlesDecoratedMethod';
 import { handles as handlesDecorator, getHandlesDecoratedMethods } from './handlesDecorator';
 
@@ -53,7 +53,7 @@ export class EventHandlerClassBuilder<T> {
      */
     build(eventTypes: IEventTypes, bindings: IServiceProviderBuilder, results: IClientBuildResults): IEventHandler | undefined {
         results.addInformation(`Building event handler of type ${this._eventHandlerType.name}`);
-        const decoratedType = getEventHandlerDecoratedType(this._eventHandlerType);
+        const decoratedType = getDecoratedEventHandlerType(this._eventHandlerType);
         if (decoratedType === undefined) {
             results.addFailure(`The event handler class ${this._eventHandlerType.name} must be decorated with an @${eventHandlerDecorator.name} decorator`);
             return;
diff --git a/Source/events.handling/Builders/_exports.ts b/Source/events.handling/Builders/_exports.ts
@@ -7,7 +7,7 @@ export { EventHandlerBuilder } from './EventHandlerBuilder';
 export { EventHandlerBuilderCallback } from './EventHandlerBuilderCallback';
 export { EventHandlerClassBuilder } from './EventHandlerClassBuilder';
 export { EventHandlerDecoratedType } from './EventHandlerDecoratedType';
-export { eventHandler, getEventHandlerDecoratedType } from './eventHandlerDecorator';
+export { eventHandler, isDecoratedEventHandlerType, getDecoratedEventHandlerType } from './eventHandlerDecorator';
 export { EventHandlerMethodsBuilder } from './EventHandlerMethodsBuilder';
 export { EventHandlerOptions } from './EventHandlerOptions';
 export { EventHandlersBuilder } from './EventHandlersBuilder';
diff --git a/Source/events.handling/Builders/eventHandlerDecorator.ts b/Source/events.handling/Builders/eventHandlerDecorator.ts
@@ -31,11 +31,20 @@ export function eventHandler(eventHandlerId: EventHandlerId | Guid | string, opt
     });
 }
 
+/**
+ * Checks whether the specified class is decorated with an event handler type.
+ * @param {Constructor<any>} type - The class to check the decorated event handler type for.
+ * @returns {boolean} True if the decorator is applied, false if not.
+ */
+export function isDecoratedEventHandlerType(type: Constructor<any>): boolean {
+    return getMetadata(type, false, false) !== undefined;
+}
+
 /**
  * Gets the {@link EventHandlerDecoratedType} of the specified class.
  * @param {Constructor<any>} type - The class to get the decorated event handler type for.
  * @returns {EventHandlerDecoratedType | undefined} The decorated event handler type if decorated.
  */
-export function getEventHandlerDecoratedType(type: Constructor<any>): EventHandlerDecoratedType | undefined {
+export function getDecoratedEventHandlerType(type: Constructor<any>): EventHandlerDecoratedType | undefined {
     return getMetadata(type);
 }
diff --git a/Source/events.handling/index.ts b/Source/events.handling/index.ts
@@ -11,7 +11,8 @@ export {
     EventHandlerClassBuilder,
     EventHandlerDecoratedType,
     eventHandler,
-    getEventHandlerDecoratedType,
+    isDecoratedEventHandlerType,
+    getDecoratedEventHandlerType,
     EventHandlerMethodsBuilder,
     EventHandlerOptions,
     EventHandlersBuilder,
diff --git a/Source/events/_exports.ts b/Source/events/_exports.ts
@@ -13,7 +13,7 @@ export { EventLogSequenceNumberMustBeAPositiveInteger } from './EventLogSequence
 export { EventSourceId } from './EventSourceId';
 export { EventType } from './EventType';
 export { EventTypeAlias, EventTypeAliasLike } from './EventTypeAlias';
-export { eventType, getDecoratedEventType } from './eventTypeDecorator';
+export { eventType, isDecoratedWithEventType, getDecoratedEventType } from './eventTypeDecorator';
 export { EventTypeId, EventTypeIdLike } from './EventTypeId';
 export { EventTypeMap } from './EventTypeMap';
 export { EventTypeOptions } from './EventTypeOptions';
diff --git a/Source/events/eventTypeDecorator.ts b/Source/events/eventTypeDecorator.ts
@@ -28,6 +28,15 @@ export function eventType(identifier: EventTypeIdLike, options: EventTypeOptions
     });
 }
 
+/**
+ * Checks whether the specified class is decorated with an event type.
+ * @param {Constructor<any>} type - The class to check the decorated event type for.
+ * @returns {boolean} True if the decorator is applied, false if not.
+ */
+export function isDecoratedWithEventType(type: Constructor<any>): boolean {
+    return getMetadata(type, false, false) !== undefined;
+}
+
 /**
  * Gets the decorated event type of the specified class.
  * @param {Constructor<any>} type - The class to get the decorated event type for.
diff --git a/Source/projections/Builders/ProjectionClassBuilder.ts b/Source/projections/Builders/ProjectionClassBuilder.ts
@@ -15,7 +15,7 @@ import { Projection } from '../Projection';
 import { ProjectionCallback } from '../ProjectionCallback';
 import { CannotRegisterProjectionThatIsNotAClass } from './CannotRegisterProjectionThatIsNotAClass';
 import { OnDecoratedProjectionMethod } from './OnDecoratedProjectionMethod';
-import { projection as projectionDecorator, getProjectionDecoratedType } from './projectionDecorator';
+import { projection as projectionDecorator, getDecoratedProjectionType } from './projectionDecorator';
 import { getOnDecoratedMethods } from './onDecorator';
 
 /**
@@ -50,7 +50,7 @@ export class ProjectionClassBuilder<T> {
     build(eventTypes: IEventTypes, results: IClientBuildResults): IProjection<T> | undefined {
 
         results.addInformation(`Building projection of type ${this._projectionType.name}`);
-        const decoratedType = getProjectionDecoratedType(this._projectionType);
+        const decoratedType = getDecoratedProjectionType(this._projectionType);
         if (decoratedType === undefined) {
             results.addFailure(`The projection class ${this._projectionType.name} must be decorated with an @${projectionDecorator.name} decorator`);
             return;
diff --git a/Source/projections/Builders/_exports.ts b/Source/projections/Builders/_exports.ts
@@ -16,7 +16,7 @@ export { ProjectionBuilderForReadModel } from './ProjectionBuilderForReadModel';
 export { ProjectionClassBuilder } from './ProjectionClassBuilder';
 export { ProjectionClassOnMethod } from './ProjectionClassOnMethod';
 export { ProjectionDecoratedType } from './ProjectionDecoratedType';
-export { projection, getProjectionDecoratedType } from './projectionDecorator';
+export { projection, isDecoratedProjectionType, getDecoratedProjectionType } from './projectionDecorator';
 export { ProjectionOptions } from './ProjectionOptions';
 export { ProjectionsBuilder } from './ProjectionsBuilder';
 export { ProjectionsBuilderCallback } from './ProjectionsBuilderCallback';
diff --git a/Source/projections/Builders/projectionDecorator.ts b/Source/projections/Builders/projectionDecorator.ts
@@ -28,11 +28,20 @@ export function projection(projectionId: ProjectionId | Guid | string, options:
     });
 }
 
+/**
+ * Checks whether the specified class is decorated with an projection type.
+ * @param {Constructor<any>} type - The class to check the decorated projection type for.
+ * @returns {boolean} True if the decorator is applied, false if not.
+ */
+export function isDecoratedProjectionType(type: Constructor<any>): boolean {
+    return getMetadata(type, false, false) !== undefined;
+}
+
 /**
  * Gets the {@link ProjectionDecoratedType} of the specified class.
  * @param {Constructor<any>} type - The class to get the decorated projection type for.
  * @returns {ProjectionDecoratedType | undefined} The decorated projection type if decorated.
  */
-export function getProjectionDecoratedType(type: Constructor<any>): ProjectionDecoratedType | undefined {
+export function getDecoratedProjectionType(type: Constructor<any>): ProjectionDecoratedType | undefined {
     return getMetadata(type);
 }
diff --git a/Source/projections/Store/ProjectionAssociations.ts b/Source/projections/Store/ProjectionAssociations.ts
diff --git a/Source/projections/index.ts b/Source/projections/index.ts
diff --git a/Source/sdk/Builders/SetupBuilder.ts b/Source/sdk/Builders/SetupBuilder.ts
diff --git a/Source/sdk/Internal/Discovery/ClassCallback.ts b/Source/sdk/Internal/Discovery/ClassCallback.ts
diff --git a/Source/sdk/Internal/Discovery/ICanTraverseModules.ts b/Source/sdk/Internal/Discovery/ICanTraverseModules.ts
diff --git a/Source/sdk/Internal/Discovery/ModuleTraverser.ts b/Source/sdk/Internal/Discovery/ModuleTraverser.ts
diff --git a/Source/sdk/Internal/Discovery/_exports.ts b/Source/sdk/Internal/Discovery/_exports.ts
diff --git a/Source/sdk/Internal/_exports.ts b/Source/sdk/Internal/_exports.ts
diff --git a/Source/sdk/package.json b/Source/sdk/package.json
