@k2works/claude-code-booster 6.1.0 → 6.3.0

package/lib/assets/docs/article/getting-start-tdd/node/09-solid-principles-and-module-design.md

@@ -1,294 +0,0 @@
----
-type: Article
-title: "第 9 章: SOLID 原則とモジュール設計"
-description: "前章までに多くのデザインパターンを適用しましたが、すべてのクラスが 1 つのファイルに詰め込まれた状態です。"
-tags: [article, getting-start-tdd, node]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 9 章: SOLID 原則とモジュール設計
-
-## 9.1 はじめに
-
-前章までに多くのデザインパターンを適用しましたが、すべてのクラスが 1 つのファイルに詰め込まれた状態です。この章では **SOLID 原則** の観点からコードを検証し、責務に基づいた **モジュール設計** を行います。
-
-## 9.2 SOLID 原則の検証
-
-### 単一責任原則（SRP: Single Responsibility Principle）
-
-> クラスが変更される理由は一つでなければならない
-
-| クラス | 責務 | 変更理由 |
-|--------|------|---------|
-| `FizzBuzzValue` | FizzBuzz の結果値を表現 | 値の表現方法が変わるとき |
-| `FizzBuzzList` | FizzBuzz の結果コレクションを管理 | コレクション操作が変わるとき |
-| `FizzBuzzType01` | タイプ 1 の変換ルール | タイプ 1 のルールが変わるとき |
-| `FizzBuzzType02` | タイプ 2 の変換ルール | タイプ 2 のルールが変わるとき |
-| `FizzBuzzType03` | タイプ 3 の変換ルール | タイプ 3 のルールが変わるとき |
-| `FizzBuzzValueCommand` | 単一値の生成操作 | 値の生成方法が変わるとき |
-| `FizzBuzzListCommand` | リストの生成操作 | リストの生成方法が変わるとき |
-
-各クラスが 1 つの責務を持ち、変更理由は 1 つです。SRP を満たしています。
-
-### 開放閉鎖原則（OCP: Open-Closed Principle）
-
-> ソフトウェアエンティティは拡張に対して開いていて、修正に対して閉じている
-
-新しいタイプ（例: タイプ 4）を追加する場合:
-
-1. `FizzBuzzType04` クラスを **新規作成** する
-2. `FizzBuzzType.create()` の switch 文に 1 行 **追加** する
-
-既存の `FizzBuzzType01`〜`03` は一切変更しません。OCP を満たしています。
-
-### 依存関係逆転の原則（DIP: Dependency Inversion Principle）
-
-> 上位レベルのモジュールは下位レベルのモジュールに依存してはならない。両方とも抽象に依存すべき
-
-```
-FizzBuzzValueCommand ──→ FizzBuzzType (抽象)
-FizzBuzzListCommand  ──→ FizzBuzzType (抽象)
-                              ↑
-                    FizzBuzzType01, Type02, Type03
-```
-
-- コマンド（上位）は抽象クラス `FizzBuzzType` に依存
-- 具体的な Type01〜03 には直接依存しない
-- DIP を満たしています
-
-## 9.3 モジュール設計
-
-### 設計方針
-
-責務に基づいて 3 つのレイヤーに分割します。
-
-| レイヤー | 配置先 | 責務 |
-|---------|-------|------|
-| **ドメインモデル** | `domain/model/` | 値オブジェクト、コレクション |
-| **ドメインタイプ** | `domain/type/` | ビジネスルール（FizzBuzz 変換） |
-| **アプリケーション** | `application/` | 操作の実行（コマンド） |
-
-### ディレクトリ構成
-
-```
-src/
-├── index.ts                          (エントリポイント)
-└── fizzbuzz/
-    ├── index.ts                      (バレルファイル: 全クラスを re-export)
-    ├── domain/
-    │   ├── model/
-    │   │   ├── fizz-buzz-value.ts    (FizzBuzzValue)
-    │   │   └── fizz-buzz-list.ts     (FizzBuzzList)
-    │   └── type/
-    │       ├── fizz-buzz-type.ts     (FizzBuzzType abstract + create)
-    │       ├── fizz-buzz-type-01.ts  (FizzBuzzType01)
-    │       ├── fizz-buzz-type-02.ts  (FizzBuzzType02)
-    │       └── fizz-buzz-type-03.ts  (FizzBuzzType03)
-    └── application/
-        ├── fizz-buzz-command.ts      (FizzBuzzCommand interface)
-        ├── fizz-buzz-value-command.ts (FizzBuzzValueCommand)
-        └── fizz-buzz-list-command.ts  (FizzBuzzListCommand)
-```
-
-### 依存関係
-
-```
-application/ ──→ domain/type/ ──→ domain/model/
-     ↓                ↓                 ↓
-  コマンド          タイプ            値・コレクション
-```
-
-- `domain/model/` は他のモジュールに依存しない（最も安定）
-- `domain/type/` は `domain/model/` のみに依存
-- `application/` は `domain/type/` と `domain/model/` に依存
-
-### バレルファイル（index.ts）
-
-TypeScript では **バレルファイル** を使って、モジュールの公開 API を集約します。
-
-```typescript
-// src/fizzbuzz/index.ts
-export { FizzBuzzValue } from "./domain/model/fizz-buzz-value.js";
-export { FizzBuzzList } from "./domain/model/fizz-buzz-list.js";
-export { FizzBuzzType } from "./domain/type/fizz-buzz-type.js";
-export { FizzBuzzType01 } from "./domain/type/fizz-buzz-type-01.js";
-export { FizzBuzzType02 } from "./domain/type/fizz-buzz-type-02.js";
-export { FizzBuzzType03 } from "./domain/type/fizz-buzz-type-03.js";
-export type { FizzBuzzCommand } from "./application/fizz-buzz-command.js";
-export { FizzBuzzValueCommand } from "./application/fizz-buzz-value-command.js";
-export { FizzBuzzListCommand } from "./application/fizz-buzz-list-command.js";
-```
-
-利用側は 1 つの import パスですべてのクラスにアクセスできます:
-
-```typescript
-import {
-  FizzBuzzType,
-  FizzBuzzValueCommand,
-  FizzBuzzListCommand,
-} from "./fizzbuzz/index";
-```
-
-## 9.4 エントリポイントの更新
-
-```typescript
-// src/index.ts
-export {
-  FizzBuzzValue,
-  FizzBuzzList,
-  FizzBuzzType,
-  FizzBuzzType01,
-  FizzBuzzType02,
-  FizzBuzzType03,
-  FizzBuzzValueCommand,
-  FizzBuzzListCommand,
-} from "./fizzbuzz/index.js";
-```
-
-## 9.5 テストの再編成
-
-テストもモジュール構造に合わせて分割します。
-
-```
-test/
-└── fizzbuzz/
-    ├── domain/
-    │   ├── model/
-    │   │   ├── fizz-buzz-value.test.ts
-    │   │   └── fizz-buzz-list.test.ts
-    │   └── type/
-    │       └── fizz-buzz-type.test.ts
-    └── application/
-        └── fizz-buzz-command.test.ts
-```
-
-### fizz-buzz-type.test.ts
-
-```typescript
-import { describe, expect, test } from "vitest";
-import {
-  FizzBuzzType,
-  FizzBuzzType01,
-  FizzBuzzType02,
-  FizzBuzzType03,
-} from "../../../../src/fizzbuzz/index";
-
-describe("FizzBuzzType", () => {
-  describe("タイプ1の場合", () => {
-    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
-
-    test("1を渡したら文字列1を返す", () => {
-      expect(type.generate(1).toString()).toBe("1");
-    });
-
-    test("3を渡したらFizzを返す", () => {
-      expect(type.generate(3).toString()).toBe("Fizz");
-    });
-
-    test("5を渡したらBuzzを返す", () => {
-      expect(type.generate(5).toString()).toBe("Buzz");
-    });
-
-    test("15を渡したらFizzBuzzを返す", () => {
-      expect(type.generate(15).toString()).toBe("FizzBuzz");
-    });
-  });
-
-  describe("ファクトリメソッド", () => {
-    test("TYPE_01 を指定すると FizzBuzzType01 が返る", () => {
-      expect(FizzBuzzType.create(FizzBuzzType.TYPE_01)).toBeInstanceOf(
-        FizzBuzzType01,
-      );
-    });
-
-    test("未定義のタイプを指定するとエラーが発生する", () => {
-      expect(() => FizzBuzzType.create(99)).toThrow("未定義のタイプ: 99");
-    });
-  });
-});
-```
-
-### fizz-buzz-command.test.ts
-
-```typescript
-import { describe, expect, test } from "vitest";
-import {
-  FizzBuzzListCommand,
-  FizzBuzzType,
-  FizzBuzzValueCommand,
-} from "../../../src/fizzbuzz/index";
-
-describe("FizzBuzzCommand", () => {
-  test("FizzBuzzValueCommand は単一の値を生成する", () => {
-    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
-    const command = new FizzBuzzValueCommand(type, 3);
-    const result = command.execute();
-    expect(result.toString()).toBe("Fizz");
-  });
-
-  test("FizzBuzzListCommand はリストを生成する", () => {
-    const type = FizzBuzzType.create(FizzBuzzType.TYPE_01);
-    const command = new FizzBuzzListCommand(type, 100);
-    const result = command.execute();
-    expect(result.size).toBe(100);
-  });
-});
-```
-
-### テスト実行結果
-
-```
- ✓ test/fizzbuzz/domain/model/fizz-buzz-value.test.ts (4 tests) 2ms
- ✓ test/fizzbuzz/domain/model/fizz-buzz-list.test.ts (4 tests) 2ms
- ✓ test/fizzbuzz/domain/type/fizz-buzz-type.test.ts (16 tests) 1ms
- ✓ test/fizzbuzz/application/fizz-buzz-command.test.ts (3 tests) 2ms
-
- Test Files  4 passed (4)
-      Tests  27 passed (27)
-```
-
-## 9.6 各言語のモジュール設計比較
-
-| 概念 | TypeScript | Java | Python |
-|------|-----------|------|--------|
-| モジュール単位 | ファイル（ES Modules） | パッケージ | パッケージ |
-| 公開制御 | `export` / non-export | `public` / package-private | `__all__` / `_` 規約 |
-| バレルファイル | `index.ts` の re-export | パッケージの public class | `__init__.py` |
-| 名前空間 | ファイルパス | パッケージ名 | モジュールパス |
-| 循環依存対策 | バレルファイルで集約 | パッケージ設計で制御 | `__init__.py` で制御 |
-
-## 9.7 まとめ
-
-第 3 部（章 7〜9）を通じて、手続き的な FizzBuzz を OOP 設計に進化させました。
-
-| 章 | テーマ | 適用したパターン |
-|---|--------|---------------|
-| 7 | カプセル化とポリモーフィズム | Strategy パターン、ファクトリメソッド |
-| 8 | デザインパターンの適用 | Value Object、First-Class Collection、Command パターン |
-| 9 | SOLID 原則とモジュール設計 | SRP、OCP、DIP、モジュール分割 |
-
-### Before / After
-
-**Before**（第 2 部終了時）:
-
-```
-src/fizzbuzz.ts (1 ファイル、1 クラス)
-test/fizzbuzz.test.ts (1 ファイル)
-```
-
-**After**（第 3 部終了時）:
-
-```
-src/fizzbuzz/
-├── domain/model/    (値オブジェクト、コレクション)
-├── domain/type/     (ビジネスルール)
-└── application/     (コマンド)
-
-test/fizzbuzz/
-├── domain/model/    (値・コレクションのテスト)
-├── domain/type/     (タイプのテスト)
-└── application/     (コマンドのテスト)
-```
-
-次の第 4 部では、関数型プログラミングの観点から FizzBuzz を再構成し、高階関数、不変データ、型安全なエラーハンドリングを学びます。

