GASのfetchAllで複数APIを
並列実行して処理を高速化する方法

// 遅い書き方: 1件ずつ順番に待つ
function fetchOneByOne() {
  const urls = [
    "https://example.com/api/1",
    "https://example.com/api/2",
    "https://example.com/api/3",
  ];

  const results = [];
  urls.forEach((url) => {
    const res = UrlFetchApp.fetch(url);   // ここで応答を待ち切ってから次へ
    results.push(res.getContentText());
  });

  return results;   // 1件2秒なら3件で約6秒
}

// 速い書き方: まとめて渡して並列に実行する
function fetchInParallel() {
  const urls = [
    "https://example.com/api/1",
    "https://example.com/api/2",
    "https://example.com/api/3",
  ];

  // fetchAll にはリクエスト設定の配列を渡す
  const requests = urls.map((url) => ({
    url: url,
    method: "get",
    muteHttpExceptions: true,   // 失敗しても例外を投げさせない
  }));

  const responses = UrlFetchApp.fetchAll(requests);   // 3件が同時に走る

  // レスポンスは渡した順番のまま返ってくる
  return responses.map((res) => res.getContentText());
}

// スプレッドシートのA列の問い合わせ文を、AIで一括要約してB列に書き戻す
const API_KEY = PropertiesService.getScriptProperties().getProperty("CLAUDE_API_KEY");
const MODEL = "claude-sonnet-5";

function summarizeAllInParallel() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const lastRow = sheet.getLastRow();
  if (lastRow < 2) return;

  const rows = sheet.getRange(2, 1, lastRow - 1, 1).getValues();

  // 空行を除きつつ、元の行番号を覚えておく
  const targets = [];
  rows.forEach((row, i) => {
    const text = String(row[0]).trim();
    if (text !== "") targets.push({ row: i + 2, text: text });
  });
  if (targets.length === 0) return;

  const requests = targets.map((t) => buildClaudeRequest(t.text));
  const responses = UrlFetchApp.fetchAll(requests);   // ここで一気に投げる

  // レスポンスは requests と同じ順番。インデックスで元の行に対応付ける
  responses.forEach((res, i) => {
    const summary = readSummary(res);
    sheet.getRange(targets[i].row, 2).setValue(summary);
  });
}

function buildClaudeRequest(text) {
  return {
    url: "https://api.anthropic.com/v1/messages",
    method: "post",
    contentType: "application/json",
    headers: {
      "x-api-key": API_KEY,
      "anthropic-version": "2023-06-01",
    },
    payload: JSON.stringify({
      model: MODEL,
      max_tokens: 300,
      messages: [
        { role: "user", content: "次の問い合わせを日本語1文で要約してください。\n\n" + text },
      ],
    }),
    muteHttpExceptions: true,
  };
}

function readSummary(res) {
  const code = res.getResponseCode();
  if (code !== 200) return "エラー(" + code + ")";

  const body = JSON.parse(res.getContentText());
  return body.content[0].text;   // テキストブロックの本文
}

// 成功・失敗を1件ずつ判定し、失敗分だけ後で再実行できるようにする
function fetchWithResultCheck(requests) {
  const responses = UrlFetchApp.fetchAll(requests);

  const succeeded = [];
  const failed = [];

  responses.forEach((res, i) => {
    const code = res.getResponseCode();

    if (code === 200) {
      succeeded.push({ index: i, body: res.getContentText() });
      return;
    }

    // 429（レート超過）と5xx（サーバー側の一時障害）は再試行の価値がある
    const retryable = code === 429 || code >= 500;
    failed.push({ index: i, code: code, retryable: retryable });
    console.warn("失敗 index=" + i + " code=" + code + " body=" + res.getContentText());
  });

  return { succeeded: succeeded, failed: failed };
}

// 失敗したぶんだけ、少し待ってからもう一度まとめて投げる
function fetchWithRetry(requests, maxRetry) {
  let pending = requests.map((req, i) => ({ index: i, request: req }));
  const results = [];

  for (let attempt = 0; attempt <= maxRetry && pending.length > 0; attempt++) {
    if (attempt > 0) Utilities.sleep(2000 * attempt);   // 2秒 → 4秒 と待ちを伸ばす

    const responses = UrlFetchApp.fetchAll(pending.map((p) => p.request));
    const next = [];

    responses.forEach((res, i) => {
      const target = pending[i];
      const code = res.getResponseCode();

      if (code === 200) {
        results.push({ index: target.index, body: res.getContentText() });
      } else if (code === 429 || code >= 500) {
        next.push(target);          // 再試行のキューに戻す
      } else {
        results.push({ index: target.index, body: null });   // 400系は再試行しない
      }
    });

    pending = next;
  }

  return results.sort((a, b) => a.index - b.index);   // 元の順番に戻す
}

// 件数が多いときは、かたまり（チャンク）に分けて呼ぶ
function fetchAllInChunks(requests, chunkSize) {
  const size = chunkSize || 30;   // 実務では20〜50件が扱いやすい
  const all = [];

  for (let i = 0; i < requests.length; i += size) {
    const chunk = requests.slice(i, i + size);
    const responses = UrlFetchApp.fetchAll(chunk);
    responses.forEach((res) => all.push(res));

    console.log((i + chunk.length) + " / " + requests.length + " 件完了");
    Utilities.sleep(500);   // APIのレート制限に配慮して少し間を空ける
  }

  return all;   // 全チャンクの結果を、元の順番のまま連結して返す
}

// 6分に収まらないときは、処理位置を保存して続きから再開する
const PROP_KEY = "FETCH_CURSOR";
const TIME_LIMIT_MS = 4.5 * 60 * 1000;   // 6分の手前で切り上げる

function processWithResume() {
  const started = new Date().getTime();
  const props = PropertiesService.getScriptProperties();
  const sheet = SpreadsheetApp.getActiveSheet();

  let cursor = Number(props.getProperty(PROP_KEY) || 2);   // 2行目から開始
  const lastRow = sheet.getLastRow();

  while (cursor <= lastRow) {
    if (new Date().getTime() - started > TIME_LIMIT_MS) {
      props.setProperty(PROP_KEY, String(cursor));   // 次回の再開位置を保存
      createResumeTrigger();
      return;
    }

    const size = Math.min(30, lastRow - cursor + 1);
    const rows = sheet.getRange(cursor, 1, size, 1).getValues();

    const requests = rows.map((row) => buildClaudeRequest(String(row[0])));
    const responses = UrlFetchApp.fetchAll(requests);
    const out = responses.map((res) => [readSummary(res)]);

    sheet.getRange(cursor, 2, out.length, 1).setValues(out);
    SpreadsheetApp.flush();   // 途中結果を確実にシートへ反映する

    cursor += size;
  }

  props.deleteProperty(PROP_KEY);   // 最後まで終わったらリセット
}

function createResumeTrigger() {
  ScriptApp.newTrigger("processWithResume")
    .timeBased()
    .after(60 * 1000)   // 1分後に続きから再開
    .create();
}