ddd-team1 0.0.1

package/README.md

@@ -0,0 +1,30 @@
+# DDD Chess
+
+A Domain-Driven Design chess implementation in TypeScript.
+
+## Prerequisites
+
+- [Bun](https://bun.sh/) (v1.0+)
+
+## Getting Started
+
+```bash
+bun install
+```
+
+## Playing
+
+Start the terminal UI:
+
+```bash
+bun start
+```
+
+Enter moves in algebraic notation, e.g. `e2 e4` to move a piece from e2 to e4.
+
+## Running Tests
+
+```bash
+bun test
+bun test --watch
+```

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "ddd-team1",
+  "version": "0.0.1",
+  "type": "module",
+  "bin": {
+    "ddd-team1": "./src/infrastructure/tui/index.tsx"
+  },
+  "files": [
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "!src/**/*.test.ts"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "start": "bun src/infrastructure/tui/index.tsx",
+    "test": "bun test",
+    "test:watch": "bun test --watch"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "@types/react": "^19.2.13",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "firebase": "^12.9.0",
+    "ink": "^6.7.0",
+    "react": "^19.2.4",
+    "reflect-metadata": "^0.2.2"
+  }
+}

package/src/application/AuthService.ts

@@ -0,0 +1,3 @@
+export interface AuthService {
+  getUid(): string;
+}

package/src/application/GameRepository.ts

@@ -0,0 +1,11 @@
+import type { UUID } from 'crypto';
+import type { DomainEvent } from '../domain/DomainEvent.ts';
+import type { Game } from '../domain/Game.ts';
+
+export interface GameRepository {
+  save(events: DomainEvent[]): Promise<void>;
+  save(event: DomainEvent): Promise<void>;
+  findById(id: UUID): Promise<Game | null>;
+  getEvents(id: UUID): Promise<DomainEvent[]>;
+  list(): Promise<Array<UUID>>;
+}

package/src/application/GetGameStateQuery.ts

@@ -0,0 +1,46 @@
+import type { UUID } from 'crypto';
+import { Game } from '../domain/Game.ts';
+import type { GameRepository } from './GameRepository.ts';
+
+export interface PieceDTO {
+  color: 'white' | 'black';
+  icon: string;
+}
+
+export interface EventDTO {
+  name: string;
+  payload?: string;
+}
+
+export interface GameStateDTO {
+  id: UUID;
+  turn: number;
+  currentPlayer: 'white' | 'black';
+  board: (PieceDTO | null)[][];
+  events: EventDTO[];
+}
+
+export class GetGameStateQuery {
+  constructor(private repo: GameRepository) {}
+
+  async execute(gameId: UUID): Promise<GameStateDTO> {
+    const game = await this.repo.findById(gameId) ?? new Game(gameId);
+    const domainEvents = await this.repo.getEvents(gameId);
+    return {
+      id: gameId,
+      turn: game.currentTurn(),
+      currentPlayer: game.currentColor(),
+      board: game.getBoardState().getState().map((row) =>
+        row.map((piece) => (piece ? {color: piece.color, icon: piece.icon} : null)),
+      ),
+      events: domainEvents.map((e) => ({
+        name: e.name,
+        ...('payload' in e ? { payload: e.payload } : {}),
+      })),
+    };
+  }
+
+  async list(): Promise<GameStateDTO[]> {
+    return Promise.all((await this.repo.list()).map((id) => this.execute(id)));
+  }
+}

package/src/application/MakeMoveUseCase.ts

@@ -0,0 +1,22 @@
+import { Game } from '../domain/Game.ts';
+import {
+  StandardAlgebraicNotationMove,
+  standardAlgebraicNotationString,
+  type StandardAlgebraicNotationString
+} from '../domain/value-objects/StandardAlgebraicNotationMove.ts';
+import type { GameRepository } from './GameRepository.ts';
+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 command = {
+      name: 'Make move!' as const,
+      payload: {
+        move: StandardAlgebraicNotationMove.fromString(standardAlgebraicNotationString(`${game?.currentTurn()}. ${standardAlgebraicNotation.trim()}`)),
+      },
+    };
+    game.execute(command);
+    await this.repo.save(game.flushEvents());
+  }
+}

package/src/application/OnlineGameService.ts

