PokéAPIで取得したポケモン名(合言葉)を取得してDB保存するまで

import { NextRequest, NextResponse } from "next/server";
import { WebhookRequest } from "./_types/WebhookRequest";
import { buildPrisma } from "@/app/_utils/prisma";

import { pokeApi } from "./_utils/pokeApi";
import { randomBytes } from "crypto";
export const POST = async (req: NextRequest) => {
  const prisma = await buildPrisma();

  try {
    const body: WebhookRequest = await req.json();
    const events = body.events;

    const joinEvent = events.find(event => event.type === "join");

    if (!joinEvent)
      return NextResponse.json(
        {
          message: "参加イベントじゃない",
        },
        { status: 204 }
      );

    const { groupId, roomId, userId } = joinEvent.source;
    const lineId = groupId || roomId || userId;
    if (!lineId) throw new Error("IDの取得が出来ませんでした");
    //合言葉の生成をする
    const pokeName = await pokeApi();

    //URLの生成
    const buffer = randomBytes(16);
    const roomUrlId = buffer.toString("hex");

    const roomData = await prisma.room.create({
      data: {
        adminUserId: process.env.ADMIN_USER as string,
        lineId,
        roomUrlId,
        password: pokeName,
      },
    });

    return NextResponse.json(
      {
        message: "success",
      },
      { status: 200 }
    );
  } catch (e) {
    if (e instanceof Error) {
      console.log(e.message);
      return NextResponse.json({ error: e.message }, { status: 400 });
    }
  }
};

import { fetcher } from "../../_utils/fetcher";
import { PokemonResponse } from "../_types/PokemonResponse";
export const pokeApi = async () => {
  //10回以内に名前取得に成功しないとエラーをスローする
  let count = 0;
  const MAX_TRY = 10;

  while (count < MAX_TRY) {
    //1-1025の数字生成する
    const id = Math.floor(Math.random() * 1025) + 1;
    const endpoint = `https://pokeapi.co/api/v2/pokemon-species/${id}`;

    try {
      const resp = await fetcher<PokemonResponse>(endpoint);
      const name = resp.names.find(item => item.language.name === "ja-Hrkt");

      if (name) {
        return name.name;
      }
    } catch (error) {
      console.error(`Error fetching data for ID ${id}:`, error);
    } finally {
      count++;
    }
  }
  throw new Error("合言葉の生成に失敗しました");
};

export interface PokemonResponse {
  base_happiness: number;
  capture_rate: number;
  color: Color;
  egg_groups: EggGroup[];
  evolution_chain: EvolutionChain;
  evolves_from_species: null | Species;
  flavor_text_entries: FlavorTextEntry[];
  forms_switchable: boolean;
  gender_rate: number;
  genera: Genus[];
  generation: Generation;
  growth_rate: GrowthRate;
  habitat: Habitat;
  has_gender_differences: boolean;
  hatch_counter: number;
  id: number;
  is_baby: boolean;
  is_legendary: boolean;
  is_mythical: boolean;
  name: string;
  names: Name[];
}

interface Color {
  name: string;
  url: string;
}

interface EggGroup {
  name: string;
  url: string;
}

interface EvolutionChain {
  url: string;
}

interface Species {
  name: string;
  url: string;
}

interface FlavorTextEntry {
  flavor_text: string;
  language: Language;
  version: Version;
}

interface Language {
  name: string;
  url: string;
}

interface Version {
  name: string;
  url: string;
}

interface Genus {
  genus: string;
  language: Language;
}

interface Generation {
  name: string;
  url: string;
}

interface GrowthRate {
  name: string;
  url: string;
}

interface Habitat {
  name: string;
  url: string;
}

interface Name {
  language: Language;
  name: string;
}

type FetcherOptions<RequestType> = {
  method?: string;
  headers?: Record<string, string>;
  body?: RequestType;
};

export const fetcher = async <ResponseType, RequestType = undefined>(
  url: string,
  options: FetcherOptions<RequestType> = {}
): Promise<ResponseType> => {
  const { method = "GET", headers = {}, body } = options;

  try {
    const response = await fetch(url, {
      method,
      headers: {
        "Content-Type": "application/json",
        ...headers,
      },
      body: body ? JSON.stringify(body) : undefined,
    });

    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }

    const data: ResponseType = await response.json();
    return data;
  } catch (error) {
    console.error(error);
    throw error;
  }
};