Merge pull request #101 from dolittle/type-registration-rules

Type registration rules

Author: jakhog

Samples/Tutorials/Aggregates/DishHandler.ts

@@ -3,15 +3,21 @@
 
 // Sample code for the tutorial at https://dolittle.io/tutorials/aggregates/
 
+import { inject } from '@dolittle/sdk.dependencyinversion';
 import { EventContext } from '@dolittle/sdk.events';
 import { eventHandler, handles } from '@dolittle/sdk.events.handling';
+import { Logger } from 'winston';
+
 import { DishPrepared } from './DishPrepared';
 
 @eventHandler('f2d366cf-c00a-4479-acc4-851e04b6fbba')
 export class DishHandler {
+    constructor(
+        @inject('Logger') private readonly _logger: Logger
+    ) {}
 
     @handles(DishPrepared)
-    dishPrepared(event: DishPrepared, eventContext: EventContext) {
-        console.log(`${event.Chef} has prepared ${event.Dish}. Yummm!`);
+    async dishPrepared(event: DishPrepared, eventContext: EventContext) {
+        this._logger.info(`${event.Chef} has prepared ${event.Dish}. Yummm!`);
     }
 }

Samples/Tutorials/Aggregates/Kitchen.ts

@@ -5,6 +5,7 @@
 
 import { aggregateRoot, AggregateRoot, on } from '@dolittle/sdk.aggregates';
 import { EventSourceId } from '@dolittle/sdk.events';
+
 import { DishPrepared } from './DishPrepared';
 
 @aggregateRoot('01ad9a9f-711f-47a8-8549-43320f782a1e')

Samples/Tutorials/Aggregates/index.ts

@@ -5,27 +5,17 @@
 
 import { DolittleClient } from '@dolittle/sdk';
 import { TenantId } from '@dolittle/sdk.execution';
-import { DishPrepared } from './DishPrepared';
-import { DishHandler } from './DishHandler';
+
+import  './DishHandler';
 import { Kitchen } from './Kitchen';
 
 (async () => {
     const client = await DolittleClient
-        .setup(builder => builder
-            .withEventTypes(eventTypes =>
-                eventTypes.register(DishPrepared))
-            .withEventHandlers(builder =>
-                builder.registerEventHandler(DishHandler))
-            .withAggregateRoots(aggregateRoots =>
-                aggregateRoots.register(Kitchen)))
+        .setup()
         .connect();
 
-    // TODO: aggregates
-    // await client
-    //     .aggregateOf(Kitchen, 'Dolittle Tacos', _ => _.forTenant(TenantId.development))
-        // .perform(kitchen => kitchen.prepareDish('Bean Blaster Taco', 'Mr. Taco'));
-
-    console.log('Done');
+    await client.aggregates
+        .forTenant(TenantId.development)
+        .get(Kitchen, 'Dolittle Tacos')
+        .perform(kitchen => kitchen.prepareDish('Bean Blaster Taco', 'Mr. Taco'));
 })();
-setInterval(function () {
-}, 1000 * 60 * 60);

Samples/Tutorials/Embeddings/Employee.ts

@@ -5,6 +5,7 @@
 
 import { CouldNotResolveUpdateToEvents, embedding, EmbeddingContext, EmbeddingProjectContext, on, resolveDeletionToEvents, resolveUpdateToEvents } from '@dolittle/sdk.embeddings';
 import { ProjectionResult } from '@dolittle/sdk.projections';
+
 import { EmployeeHired } from './EmployeeHired';
 import { EmployeeRetired } from './EmployeeRetired';
 import { EmployeeTransferred } from './EmployeeTransferred';

Samples/Tutorials/Embeddings/index.ts

@@ -5,49 +5,40 @@
 
 import { DolittleClient } from '@dolittle/sdk';
 import { TenantId } from '@dolittle/sdk.execution';
+import { setTimeout } from 'timers/promises';
+
 import { Employee } from './Employee';
-import { EmployeeHired } from './EmployeeHired';
-import { EmployeeRetired } from './EmployeeRetired';
-import { EmployeeTransferred } from './EmployeeTransferred';
 
 (async () => {
     const client = await DolittleClient
-        .setup(builder => builder
-            .withEventTypes(eventTypes => {
-                eventTypes.register(EmployeeHired);
-                eventTypes.register(EmployeeTransferred);
-                eventTypes.register(EmployeeRetired);
-            })
-            .withEmbeddings(builder => {
-                builder.registerEmbedding(Employee);
-            }))
+        .setup()
         .connect();
 
     // wait for the registration to complete
-    setTimeout(async () => {
-        // mock of the state from the external HR system
-        const updatedEmployee = new Employee(
-            'Mr. Taco',
-            'Street Food Taco Truck');
-
-        await client.embeddings
-            .forTenant(TenantId.development)
-            .update(Employee, updatedEmployee.name, updatedEmployee);
-        console.log(`Updated ${updatedEmployee.name}`);
-
-        const mrTaco = await client.embeddings
-            .forTenant(TenantId.development)
-            .get(Employee, 'Mr. Taco');
-        console.log(`Mr. Taco is now working at ${mrTaco.state.workplace}`);
-
-        const allEmployeeNames = await client.embeddings
-            .forTenant(TenantId.development)
-            .getKeys(Employee);
-        console.log(`All current employees are ${allEmployeeNames}`);
-
-        await client.embeddings
-            .forTenant(TenantId.development)
-            .delete(Employee, updatedEmployee.name);
-        console.log(`Deleted ${updatedEmployee.name}`);
-    }, 1000);
+    await setTimeout(1000);
+
+    // mock of the state from the external HR system
+    const updatedEmployee = new Employee(
+        'Mr. Taco',
+        'Street Food Taco Truck');
+
+    await client.embeddings
+        .forTenant(TenantId.development)
+        .update(Employee, updatedEmployee.name, updatedEmployee);
+    console.log(`Updated ${updatedEmployee.name}`);
+
+    const mrTaco = await client.embeddings
+        .forTenant(TenantId.development)
+        .get(Employee, 'Mr. Taco');
+    console.log(`Mr. Taco is now working at ${mrTaco.state.workplace}`);
+
+    const allEmployeeNames = await client.embeddings
+        .forTenant(TenantId.development)
+        .getKeys(Employee);
+    console.log(`All current employees are ${allEmployeeNames}`);
+
+    await client.embeddings
+        .forTenant(TenantId.development)
+        .delete(Employee, updatedEmployee.name);
+    console.log(`Deleted ${updatedEmployee.name}`);
 })();

Samples/Tutorials/GettingStarted/DishHandler.ts

@@ -3,35 +3,21 @@
 
 // Sample code for the tutorial at https://dolittle.io/tutorials/getting-started/typescript/
 
-import { Logger } from 'winston';
 import { inject } from '@dolittle/sdk.dependencyinversion';
-import { EventContext, IEventStore } from '@dolittle/sdk.events';
+import { EventContext } from '@dolittle/sdk.events';
 import { eventHandler, handles } from '@dolittle/sdk.events.handling';
+import { Logger } from 'winston';
+
 import { DishPrepared } from './DishPrepared';
 
 @eventHandler('f2d366cf-c00a-4479-acc4-851e04b6fbba')
-@inject('logger', IEventStore)
 export class DishHandler {
-
     constructor(
-        // @inject('logger') private readonly _logger: Logger,
-        // @inject(IEventStore) private readonly _eventStore: IEventStore,
-        private readonly _logger: Logger,
-        private readonly _eventStore: IEventStore,
+        @inject('Logger') private readonly _logger: Logger
     ) {}
 
     @handles(DishPrepared)
     async dishPrepared(event: DishPrepared, eventContext: EventContext) {
-        console.log(`${event.Chef} has prepared ${event.Dish}. Yummm!`);
-        this._logger.info('Hello nice message from the eventhandler');
-
-        await new Promise<void>((resolve) => {
-            setTimeout(async () => {
-                await this._eventStore.commit(new DishPrepared('EventHandlerChef', 'RecursiveDish'), 'Dakitchen');
-                resolve();
-            }, 1000);
-        });
-
-        this._logger.info('Committed new event');
+        this._logger.info(`${event.Chef} has prepared ${event.Dish}. Yummm!`);
     }
 }

Samples/Tutorials/GettingStarted/index.ts

@@ -5,8 +5,9 @@
 
 import { DolittleClient } from '@dolittle/sdk';
 import { TenantId } from '@dolittle/sdk.execution';
-import { DishPrepared } from './DishPrepared';
+
 import './DishHandler';
+import { DishPrepared } from './DishPrepared';
 
 (async () => {
     const client = await DolittleClient

Samples/Tutorials/Projections/DishCounter.ts

@@ -4,6 +4,7 @@
 // Sample code for the tutorial at https://dolittle.io/tutorials/projections/typescript/
 
 import { ProjectionContext, projection, on } from '@dolittle/sdk.projections';
+
 import { DishPrepared } from './DishPrepared';
 
 @projection('98f9db66-b6ca-4e5f-9fc3-638626c9ecfa')

Samples/Tutorials/Projections/index.ts

@@ -5,18 +5,16 @@
 
 import { DolittleClient } from '@dolittle/sdk';
 import { TenantId } from '@dolittle/sdk.execution';
-import { DishPrepared } from './DishPrepared';
-import { DishCounter } from './DishCounter';
+import { setTimeout } from 'timers/promises';
+
 import { Chef } from './Chef';
+import { DishCounter } from './DishCounter';
+import { DishPrepared } from './DishPrepared';
 
 (async () => {
     const client = await DolittleClient
         .setup(builder => builder
-            .withEventTypes(eventTypes =>
-                eventTypes.register(DishPrepared))
             .withProjections(builder => {
-                builder.registerProjection(DishCounter);
-
                 builder.createProjection('0767bc04-bc03-40b8-a0be-5f6c6130f68b')
                     .forReadModel(Chef)
                     .on(DishPrepared, _ => _.keyFromProperty('Chef'), (chef, event, projectionContext) => {
@@ -34,12 +32,12 @@ import { Chef } from './Chef';
     await eventStore.commit(new DishPrepared('Avocado Artillery Tortilla', 'Mr. Taco'), 'Dolittle Tacos');
     await eventStore.commit(new DishPrepared('Chili Canon Wrap', 'Mrs. Tex Mex'), 'Dolittle Tacos');
 
-    setTimeout(async () => {
-        for (const [dish, { state: counter }] of await client.projections.forTenant(TenantId.development).getAll(DishCounter)) {
-            console.log(`The kitchen has prepared ${dish} ${counter.numberOfTimesPrepared} times`);
-        }
+    await setTimeout(1000);
+
+    for (const [dish, { state: counter }] of await client.projections.forTenant(TenantId.development).getAll(DishCounter)) {
+        console.log(`The kitchen has prepared ${dish} ${counter.numberOfTimesPrepared} times`);
+    }
 
-        const chef = await client.projections.forTenant(TenantId.development).get<Chef>(Chef, 'Mrs. Tex Mex');
-        console.log(`${chef.key} has prepared ${chef.state.dishes}`);
-    }, 1000);
+    const chef = await client.projections.forTenant(TenantId.development).get<Chef>(Chef, 'Mrs. Tex Mex');
+    console.log(`${chef.key} has prepared ${chef.state.dishes}`);
 })();

Source/aggregates/AggregateOf.ts

@@ -4,10 +4,11 @@
 import { Logger } from 'winston';
 import { Constructor } from '@dolittle/types';
 
-import { EventSourceId, IEventStore, IEventTypes } from '@dolittle/sdk.events';
+import { EventSourceId, EventSourceIdLike, IEventStore, IEventTypes } from '@dolittle/sdk.events';
 
 import { AggregateRoot } from './AggregateRoot';
 import { AggregateRootOperations } from './AggregateRootOperations';
+import { AggregateRootType } from './AggregateRootType';
 import { IAggregateOf } from './IAggregateOf';
 import { IAggregateRootOperations } from './IAggregateRootOperations';
 
@@ -19,13 +20,15 @@ export class AggregateOf<TAggregateRoot extends AggregateRoot> extends IAggregat
 
     /**
      * Initialises a new instance of the {@link AggregateOf} class.
-     * @param {Constructor<TAggregateRoot>} _type - The type of the aggregate root implementation.
+     * @param {Constructor<TAggregateRoot>} _type - The class implementing the aggregate root.
+     * @param {AggregateRootType} _aggregateRootType - The aggregate root type associated with the aggregate root.
      * @param {IEventStore} _eventStore - The event store to fetch committed events from and commit aggregate events with.
      * @param {IEventTypes} _eventTypes - All registered event types.
      * @param {Logger} _logger - The logger to use for logging.
      */
     constructor(
         private readonly _type: Constructor<TAggregateRoot>,
+        private readonly _aggregateRootType: AggregateRootType,
         private readonly _eventStore: IEventStore,
         private readonly _eventTypes: IEventTypes,
         private readonly _logger: Logger) {
@@ -38,7 +41,13 @@ export class AggregateOf<TAggregateRoot extends AggregateRoot> extends IAggregat
     }
 
     /** @inheritdoc */
-    get(eventSourceId: EventSourceId): IAggregateRootOperations<TAggregateRoot> {
-        return new AggregateRootOperations<TAggregateRoot>(eventSourceId, this._eventStore, this._type, this._eventTypes, this._logger);
+    get(eventSourceId: EventSourceIdLike): IAggregateRootOperations<TAggregateRoot> {
+        return new AggregateRootOperations<TAggregateRoot>(
+            this._type,
+            this._aggregateRootType,
+            EventSourceId.from(eventSourceId),
+            this._eventStore,
+            this._eventTypes,
+            this._logger);
     }
 }