@@ -0,0 +1,17 @@
+export interface GameInfo {
+  gameId: string;
+  hostUid: string;
+  hostColor: 'white' | 'black';
+  guestUid: string | null;
+  status: 'waiting' | 'active' | 'finished';
+  createdAt: Date;
+}
+
+export interface OnlineGameService {
+  createGame(hostUid: string): Promise<GameInfo>;
+  joinGame(gameId: string, guestUid: string): Promise<GameInfo>;
+  listHostedGames(uid: string): Promise<GameInfo[]>;
+  listJoinedGames(uid: string): Promise<GameInfo[]>;
+  onGameInfoChanged(gameId: string, callback: (info: GameInfo) => void): () => void;
+  onEventsChanged(gameId: string, callback: (events: { index: number; name: string; aggregateId: string; payload?: string }[]) => void): () => void;
+}

package/src/domain/Command.ts

@@ -0,0 +1,12 @@
+import type { StandardAlgebraicNotationMove } from './value-objects/StandardAlgebraicNotationMove.ts';
+
+export type Command = MakeMoveCommand
+
+export type CommandBase<CommandName extends `${string}!`, Payload = never> = {
+  name: CommandName
+  payload: Payload
+}
+
+export type MakeMoveCommand = CommandBase<'Make move!', {
+  move: StandardAlgebraicNotationMove
+}>

package/src/domain/DomainEvent.ts

@@ -0,0 +1,20 @@
+import type { UUID } from 'crypto'
+import type {
+  StandardAlgebraicNotationMove,
+  StandardAlgebraicNotationString
+} from './value-objects/StandardAlgebraicNotationMove.ts';
+
+export type EventBase<EventName extends `${string}.`, Payload = never, AggregateId = UUID> = [Payload] extends [never] ? {
+  name: EventName
+  aggregateId: AggregateId
+} : {
+  name: EventName
+  aggregateId: AggregateId
+  payload: Payload
+};
+
+export type GameStartedEvent = EventBase<'Game started.'>;
+
+export type MoveMadeEvent = EventBase<'Move made.', StandardAlgebraicNotationString>;
+
+export type DomainEvent = GameStartedEvent | MoveMadeEvent;

package/src/domain/Game.ts

@@ -0,0 +1,72 @@
+import type { UUID } from 'crypto';
+import type { Command } from './Command.ts';
+import type { DomainEvent, GameStartedEvent, MoveMadeEvent } from './DomainEvent.ts';
+import { AggregateRoot } from './shared';
+import { Board } from './value-objects/Board.ts';
+import { StandardAlgebraicNotationMove } from './value-objects/StandardAlgebraicNotationMove.ts';
+
+export class Game extends AggregateRoot<UUID> {
+  private board = new Board();
+
+  constructor(id: UUID) {
+    super(id);
+  }
+
+  static fromEvents(id: UUID, events: DomainEvent[]): Game {
+    const game = new Game(id);
+    game.replay(events);
+    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));
+        }
+      });
+  }
+
+  move(move: StandardAlgebraicNotationMove): DomainEvent[] {
+    if (this.board.equals(new Board())) {
+      this.recordThat({
+        name: 'Game started.',
+        aggregateId: this.id,
+      });
+    }
+
+    this.recordThat({
+      name: 'Move made.',
+      aggregateId: this.id,
+      payload: move.toString(),
+    });
+    this.replay(this.newlyRecordEvents);
+    return this.newlyRecordEvents;
+  }
+
+  execute(command: Command): DomainEvent[] {
+    switch (command.name) {
+      case 'Make move!':
+        return this.move(command.payload.move);
+      default:
+        throw new Error(`Unknown command: ${command.name}`);
+    }
+  }
+
+  getBoardState(): Board {
+    return this.board;
+  }
+
+  getBoardStateFormatted(): string {
+    return this.board.getBoardStateFormatted();
+  }
+
+  currentColor() {
+    return this.board.color;
+  }
+
+  currentTurn() {
+    return this.board.turn;
+  }
+}

package/src/domain/shared/AggregateRoot.ts

@@ -0,0 +1,21 @@
+import { Entity } from "./Entity";
+import type { DomainEvent } from "../DomainEvent.ts";
+
+export abstract class AggregateRoot<T> extends Entity<T>
+{
+    protected newlyRecordEvents: DomainEvent[] = [];
+
+    flushEvents(): DomainEvent[] {
+        const eventsToFlush = [...this.newlyRecordEvents];
+        this.newlyRecordEvents = [];
+        return eventsToFlush;
+    }
+
+    constructor(id: T){
+        super(id);
+    }
+
+    recordThat(event: DomainEvent): void {
+        this.newlyRecordEvents.push(event);
+    }
+}

