POSTにすべきところをGETにしてハマった話

import { NextResponse } from "next/server";
import { buildPrisma } from "@/app/_utils/prisma";
import { dayjs } from "@/app/_utils/dayjs";
import { messagePush } from "./_utils/messagePush";

export const POST = async () => {
  const prisma = await buildPrisma();
  const now = dayjs().tz("Asia/Tokyo");

  const startOfHour = now.startOf("hour").toDate();
  const endOfHour = now.endOf("hour").toDate();

  try {
    const schedules = await prisma.schedule.findMany({
      where: {
        datetime: {
          gte: startOfHour,
          lte: endOfHour,
        },
      },
      include: {
        notification: {
          include: {
            task: {
              include: {
                roomTasks: {
                  include: {
                    room: true,
                    task: true,
                  },
                },
              },
            },
          },
        },
      },
    });

    if (!schedules || schedules.length === 0) {
      return NextResponse.json({ message: "data is null" }, { status: 200 });
    }
    const groupedRoomsTasks = schedules
      .map(schedule =>
        schedule.notification.task.roomTasks.map(roomTask => ({
          lineId: roomTask.room.lineId,
          taskId: roomTask.task.id,
          task: roomTask.task.task,
          date: dayjs(roomTask.task.date).format("YYYY/MM/DD"),
        }))
      )
      .flat()
      .reduce((acc, { lineId, taskId, task, date }) => {
        if (!acc[lineId]) {
          acc[lineId] = { lineId, data: {} };
        }
        if (!acc[lineId].data[taskId]) {
          acc[lineId].data[taskId] = { task, date };
        }
        return acc;
      }, {} as Record<string, { lineId: string; data: Record<string, { task: string; date: string }> }>);

    const result = await messagePush(
      Object.values(groupedRoomsTasks).map(room => ({
        lineId: room.lineId,
        data: Object.values(room.data),
      }))
    );

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

import { fetcher } from "../../_utils/fetcher";
import { RoomsTasks } from "../_types/RoomsTasks";
import { PushResponse, sentMessage } from "../_types/PushResponse";
import { PushRequest } from "../_types/PushRequest";
export const messagePush = async (roomsTasks: RoomsTasks[]) => {
  const resposeMessages: sentMessage[] = [];
  const endpoint = "https://api.line.me/v2/bot/message/push";
  try {
    for (const roomTask of roomsTasks) {
      const text = roomTask.data
        .map(task => `日付:${task.date}\n予定:${task.task}\n`)
        .join("\n");
      const options = {
        method: "POST",
        headers: {
          Authorization: `Bearer ${process.env.CHANNEL_ACCESS_TOKEN}`,
        },
        body: {
          to: roomTask.lineId,
          messages: [
            {
              type: "text",
              text,
            },
          ],
        },
      };
      //1つ失敗しても次のline通知したいのでここでもtry-catchいれとく
      try {
        const resp: PushResponse = await fetcher<PushResponse, PushRequest>(
          endpoint,
          options
        );
        if (resp.sentMessages.length > 0) {
          const { id, quoteToken } = resp.sentMessages[0];
          resposeMessages.push({ id, quoteToken });
        }
      } catch (e) {
        console.error(e);
      }
    }
  } catch (e) {
    console.error(e);
  }
  return resposeMessages;
};