package/lib/assets/docs/article/getting-start-tdd/node/10-higher-order-functions-and-composition.md

@@ -1,208 +0,0 @@
----
-type: Article
-title: "第 10 章: 高階関数と関数合成"
-description: "第 3 部ではオブジェクト指向設計でコードを構造化しました。"
-tags: [article, getting-start-tdd, node]
-status: stable
-generated: { by: human:kakimomokuri, at: 2026-03-24T05:22:28Z }
----
-
-# 第 10 章: 高階関数と関数合成
-
-## 10.1 はじめに
-
-第 3 部ではオブジェクト指向設計でコードを構造化しました。第 4 部では **関数型プログラミング** の観点から FizzBuzz を再構成し、JavaScript/TypeScript の関数型機能を学びます。
-
-この章では、**高階関数**（Higher-Order Functions）と **関数合成**（Function Composition）を使って、コレクション操作をより宣言的に記述します。
-
-## 10.2 アロー関数と高階関数
-
-### アロー関数
-
-TypeScript/JavaScript のアロー関数は、関数型プログラミングの基本です。
-
-```typescript
-// 従来の関数
-function double(n: number): number {
-  return n * 2;
-}
-
-// アロー関数
-const double = (n: number): number => n * 2;
-```
-
-### 高階関数とは
-
-**高階関数** とは、関数を引数に取るか、関数を返す関数です。JavaScript の配列メソッド `map`、`filter`、`reduce` は代表的な高階関数です。
-
-## 10.3 FizzBuzzList への関数型メソッドの追加
-
-### map: 各要素を変換
-
-```typescript
-map(fn: (value: FizzBuzzValue) => FizzBuzzValue): FizzBuzzList {
-  return new FizzBuzzList(this._list.map(fn));
-}
-```
-
-**特徴**: 元のリストを変更せず、新しいリストを返します（不変性）。
-
-### filter: 条件に合う要素のみ抽出
-
-```typescript
-filter(predicate: (value: FizzBuzzValue) => boolean): FizzBuzzList {
-  return new FizzBuzzList(this._list.filter(predicate));
-}
-```
-
-### reduce: 畳み込み
-
-```typescript
-reduce<T>(fn: (acc: T, value: FizzBuzzValue) => T, initial: T): T {
-  return this._list.reduce(fn, initial);
-}
-```
-
-### テスト
-
-```typescript
-describe("関数型メソッド", () => {
-  const baseList = new FizzBuzzList([
-    new FizzBuzzValue("1", 1),
-    new FizzBuzzValue("Fizz", 3),
-    new FizzBuzzValue("Buzz", 5),
-    new FizzBuzzValue("FizzBuzz", 15),
-  ]);
-
-  test("map で値を変換する", () => {
-    const mapped = baseList.map(
-      (v) => new FizzBuzzValue(v.toString().toUpperCase(), v.number),
-    );
-    expect(mapped.toStringArray()).toEqual(["1", "FIZZ", "BUZZ", "FIZZBUZZ"]);
-    // 元のリストは変更されない
-    expect(baseList.toStringArray()).toEqual(["1", "Fizz", "Buzz", "FizzBuzz"]);
-  });
-
-  test("filter で Fizz のみ抽出できる", () => {
-    const filtered = baseList.filter((v) => v.value === "Fizz");
-    expect(filtered.toStringArray()).toEqual(["Fizz"]);
-  });
-
-  test("reduce で文字列結合できる", () => {
-    const reduced = baseList.reduce(
-      (acc, v) => `${acc}${acc.length > 0 ? "," : ""}${v.toString()}`,
-      "",
-    );
-    expect(reduced).toBe("1,Fizz,Buzz,FizzBuzz");
-  });
-});
-```
-
-## 10.4 FizzBuzzListCommand の関数的リファクタリング
-
-### Before: for ループ
-
-```typescript
-execute(): FizzBuzzList {
-  let list = new FizzBuzzList();
-  for (let i = 1; i <= this._count; i++) {
-    list = list.add(this._type.generate(i));
-  }
-  return list;
-}
-```
-
-### After: Array.from + reduce
-
-```typescript
-execute(): FizzBuzzList {
-  return Array.from({ length: this._count }, (_, i) => i + 1).reduce(
-    (list, num) => list.add(this._type.generate(num)),
-    new FizzBuzzList(),
-  );
-}
-```
-
-**変更点**:
-
-- `for` ループを `Array.from` + `reduce` に置き換え
-- 宣言的な記述に変更（「何を」するかが明確）
-- 既存のテストはすべてそのまま通過
-
-## 10.5 関数合成ユーティリティ
-
-### compose と pipe
-
-```typescript
-// compose: 右から左に合成 f(g(x))
-export const compose =
-  <T>(...fns: ((arg: T) => T)[]): ((arg: T) => T) =>
-  (arg: T) =>
-    fns.reduceRight((acc, fn) => fn(acc), arg);
-
-// pipe: 左から右に合成 g(f(x))
-export const pipe =
-  <T>(...fns: ((arg: T) => T)[]): ((arg: T) => T) =>
-  (arg: T) =>
-    fns.reduce((acc, fn) => fn(acc), arg);
-```
-
-### フィルタ述語関数
-
-カリー化されたフィルタ関数で、再利用可能な述語を定義します。
-
-```typescript
-export const isFizz = (v: FizzBuzzValue): boolean => v.value === "Fizz";
-export const isBuzz = (v: FizzBuzzValue): boolean => v.value === "Buzz";
-export const isFizzBuzz = (v: FizzBuzzValue): boolean => v.value === "FizzBuzz";
-export const isNumber = (v: FizzBuzzValue): boolean => !isNaN(Number(v.value));
-```
-
-### テスト
-
-```typescript
-describe("関数合成", () => {
-  test("compose は右から左に適用する", () => {
-    const double = (n: number): number => n * 2;
-    const increment = (n: number): number => n + 1;
-    const fn = compose(double, increment);
-    expect(fn(3)).toBe(8); // double(increment(3)) = double(4) = 8
-  });
-
-  test("pipe は左から右に適用する", () => {
-    const double = (n: number): number => n * 2;
-    const increment = (n: number): number => n + 1;
-    const fn = pipe(double, increment);
-    expect(fn(3)).toBe(7); // increment(double(3)) = increment(6) = 7
-  });
-});
-
-describe("フィルタ関数", () => {
-  test("isFizz は Fizz のとき true を返す", () => {
-    expect(isFizz(new FizzBuzzValue("Fizz", 3))).toBe(true);
-    expect(isFizz(new FizzBuzzValue("Buzz", 5))).toBe(false);
-  });
-});
-```
-
-## 10.6 各言語の高階関数比較
-
-| 概念 | TypeScript | Java | Python |
-|------|-----------|------|--------|
-| ラムダ式 | `(x) => x * 2` | `x -> x * 2` | `lambda x: x * 2` |
-| map | `array.map(fn)` | `stream.map(fn)` | `map(fn, list)` / 内包表記 |
-| filter | `array.filter(fn)` | `stream.filter(fn)` | `filter(fn, list)` / 内包表記 |
-| reduce | `array.reduce(fn, init)` | `stream.reduce(init, fn)` | `functools.reduce(fn, list, init)` |
-| 関数合成 | `compose(f, g)` / `pipe(f, g)` | `f.andThen(g)` / `f.compose(g)` | `functools.reduce` で実装 |
-| 述語関数 | `const isFizz = (v) => ...` | `Predicate<T>` インターフェース | `def is_fizz(v): ...` |
-
-## 10.7 まとめ
-
-この章で学んだこと:
-
-1. **アロー関数**: 簡潔な関数リテラルで高階関数を活用
-2. **map/filter/reduce**: コレクションの宣言的操作
-3. **関数合成**: `compose`（右→左）と `pipe`（左→右）で関数を組み合わせ
-4. **述語関数**: 再利用可能なフィルタ条件を関数として定義
-
-次の章では、不変データの原則をさらに深め、パイプライン処理でデータを変換するパターンを学びます。