package/src/domain/shared/BusinessRules/BusinessRule.ts

@@ -0,0 +1,16 @@
+import { BusinessRuleViolation, BusinessRuleViolationError } from "..";
+
+export abstract class BusinessRule {
+    public abstract checkRule(): BusinessRuleViolation[]
+}
+
+export class BusinessRules {
+    public static ThrowIfAnyNotSatisfied(...businessRules: BusinessRule[]) : void {
+
+        let violations = businessRules.flatMap(rule => rule.checkRule());
+
+        if(violations && violations.length > 0) {
+            throw new BusinessRuleViolationError(violations);
+        }
+    }
+}

package/src/domain/shared/BusinessRules/BusinessRuleViolation.ts

@@ -0,0 +1,7 @@
+export class BusinessRuleViolation {
+    public violationMessage: string;
+
+    constructor(violationMessage: string) {
+        this.violationMessage = violationMessage;
+    }
+}

package/src/domain/shared/BusinessRules/BusinessRuleViolationError.ts

@@ -0,0 +1,10 @@
+import { BusinessRuleViolation } from "..";
+
+export class BusinessRuleViolationError extends Error {
+    public violations: BusinessRuleViolation[];
+
+    public constructor(violations: BusinessRuleViolation[]) {
+        super();
+        this.violations = violations;
+    }
+}

package/src/domain/shared/Entity.ts

@@ -0,0 +1,7 @@
+export abstract class Entity<TId> {
+    public readonly id: TId;
+
+    constructor(id: TId) {
+        this.id = id;
+    }
+}

package/src/domain/shared/ValueObject.ts

@@ -0,0 +1,20 @@
+export abstract class ValueObject {
+    protected abstract getAtomicValues() : any[];
+
+    public equals(obj: any) {
+        if (!(obj instanceof ValueObject)) {
+            return false;
+        }
+        else {
+            let thisValues = this.getAtomicValues();
+            let thatValues = obj.getAtomicValues();
+
+            if(thisValues.length !== thatValues.length) return false;
+
+            for(let i = 0; i < thisValues.length; i++){
+                if(thisValues[i] !== thatValues[i]) return false;
+            }
+            return true;
+        }
+    }
+}

package/src/domain/shared/index.ts

@@ -0,0 +1,6 @@
+export * from './Entity';
+export * from './ValueObject';
+export * from './AggregateRoot';
+export * from './BusinessRules/BusinessRule';
+export * from './BusinessRules/BusinessRuleViolation';
+export * from './BusinessRules/BusinessRuleViolationError';

package/src/domain/value-objects/Board.ts

