デザインパターン再入門 ― GoF の23パターンを TypeScript で読み直す

interface DiscountStrategy {
  apply(price: number): number
}

const noDiscount: DiscountStrategy = { apply: (price) => price }
const percentOff = (rate: number): DiscountStrategy => ({
  apply: (price) => Math.round(price * (1 - rate)),
})
const amountOff = (amount: number): DiscountStrategy => ({
  apply: (price) => Math.max(0, price - amount),
})

class Checkout {
  constructor(private strategy: DiscountStrategy = noDiscount) {}

  setStrategy(strategy: DiscountStrategy) {
    this.strategy = strategy
  }

  total(prices: number[]): number {
    const subtotal = prices.reduce((sum, p) => sum + p, 0)
    return this.strategy.apply(subtotal)
  }
}

const checkout = new Checkout()
checkout.total([1200, 800])          // 2000
checkout.setStrategy(percentOff(0.1))
checkout.total([1200, 800])          // 1800
checkout.setStrategy(amountOff(500))
checkout.total([1200, 800])          // 1500

type Listener<T> = (payload: T) => void

class Subject<T> {
  private listeners = new Set<Listener<T>>()

  subscribe(listener: Listener<T>): () => void {
    this.listeners.add(listener)
    return () => this.listeners.delete(listener) // 購読をやめる関数を返す
  }

  notify(payload: T): void {
    for (const listener of this.listeners) listener(payload)
  }
}

interface CartEvent {
  itemCount: number
  total: number
}

const cartChanged = new Subject<CartEvent>()

const unsubscribeBadge = cartChanged.subscribe(({ itemCount }) =>
  console.log(`バッジ表示を ${itemCount} に更新`)
)
cartChanged.subscribe(({ total }) => console.log(`合計 ${total} 円を表示`))

cartChanged.notify({ itemCount: 2, total: 2000 })
// → バッジ表示を 2 に更新
// → 合計 2000 円を表示

unsubscribeBadge()
cartChanged.notify({ itemCount: 3, total: 3500 })
// → 合計 3500 円を表示（バッジはもう購読していない）

interface Row {
  name: string
  score: number
}

interface Formatter {
  header(): string
  row(row: Row): string
}

abstract class ReportExporter {
  // サブクラスが「どの Formatter を作るか」を決める（Factory Method）
  protected abstract createFormatter(): Formatter

  export(rows: Row[]): string {
    const formatter = this.createFormatter()
    return [formatter.header(), ...rows.map((r) => formatter.row(r))].join('\n')
  }
}

class CsvExporter extends ReportExporter {
  protected createFormatter(): Formatter {
    return {
      header: () => 'name,score',
      row: (r) => `${r.name},${r.score}`,
    }
  }
}

class MarkdownExporter extends ReportExporter {
  protected createFormatter(): Formatter {
    return {
      header: () => '| name | score |\n|---|---|',
      row: (r) => `| ${r.name} | ${r.score} |`,
    }
  }
}

const rows: Row[] = [{ name: 'Alice', score: 92 }, { name: 'Bob', score: 85 }]
new CsvExporter().export(rows)
// name,score
// Alice,92
// Bob,85

// アプリが期待するインターフェース
interface Logger {
  info(message: string): void
  error(message: string, cause?: unknown): void
}

// 外部ライブラリ（変更できない）
class VendorLogger {
  write(level: 'INFO' | 'ERROR', fields: Record<string, unknown>): void {
    console.log(`[vendor] ${level}`, JSON.stringify(fields))
  }
}

class VendorLoggerAdapter implements Logger {
  constructor(private readonly vendor: VendorLogger) {}

  info(message: string): void {
    this.vendor.write('INFO', { msg: message })
  }

  error(message: string, cause?: unknown): void {
    const detail = cause instanceof Error ? cause.message : cause
    this.vendor.write('ERROR', { msg: message, cause: detail })
  }
}

const logger: Logger = new VendorLoggerAdapter(new VendorLogger())
logger.error('保存に失敗しました', new Error('disk full'))
// → [vendor] ERROR {"msg":"保存に失敗しました","cause":"disk full"}

interface DataSource {
  fetch(key: string): Promise<string>
}

// 失敗したら、指定回数まで再試行する
class RetrySource implements DataSource {
  constructor(private readonly inner: DataSource, private readonly retries = 2) {}

  async fetch(key: string): Promise<string> {
    let lastError: unknown
    for (let attempt = 0; attempt <= this.retries; attempt++) {
      try {
        return await this.inner.fetch(key)
      } catch (e) {
        lastError = e
      }
    }
    throw lastError
  }
}

// 同じキーの結果を使い回す
class CachedSource implements DataSource {
  private readonly cache = new Map<string, Promise<string>>()

  constructor(private readonly inner: DataSource) {}

  fetch(key: string): Promise<string> {
    let hit = this.cache.get(key)
    if (!hit) {
      hit = this.inner.fetch(key)
      this.cache.set(key, hit)
      hit.catch(() => this.cache.delete(key)) // 失敗はキャッシュしない
    }
    return hit
  }
}

// 1回目は失敗し、2回目に成功する API（例）
let calls = 0
const flakyApi: DataSource = {
  async fetch(key) {
    calls++
    if (calls === 1) throw new Error('temporary failure')
    return `value of ${key}`
  },
}

const source: DataSource = new CachedSource(new RetrySource(flakyApi))
await source.fetch('a') // "value of a"（内部で1回再試行。calls = 2）
await source.fetch('a') // "value of a"（キャッシュから。calls = 2 のまま）

interface Context {
  path: string
  user?: string
  status?: number
  body?: string
}

type Middleware = (ctx: Context, next: () => Promise<void>) => Promise<void>

// ミドルウェアの配列を、1つの処理につなげる
const compose = (middlewares: Middleware[]) => (ctx: Context): Promise<void> => {
  const dispatch = (i: number): Promise<void> => {
    const mw = middlewares[i]
    return mw ? mw(ctx, () => dispatch(i + 1)) : Promise.resolve()
  }
  return dispatch(0)
}

const logging: Middleware = async (ctx, next) => {
  const start = Date.now()
  await next()
  console.log(`${ctx.path} -> ${ctx.status} (${Date.now() - start}ms)`)
}

const auth: Middleware = async (ctx, next) => {
  if (ctx.path.startsWith('/admin') && !ctx.user) {
    ctx.status = 401
    ctx.body = 'Unauthorized'
    return // next() を呼ばない＝ここで処理を打ち切る
  }
  await next()
}

const handler: Middleware = async (ctx) => {
  ctx.status = 200
  ctx.body = `Hello ${ctx.user ?? 'guest'}`
}

const app = compose([logging, auth, handler])

await app({ path: '/admin/settings' })                 // /admin/settings -> 401
await app({ path: '/admin/settings', user: 'kyosei' }) // /admin/settings -> 200
await app({ path: '/blog' })                           // /blog -> 200