ddd-team1 0.0.7 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ddd-team1",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "type": "module",
   "bin": {
     "ddd-team1": "./src/infrastructure/tui/index.tsx"

package/src/application/MakeMoveUseCase.ts

@@ -9,7 +9,7 @@ export class MakeMoveUseCase {
   constructor(private repo: GameRepository) {}
 
   async execute(gameId: Game['id'], standardAlgebraicNotation: string): Promise<void> {
-    let game = await this.repo.findById(gameId) ?? new Game(gameId);
+    const game = await this.repo.findById(gameId) ?? new Game(gameId);
     const expectedVersion = game.version;
     const command = {
       name: 'Make move!' as const,

package/src/domain/Game.ts

@@ -1,6 +1,6 @@
 import type { UUID } from 'crypto';
 import type { Command } from './Command.ts';
-import type { DomainEvent, GameStartedEvent, MoveMadeEvent } from './DomainEvent.ts';
+import type { DomainEvent } from './DomainEvent.ts';
 import { AggregateRoot } from './shared';
 import { Board } from './value-objects/Board.ts';
 import { StandardAlgebraicNotationMove } from './value-objects/StandardAlgebraicNotationMove.ts';
@@ -14,23 +14,22 @@ export class Game extends AggregateRoot<UUID> {
 
   static fromEvents(id: UUID, events: DomainEvent[]): Game {
     const game = new Game(id);
-    game.replay(events);
-    game.setVersion(events.filter(e => e.aggregateId === id).length);
+    game.rehydrate(events.filter(e => e.aggregateId === id));
     return game;
   }
 
-  replay(events: DomainEvent[]): void {
-    events
-      .filter(event => event.aggregateId === this.id)
-      .forEach(event => {
-        if (event.name === 'Move made.') {
-          this.board = this.board.play(StandardAlgebraicNotationMove.fromString(event.payload));
-        }
-      });
+  protected apply(event: DomainEvent): void {
+    switch (event.name) {
+      case 'Game started.':
+        break;
+      case 'Move made.':
+        this.board = this.board.play(StandardAlgebraicNotationMove.fromString(event.payload));
+        break;
+    }
   }
 
-  move(move: StandardAlgebraicNotationMove): DomainEvent[] {
-    if (this.board.equals(new Board())) {
+  move(move: StandardAlgebraicNotationMove): void {
+    if (this.version === 0) {
       this.recordThat({
         name: 'Game started.',
         aggregateId: this.id,
@@ -42,14 +41,13 @@ export class Game extends AggregateRoot<UUID> {
       aggregateId: this.id,
       payload: move.toString(),
     });
-    this.replay(this.newlyRecordEvents);
-    return this.newlyRecordEvents;
   }
 
-  execute(command: Command): DomainEvent[] {
+  execute(command: Command): void {
     switch (command.name) {
       case 'Make move!':
-        return this.move(command.payload.move);
+        this.move(command.payload.move);
+        break;
       default:
         throw new Error(`Unknown command: ${command.name}`);
     }

package/src/domain/shared/AggregateRoot.ts

@@ -3,28 +3,35 @@ import type { DomainEvent } from "../DomainEvent.ts";
 
 export abstract class AggregateRoot<T> extends Entity<T>
 {
-    protected newlyRecordEvents: DomainEvent[] = [];
+    private _newlyRecordedEvents: DomainEvent[] = [];
     private _version = 0;
 
     get version(): number {
         return this._version;
     }
 
-    flushEvents(): DomainEvent[] {
-        const eventsToFlush = [...this.newlyRecordEvents];
-        this.newlyRecordEvents = [];
-        return eventsToFlush;
-    }
-
     constructor(id: T){
         super(id);
     }
 
-    protected setVersion(version: number): void {
-        this._version = version;
+    protected abstract apply(event: DomainEvent): void;
+
+    protected recordThat(event: DomainEvent): void {
+        this.apply(event);
+        this._version++;
+        this._newlyRecordedEvents.push(event);
     }
 
-    recordThat(event: DomainEvent): void {
-        this.newlyRecordEvents.push(event);
+    rehydrate(events: DomainEvent[]): void {
+        for (const event of events) {
+            this.apply(event);
+            this._version++;
+        }
+    }
+
+    flushEvents(): DomainEvent[] {
+        const eventsToFlush = [...this._newlyRecordedEvents];
+        this._newlyRecordedEvents = [];
+        return eventsToFlush;
     }
 }