バッチ処理でフェイルファストせずエラーを収集して一括報告するTypeScriptパターン

// ❌ フェイルファスト: 1件のエラーで全部止まる
for (const file of files) {
  const entry = readFile(file);
  if (!isValid(entry)) {
    throw new Error(`${file} に不備があります`); // ← ここで処理終了
  }
  processEntry(entry);
}

// ❌ エラー無視: 問題が検知されない
for (const file of files) {
  try {
    const entry = readFile(file);
    if (!isValid(entry)) continue; // ← エラーがあっても黙ってスキップ
    processEntry(entry);
  } catch {
    // 握りつぶし
  }
}

class BatchProcessor {
  // エラー収集用のMap: キーはファイル名、値はエラーメッセージの配列
  private errorMap: Map<string, string[]> = new Map();
  private entryMap: Map<string, Entry[]> = new Map();

  public async main() {
    await this.processInputFiles();   // ← エラーがあっても続ける
    await this.broadcastErrors();     // ← エラーをまとめて報告
    await this.createOutput();        // ← エラーがなければ出力を作る
    this.clear();
  }

  private addErrorToMap(key: string, errors: string[]): void {
    if (this.errorMap.has(key)) {
      const existing = this.errorMap.get(key)!;
      this.errorMap.set(key, [...existing, ...errors]);
    } else {
      this.errorMap.set(key, [...errors]);
    }
  }
}

private async processInputFiles() {
  const promises = this.files.map(async (file) => {
    try {
      const workbook = await readXlsx(file);
      let rowNumber = 4;

      while (rowNumber <= workbook.rowCount) {
        const row = workbook.getRow(rowNumber);
        const entry = this.parseRow(row);

        // 検証してエラーがあればMapに追記、なければ処理対象に追加
        const isValid = await this.validate(file, entry, rowNumber);
        if (isValid) {
          this.addEntryToMap(file, entry);
        }

        rowNumber++;
      }
    } catch (error) {
      // ファイル単位の致命的なエラーもMapに収集
      Logger.error(`${file} の処理中にエラーが発生しました`);
    }
  });

  await Promise.all(promises); // 複数ファイルを並列処理
}

private async validate(
  fileName: string,
  entry: Entry,
  row: number
): Promise<boolean> {
  // 8種類のチェックを並列実行
  const results = await Promise.all([
    this.requiredCheck(entry, row),     // 必須項目チェック
    this.lengthCheck(entry, row),       // 文字数チェック
    this.dateCheck(entry, row),         // 日付形式チェック
    this.timeCheck(entry, row),         // 時刻形式チェック
    this.phoneCheck(entry, row),        // 電話番号形式チェック
    this.postalCheck(entry, row),       // 郵便番号形式チェック
    this.addressCheck(entry, row),      // 住所チェック
  ]);

  // 各チェックの結果 (string[]) をすべて結合
  const errors = results.flat();

  if (errors.length > 0) {
    this.addErrorToMap(fileName, errors); // Mapに追記
    return false;
  }
  return true;
}

private async requiredCheck(entry: Entry, row: number): Promise<string[]> {
  const errors: string[] = [];
  const requiredFields = ["氏名", "電話番号", "住所", "郵便番号"];

  for (const field of requiredFields) {
    if (!entry[field]) {
      errors.push(`行${row}：${field}が空欄になっています。`);
    }
  }
  return errors;
}

private async broadcastErrors() {
  if (this.errorMap.size === 0) return; // エラーなし → スキップ

  const msg = [
    "ファイルに不備がありましたので修正をお願いします。\n",
  ];

  // ファイルごとにエラーをまとめて通知
  for (const [file, errors] of this.errorMap.entries()) {
    msg.push(`■ファイル名：${file}\n`, "---", ...errors);
  }

  await ChatNotifier.send(msg.join("\n")); // チャットツールに通知
}

private async createOutput(): Promise<void> {
  // エラーがあれば出力は作らない（中途半端な出力を防ぐ）
  if (this.errorMap.size !== 0) return;
  if (this.entryMap.size === 0) return;

  // 全件正常なときだけ出力を生成
  for (const [file, entries] of this.entryMap.entries()) {
    await this.generateOutputFile(file, entries);
  }
}

class SyncMarketData {
  // 各ステップの状態を個別に管理
  private step1 = { error: null as string | null, fileId: "" };
  private step2 = { error: null as string | null, fileId: "" };
  private step3 = { error: null as string | null, fileId: "" };
  private step4 = { error: null as string | null, fileId: "" };

  public async main() {
    try {
      // 4つのデータソースを並列処理
      await Promise.all([
        this.step1_syncShipping(),
        this.step2_syncArrival(),
        this.step3_syncLetterShipping(),
        this.step4_syncLetterArrival(),
      ]);

      await this.broadcastOutput();
    } finally {
      this.clear(); // 成功・失敗問わずキャッシュをクリア
    }
  }

  private async step1_syncShipping() {
    try {
      await this.fetchShippingData();
      await this.generateShippingCsv();
    } catch {
      // step1 のエラーを step1 のプロパティに記録
      // → step2〜4 の処理には影響しない
      this.step1.error = "出荷データ処理中にエラーが発生しました。";
    }
  }

  private async broadcastOutput() {
    const results = [this.step1, this.step2, this.step3, this.step4];
    const errors = results
      .filter((r) => r.error)
      .map((r) => r.error!);

    if (errors.length > 0) {
      await ChatNotifier.send(`エラーが発生しました:\n${errors.join("\n")}`);
    } else {
      await ChatNotifier.send("全ステップ正常完了");
    }
  }
}

private errorMap: Map<string, string[]> = new Map();

private addError(key: string, errors: string[]) {
  const existing = this.errorMap.get(key) ?? [];
  this.errorMap.set(key, [...existing, ...errors]);
}

// ✅ エラーをデータとして返す
async validate(entry: Entry, row: number): Promise<string[]> {
  const errors: string[] = [];
  if (!entry.name) errors.push(`行${row}: 氏名が空です`);
  return errors;
}

private async createOutput() {
  if (this.errorMap.size !== 0) return; // エラーあり → スキップ
  // 全件正常なときだけ出力
}