neverthrow と fetch と zod を組み合わせた非同期処理【直列実行と並列実行編】

import { ResultAsync } from "neverthrow";

/**
 * neverthrow の ResultAsync と fetch を組み合わせた関数です。
 */
export const handleFetch = <R, P = unknown>({
  path,
  method = "GET",
  requestParams,
}: {
  path: string;
  method?: "GET" | "POST" | "PUT" | "DELETE";
  requestParams?: P;
}): ResultAsync<R, Error> => {
  const params: RequestInit = {
    method,
  };
  if ((method === "POST" || method === "PUT") && requestParams) {
    params.body = JSON.stringify(requestParams);
  }

  // ok(), err() から ResultAsync.fromPromise() へ移行…(1)
  return ResultAsync.fromPromise(
    // 第一引数: 非同期処理の関数 …(2)
    fetch(`${path}`, params).then((response) => {
      if (!response.ok) {
        throw new Error("サーバーとの通信に失敗しました");
      }

      return response.json().then((data: R) => {
        const isR = isTypeR<R>(data);
        if (!isR) {
          throw new Error("レスポンスの形式が不正です");
        }
        return data;
      });
    }),
    // 第二引数: 第一引数の非同期処理のエラーハンドリング関数 …(3)
    (error) => {
      if (error instanceof Error) {
        if (error.message === "サーバーとの通信に失敗しました") {
          // 通信失敗時の処理
        }
        if (error.message === "レスポンスの形式が不正です") {
          // レスポンスが不正な場合の処理
        }

        return error;
      }
      return new Error("不明なエラーが発生しました");
    }
  );
};

/**
 * fetch の戻り値を推論するための型ガード
 */
const isTypeR = <R>(data: unknown): data is R => {
  return typeof data === "object" && data !== null;
};

import { err, ok } from "neverthrow";
import { z, ZodError } from "zod";
import { handleFetch } from "./neverthrow_fetch";

type Todo = {
  id: number;
  userId: number;
  title: string;
  completed: boolean;
};

const runSeries = (id: number) => {
  ok(z.number().min(1).max(100).safeParse(id))
    .andThen((id) => {
      if (!id.success) return err(id.error);
      return ok(id.data);
    })
    .asyncAndThen((id) => {
      return handleFetch<Todo>({
        path: `https://jsonplaceholder.typicode.com/todos/${id}`,
      });
    })
    .andThen((result) => {
      console.log("id: ", result);

      return handleFetch<Todo>({
        path: `https://jsonplaceholder.typicode.com/todos/${result.id + 10}`,
      });
    })
    .andThen((result) => {
      console.log("id + 10: ", result);

      return handleFetch<Todo>({
        path: `https://jsonplaceholder.typicode.com/todos/${result.id + 20}`,
      });
    })
    .andThen((result) => {
      console.log("id + 20: ", result);

      return handleFetch<Todo>({
        path: `https://jsonplaceholder.typicode.com/todos/${result.id + 30}`,
      });
    })
    .map((result) => {
      console.log("id + 30: ", result);
    })
    .mapErr((error) => {
      if (error instanceof ZodError) {
        console.log("zod エラー", error);
      } else {
        console.log("API エラー", error);
      }
    });
};

runSeries(1);

export class ResultAsync<T, E> implements PromiseLike<Result<T, E>> {
  // …略…

  andThen<R extends Result<unknown, unknown>>(
    f: (t: T) => R,
  ): ResultAsync<InferOkTypes<R>, InferErrTypes<R> | E>
  andThen<R extends ResultAsync<unknown, unknown>>(
    f: (t: T) => R,
  ): ResultAsync<InferAsyncOkTypes<R>, InferAsyncErrTypes<R> | E>
  andThen<U, F>(f: (t: T) => Result<U, F> | ResultAsync<U, F>): ResultAsync<U, E | F>

  // …略…
}

import { err, ok, ResultAsync } from "neverthrow";
import { z, ZodError } from "zod";
import { handleFetch } from "./neverthrow_fetch";

type Todo = {
  id: number;
  userId: number;
  title: string;
  completed: boolean;
};

const runParallel = (ids: number[]) => {
  ok(z.array(z.number().min(1).max(100)).min(1).safeParse(ids))
    .andThen((ids) => {
      if (!ids.success) return err(ids.error);
      return ok(ids.data);
    })
    .asyncAndThen((ids) => {
      const fetches = ids.map((id) => {
        return handleFetch<Todo>({
          path: `https://jsonplaceholder.typicode.com/todos/${id}`,
        });
      });

      return ResultAsync.combine(fetches);
    })
    .map((results) => {
      results.map((todo) => {
        console.log("todo: ", todo);
      });
    })
    .mapErr((error) => {
      if (error instanceof ZodError) {
        console.log("zod エラー", error);
      } else {
        console.log("API エラー", error);
      }
    });
};

runParallel([1, 2, 3, 4]);