@@ -0,0 +1,197 @@
+import type { StandardAlgebraicNotationMove } from "./StandardAlgebraicNotationMove.ts";
+import { Piece } from "./Piece.ts";
+import { Position } from "./Position.ts";
+import { ValueObject } from "../shared";
+import { Rook } from "./pieces/Rook.ts";
+import type { PieceV2 } from "./PieceV2.ts";
+
+type BoardState = (Piece | PieceV2 | null)[][];
+
+export class Board extends ValueObject {
+  static initialBoardState: BoardState = [
+    [
+      new Rook("white"),
+      Piece.WhiteKnight,
+      Piece.WhiteBishop,
+      Piece.WhiteQueen,
+      Piece.WhiteKing,
+      Piece.WhiteBishop,
+      Piece.WhiteKnight,
+      new Rook("white"),
+    ],
+    [
+      Piece.WhitePawn,
+      Piece.WhitePawn,
+      Piece.WhitePawn,
+      Piece.WhitePawn,
+      Piece.WhitePawn,
+      Piece.WhitePawn,
+      Piece.WhitePawn,
+      Piece.WhitePawn,
+    ],
+    [null, null, null, null, null, null, null, null],
+    [null, null, null, null, null, null, null, null],
+    [null, null, null, null, null, null, null, null],
+    [null, null, null, null, null, null, null, null],
+    [
+      Piece.BlackPawn,
+      Piece.BlackPawn,
+      Piece.BlackPawn,
+      Piece.BlackPawn,
+      Piece.BlackPawn,
+      Piece.BlackPawn,
+      Piece.BlackPawn,
+      Piece.BlackPawn,
+    ],
+    [
+      new Rook("black"),
+      Piece.BlackKnight,
+      Piece.BlackBishop,
+      Piece.BlackQueen,
+      Piece.BlackKing,
+      Piece.BlackBishop,
+      Piece.BlackKnight,
+      new Rook("black"),
+    ],
+  ];
+
+  constructor(
+    protected boardState: BoardState = Board.initialBoardState,
+    public readonly turn = 1,
+  ) {
+    super();
+  }
+
+  get color(): "white" | "black" {
+    return this.turn % 2 === 1 ? "white" : "black";
+  }
+
+  play(move: StandardAlgebraicNotationMove): Board {
+    if (move.isCastling) {
+      throw new Error("Castling not yet implemented");
+    }
+    const newBoardState = this.boardState.map((row) => row.map((cell) => cell));
+    const to = move.destination!;
+    const from = this.getFromPosition(move);
+    newBoardState[to.rank]![to.file] =
+      this.boardState[from.rank]![from.file] ?? null;
+    newBoardState[from.rank]![from.file] = null;
+    return new Board(newBoardState, this.turn + 1);
+  }
+
+  getState(): BoardState {
+    return this.boardState;
+  }
+
+  getBoardStateFormatted(): string {
+    const rows = this.boardState
+      .toReversed()
+      .map(
+        (row, i) =>
+          `${8 - i}  ` + row.map((cell) => cell?.icon ?? "·").join(" "),
+      );
+    return "\n" + [...rows, "   a b c d e f g h"].join("\n");
+  }
+
+  //TODO: alleen raamwerk overlaten, validatie gaat naar het stuk (piece). betere naam bedenken
+  /**
+   * Determine FROM position based on the TO position
+   * array met posities > als meer dan 1 dan fout.
+   */
+  getFromPosition(move: StandardAlgebraicNotationMove): Position {
+    let rulesToCheck: Position[][] = [];
+    const position = move.destination;
+
+    if (!position) {
+      throw new Error("Move must have a destination");
+    }
+
+    const capturedPiece = this.boardState[position.rank]![position.file];
+    if (capturedPiece?.color == this.color) {
+      throw new Error("You cannot capture yourself");
+    }
+    if (move.piece instanceof Piece) {
+      if (move.piece?.type === "pawn" && this.color === "white") {
+        if (capturedPiece !== null) {
+          if (position.file > 0) rulesToCheck.push([position.offset(-1, -1)]);
+          if (position.file < 7) rulesToCheck.push([position.offset(1, -1)]);
+        } else {
+          let forwardMoves = [position.offset(0, -1)];
+          if (position.rank === 3) {
+            forwardMoves.push(position.offset(0, -2));
+          }
+          rulesToCheck.push(forwardMoves);
+        }
+      }
+
+      if (move.piece?.type === "pawn" && this.color === "black") {
+        if (capturedPiece !== null) {
+          if (position.file > 0) rulesToCheck.push([position.offset(-1, 1)]);
+          if (position.file < 7) rulesToCheck.push([position.offset(1, 1)]);
+        } else {
+          let forwardMoves = [position.offset(0, 1)];
+          if (position.rank === 4) {
+            forwardMoves.push(position.offset(0, 2));
+          }
+          rulesToCheck.push(forwardMoves);
+        }
+      }
+
+      if (move.piece?.type === "bishop") {
+        rulesToCheck = position.diagonalMask;
+      }
+
+      if (move.piece?.type === "knight") {
+        rulesToCheck = position.jumpMask;
+      }
+
+      if (move.piece?.type === "queen") {
+        rulesToCheck = position.straightMask.concat(position.diagonalMask);
+      }
+
+      if (move.piece?.type === "king") {
+        rulesToCheck = position.straightMask
+          .slice(0, 1)
+          .concat(position.diagonalMask.slice(0, 1));
+      }
+    } else {
+      if (move.piece instanceof Rook) {
+        rulesToCheck = move.piece.getRulesToCheck(position);
+      }
+    }
+
+    /*
+     * checks each position in the rules to see if the piece at that position matches the move's piece, and returns
+     * the first match aborts the line if it encounters a piece that doesn't match, since that would block the move
+     *
+     * TODO: this is a very naive implementation and doesn't account for many rules of chess (e.g. check, pins, en
+     *  passant, etc.) but it should work for basic moves. Also, this assumes that the move's piece is correctly set
+     *  to the piece that is actually moving, which may not always be the case (e.g. in a promotion), so this might need
+     *  to be adjusted in the future
+     */
+    for (const lineToCheck of rulesToCheck) {
+      for (const position of lineToCheck) {
+        if (
+          position.file < 0 ||
+          position.file >= 8 ||
+          position.rank < 0 ||
+          position.rank >= 8
+        ) {
+          continue;
+        }
+        const pieceAtPosition =
+          this.boardState[position.rank]![position.file] ?? null;
+        if (move.piece?.equals(pieceAtPosition)) return position;
+        if (pieceAtPosition !== null) break;
+      }
+    }
+
+    throw new Error(
+      "No valid from position found for move: " + move.toString(),
+    );
+  }
+
+  protected getAtomicValues(): any[] {
+    return [this.boardState, this.turn];
+  }
+}

