{
  "name": "my-worker",
  "main": "./workers/app.ts",
  "kv_namespaces": [
    {
      "binding": "BLOG_CACHE",
      "id": "your-kv-namespace-id"
    }
  ],
  "triggers": {
    "crons": [
      "0 */12 * * *"
    ]
  }
}

npx wrangler kv namespace create "BLOG_CACHE"

import { updateBlogCache } from "./blogFetcher";

export default {
  // 通常のHTTPリクエストを処理
  async fetch(
    request: Request,
    env: Env,
    ctx: ExecutionContext
  ): Promise<Response> {
    // アプリケーションのリクエストハンドラに渡す
    return handleRequest(request, env, ctx);
  },

  // Cron Triggersによる定期実行
  async scheduled(
    _controller: ScheduledController,
    env: Env,
    ctx: ExecutionContext
  ): Promise<void> {
    ctx.waitUntil(updateBlogCache(env.BLOG_CACHE));
  },
} satisfies ExportedHandler<Env>;

const KV_KEY = "blog_articles";

// Cloudflare Workersのサブリクエスト上限は50回/実行
// 各ソースの取得ページ数を制限して上限を超えないようにする
const MAX_PAGES_QIITA = 5;
const MAX_PAGES_ZENN = 5;
// DevelopersIOはRSSのページネーションが効かないため1ページのみ
const MAX_PAGES_DEVIO = 1;

export interface Article {
  id: number;
  title: string;
  date: string;
  excerpt: string;
  tags: string[];
  url: string;
  source: string;
  likes_count?: number;
  page_views_count?: number;
  comments_count?: number;
}

export const fetchAllArticles = async (): Promise<Article[]> => {
  const results = await Promise.allSettled([
    fetchQiitaArticles(),
    fetchZennArticles(),
    fetchDevelopersIOArticles(),
    fetchTortoiseTechBlogArticles(),
  ]);

  const articles: Article[] = [];

  for (const result of results) {
    if (result.status === "fulfilled") {
      articles.push(...result.value);
    } else {
      // 失敗したソースはログに記録して続行
      console.error("Failed to fetch articles:", result.reason);
    }
  }

  // URLベースで重複を除去して日付降順でソート
  const seen = new Set<string>();
  const unique = articles.filter((a) => {
    if (seen.has(a.url)) return false;
    seen.add(a.url);
    return true;
  });

  unique.sort(
    (a, b) => new Date(b.date).getTime() - new Date(a.date).getTime()
  );

  // マージ・ソート後に連番IDを振る
  unique.forEach((article, index) => {
    article.id = index + 1;
  });

  return unique;
};

const fetchQiitaArticles = async (): Promise<Article[]> => {
  const allData: QiitaArticle[] = [];
  let page = 1;
  const perPage = 100;

  while (page <= MAX_PAGES_QIITA) {
    const response = await fetch(
      `https://qiita.com/api/v2/users/{username}/items?page=${page}&per_page=${perPage}`
    );

    if (!response.ok) {
      throw new Error(`Qiita API returned status: ${response.status}`);
    }

    const data = (await response.json()) as QiitaArticle[];

    if (!data || data.length === 0) break;
    allData.push(...data);

    // 取得件数がper_page未満なら最後のページ
    if (data.length < perPage) break;
    page++;
  }

  return allData.map((item, index) => ({
    id: index,
    title: item.title,
    date: item.created_at.split("T")[0],
    url: item.url,
    source: "Qiita",
    tags: item.tags.map((tag) => tag.name),
  }));
};

/**
 * Fetch articles and store them in KV.
 */
export const updateBlogCache = async (kv: KVNamespace): Promise<void> => {
  console.log("Updating blog cache...");
  const articles = await fetchAllArticles();

  if (articles.length > 0) {
    await kv.put(KV_KEY, JSON.stringify(articles));
    console.log(`Blog cache updated: ${articles.length} articles stored`);
  } else {
    // 全ソースが失敗した場合は既存キャッシュを維持
    console.warn("No articles fetched, skipping KV update");
  }
};

/**
 * Get cached articles from KV.
 * Returns empty array if KV is empty.
 */
export const getCachedArticles = async (
  kv: KVNamespace
): Promise<Article[]> => {
  const cached = await kv.get(KV_KEY);

  if (cached) {
    return JSON.parse(cached) as Article[];
  }

  // KVが空の場合はログを出して空配列を返す
  // 次回のCron Triggerで自動的にKVにデータが保存される
  console.warn("KV cache is empty. Waiting for next scheduled update.");
  return [];
};

export async function loader({ context }: Route.LoaderArgs) {
  try {
    const articles = await getCachedArticles(
      context.cloudflare.env.BLOG_CACHE
    );
    return { articles, error: null };
  } catch (err) {
    console.error("Failed to load blog articles:", err);
    return { articles: [], error: "記事の取得中にエラーが発生しました。" };
  }
}

// 4ソース合計で上限を超えないようにページ数を制限
const MAX_PAGES_QIITA = 5;   // 最大5リクエスト
const MAX_PAGES_ZENN = 5;    // 最大5リクエスト
const MAX_PAGES_DEVIO = 1;   // 1リクエスト
// tortoise-tech-blog: 1リクエスト
// 合計: 最大12リクエスト（50回の上限内に収まる）