skills/hexagonal-architecture/SKILL.md (1)

119-202: LGTM! Comprehensive TypeScript example demonstrates key concepts.

The TypeScript example effectively illustrates:

• Clean port interface definitions
• Use case orchestration with dependency injection
• Outbound adapter implementation
• Explicit composition root wiring

The comment at line 161 explaining immutability is helpful. The example correctly shows ports as abstractions with concrete implementations in adapters.

Consider showing the Order domain entity.

The example references Order.create() (line 154), order.markAuthorized() (line 162), and Order.rehydrate() (line 188), but the Order domain entity implementation is not shown. While the focus is on architecture boundaries, showing a brief domain entity example would make the skill more complete and help readers understand what "business rules and entities/value objects" (line 22) look like in practice.

📝 Optional: Add Order domain entity example

Consider adding this example after line 122 or in a separate domain section:

// Domain entity - no framework dependencies
export class Order {
  private constructor(
    public readonly id: string,
    public readonly amountCents: number,
    public readonly status: 'pending' | 'authorized',
    public readonly authorizationId?: string
  ) {}

  static create(props: { id: string; amountCents: number }): Order {
    if (props.amountCents <= 0) {
      throw new Error('Order amount must be positive');
    }
    return new Order(props.id, props.amountCents, 'pending');
  }

  markAuthorized(authorizationId: string): Order {
    return new Order(this.id, this.amountCents, 'authorized', authorizationId);
  }

  static rehydrate(row: any): Order {
    return new Order(row.id, row.amount_cents, row.status, row.authorization_id);
  }
}

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@skills/hexagonal-architecture/SKILL.md` around lines 119 - 202, Add a brief
Order domain-entity example to the TypeScript sample so the referenced methods
are defined: create a simple Order class that includes a static create(id,
amountCents), an instance method markAuthorized(authorizationId) that returns a
new Order, and a static rehydrate(row) to map DB rows to Order instances; insert
this class near the top of the example (before CreateOrderUseCase) so calls to
Order.create, order.markAuthorized, and Order.rehydrate resolve and readers can
see the business-rule checks and immutability behavior.