package/src/domain/value-objects/Piece.ts

@@ -0,0 +1,91 @@
+import { ValueObject } from '../shared';
+
+export type PieceColor = 'white' | 'black';
+export type PieceType = 'king' | 'queen' | 'rook' | 'bishop' | 'knight' | 'pawn';
+
+const ICONS: Record<PieceColor, Record<PieceType, string>> = {
+  black: { king: '♔', queen: '♕', rook: '♖', bishop: '♗', knight: '♘', pawn: '♙' },
+  white: { king: '♚', queen: '♛', rook: '♜', bishop: '♝', knight: '♞', pawn: '♟' },
+};
+
+const PIECE_LETTER: Record<string, PieceType> = {
+  K: 'king',
+  Q: 'queen',
+  R: 'rook',
+  B: 'bishop',
+  N: 'knight',
+  '': 'pawn',
+};
+
+const LETTER_PIECE: Record<PieceType, string> = {
+  king: 'K',
+  queen: 'Q',
+  rook: 'R',
+  bishop: 'B',
+  knight: 'N',
+  pawn: '',
+}
+
+export class Piece extends ValueObject {
+  private constructor(
+    public readonly color: PieceColor,
+    public readonly type: PieceType,
+  ) {
+    super();
+  }
+
+  get icon(): string {
+    return ICONS[this.color][this.type];
+  }
+
+  override toString(): string {
+    return `${this.icon} (${this.color} ${this.type})`;
+  }
+
+  toIcon(): string {
+    return this.icon;
+  }
+
+  toChar(): string {
+    return LETTER_PIECE[this.type];
+  }
+
+  protected getAtomicValues(): any[] {
+    return [this.color, this.type];
+  }
+
+  static fromIcon(icon: string): Piece | null {
+    for (const color in ICONS) {
+      for (const type in ICONS[color as PieceColor]) {
+        if (ICONS[color as PieceColor][type as PieceType] === icon) {
+          return new Piece(color as PieceColor, type as PieceType);
+        }
+      }
+    }
+    return null;
+  }
+
+  static fromLetter(letter: string, color: 'white' | 'black'): Piece | null {
+    const pieceType = PIECE_LETTER[letter.toUpperCase()];
+    if (!pieceType) {
+      return null;
+    }
+    return new Piece(color, pieceType);
+  }
+
+  // White pieces
+  static readonly WhiteKing = new Piece('white', 'king');
+  static readonly WhiteQueen = new Piece('white', 'queen');
+  static readonly WhiteRook = new Piece('white', 'rook');
+  static readonly WhiteBishop = new Piece('white', 'bishop');
+  static readonly WhiteKnight = new Piece('white', 'knight');
+  static readonly WhitePawn = new Piece('white', 'pawn');
+
+  // Black pieces
+  static readonly BlackKing = new Piece('black', 'king');
+  static readonly BlackQueen = new Piece('black', 'queen');
+  static readonly BlackRook = new Piece('black', 'rook');
+  static readonly BlackBishop = new Piece('black', 'bishop');
+  static readonly BlackKnight = new Piece('black', 'knight');
+  static readonly BlackPawn = new Piece('black', 'pawn');
+}