Next.jsで学ぶReact講座 90日コース | Next.jsでCRUDアプリ開発 - Day 54:データ作成

React Next.jsで学ぶReact講座90日コース
スポンサーリンク
スポンサーリンク
  1. Day 54:データ作成 ― POST APIで受け取ったデータをデータベースへ保存する
  2. 今日のゴール
  3. 完成後の動きを確認する
  4. POST APIとは何か
    1. 今回送信するデータ
    2. 保存に成功した場合のレスポンス
  5. HTTPステータスコードを先に決める
  6. Day 53の環境を確認する
    1. Userモデルの確認例
  7. 今回作成・変更するファイル
  8. 登録データの型を定義する
    1. src/types/user.ts
  9. サーバー側の入力検証を作る
    1. src/lib/validation/user.ts
    2. なぜ余分な項目を受け付けないのか
    3. メール形式の確認には限界があります
  10. Prismaでデータを作成するサービスを作る
    1. src/services/user.service.ts
    2. サービスはHTTPを知らなくてもよい形にする
  11. POST APIを実装する
    1. src/app/api/users/route.ts
    2. なぜJSONの読み取りとDB処理を分けたのか
    3. P2002とは何か
    4. 先に重複検索すれば十分なのか
  12. まずはAPI単体で確認する
    1. 同じリクエストをもう一度送る
    2. ブラウザーでURLを開くだけではPOSTにならない
  13. 登録フォームを作る
    1. src/components/UserCreateForm.tsx
    2. response.okを確認する理由
    3. エラー時に入力値を消さない理由
    4. 通信失敗は「保存されていない」とは限らない
  14. フォームとユーザー一覧を同じページへ配置する
    1. src/app/users/page.tsx
    2. ページ全体をClient Componentにしない
    3. router.refresh()はDBへ保存する命令ではない
  15. 正常系と異常系をテストする
    1. ブラウザーの入力制限だけで満足しない
    2. 再起動してもデータが残るか確認する
  16. error.tsxだけでは送信エラーを扱えない理由
  17. 公開前に追加しなければならない対策
    1. 文字数制限と本文サイズ制限は別です
    2. 重複の案内が情報公開につながる場合もある
    3. 二重送信防止は画面だけで完成しない
  18. よくあるつまずきと確認方法
  19. 自力で取り組む練習問題
    1. 名前の文字数ルールを変更する
    2. 任意のプロフィール欄を追加する
    3. 成功時に作成したユーザー名を表示する
  20. 本番ビルドで確認する
  21. Day 54のチェックリスト
  22. まとめ

Day 54:データ作成 ― POST APIで受け取ったデータをデータベースへ保存する

Day 54では、Next.jsのRoute HandlersとPrismaを組み合わせて、ユーザーを作成するPOST APIを実装します。Day 53ではデータベースから情報を読み取りました。今回は反対に、ブラウザーから送った情報を受け取り、データベースへ保存します。

学習の中心は、「受け取る」「検証する」「保存する」「結果を返す」という流れです。正常に保存できる場合だけでなく、入力不足、メールアドレスの重複、通信失敗も区別して扱います。

今日のゴール

今回作るのは、名前とメールアドレスを登録するAPIと、そのAPIを呼び出すフォームです。

項目今回実装するもの
APIPOST /api/users
受け取るデータ名前とメールアドレス
保存先Day 53で用意したSQLite
データ操作Prisma Clientのcreate()
入力確認型、必須項目、文字数、簡単な形式チェック
重複確認DBの一意制約違反を処理
画面登録フォームとユーザー一覧
保存後成功メッセージと一覧の再取得

今回はログイン機能のない、ローカル学習専用の実装です。 誤ってそのまま公開しないよう、APIは開発環境でのみ登録できる構成にします。

完成後の動きを確認する

完成すると、次の流れでデータが保存されます。

利用者がフォームへ入力する
    ↓
Client ComponentからPOSTリクエストを送る
    ↓
Route HandlerがJSONを読み取る
    ↓
サーバー側で入力を検証する
    ↓
サービスからPrismaを呼び出す
    ↓
SQLiteへユーザーを登録する
    ↓
APIが201を返す
    ↓
フォームに成功を表示する
    ↓
ユーザー一覧を再取得する

この中で、ブラウザーが直接データベースへ接続することはありません。今回は、サーバー側のRoute HandlerとサービスがDB操作を担当します。

Next.jsでは、app内のroute.tsにHTTPメソッド名の関数をexportすることで、APIの入口を定義できます。(🔗 nextjs.org)

POST APIとは何か

POSTは、サーバーへデータを送信して処理を依頼するときに使うHTTPメソッドです。今回は、新しいユーザーの作成に使います。

今回送信するデータ

{
  "name": "結衣",
  "email": "yui@example.com"
}
JSON

JSONにはコメントを書けないため、この形式例にはコメントを入れていません。

送信する値の役割は、次のとおりです。

  • nameは、登録するユーザーの名前です。
  • emailは、登録するメールアドレスです。
  • idは送信せず、データベース側の自動採番を使います。
  • createdAtも送信せず、モデルの既定値を使います。

保存に成功した場合のレスポンス

{
  "message": "ユーザーを登録しました。",
  "user": {
    "id": 3,
    "name": "結衣"
  }
}
JSON

実際のIDは、既存データや過去の操作によって変わります。

今回は画面で必要なIDと名前だけを返し、メールアドレスは返さない設計にします。

HTTPステータスコードを先に決める

コードを書く前に、成功と失敗の分類を決めます。

ステータス今回の意味例
201作成成功ユーザーを登録できました
400JSONを読み取れませんJSONの構文が壊れています
403今回のAPIでは実行を許可しません開発環境以外からの登録です
409現在のデータと競合しますメールアドレスが重複しています
415送信形式が対象外ですJSON以外の形式です
422データの内容が条件を満たしません名前が空です
500サーバー側の予期しない失敗ですDB操作に失敗しました

今回は、この表をAPIの契約として使います。入力の内容やContent-Typeを確認し、内部エラーの詳細をそのまま返さない設計は、APIの基本的な安全対策です。(🔗 cheatsheetseries.owasp.org)

400と422の使い分けは、今回の設計方針です。重要なのは、同じAPIの中で分類を統一し、呼び出し側が扱えるようにすることです。

Day 53の環境を確認する

今回の実装は、Day 53で次の状態になっていることを前提にします。

  • PrismaからSQLiteへ接続できます。
  • src/lib/prisma.tsでPrisma Clientを共有しています。
  • 生成先はsrc/generated/prismaです。
  • Userモデルにnameとemailがあります。
  • emailへ@uniqueを設定しています。
  • /usersでユーザー一覧を表示できます。

Prisma関連のパッケージは、Day 53で動作確認できた組み合わせを引き継ぎます。今回は新しい機能のためだけに、Prismaのバージョンを変更しません。

Userモデルの確認例

既存のモデルを確認するための例です。すでにbioなどを追加している場合、削除する必要はありません。

// 今回使用するユーザーモデルの基本形です
model User {
  id        Int      @id @default(autoincrement())
  name      String
  email     String   @unique
  createdAt DateTime @default(now()) @map("created_at")

  @@map("users")
}
Prisma

モデルがすでにこの要件を満たしていれば、今回のためのMigrationは不要です。

ただし、スキーマを変更した場合は、DBへの反映とクライアント生成を行います。

# スキーマを変更した場合だけ、変更内容に応じて実行します
npx prisma migrate dev --name prepare_user_creation

# 生成クライアントを更新します
npx prisma generate
Bash

今回作成・変更するファイル

src/
├── app/
│   ├── api/
│   │   └── users/
│   │       └── route.ts
│   └── users/
│       └── page.tsx
├── components/
│   └── UserCreateForm.tsx
├── generated/
│   └── prisma/
├── lib/
│   ├── prisma.ts
│   └── validation/
│       └── user.ts
├── services/
│   └── user.service.ts
└── types/
    └── user.ts

src/lib/prisma.tsはDay 53のものを引き継ぎます。

今回の責務は、次のように分けます。

ファイル担当すること
types/user.ts登録データの型
lib/validation/user.ts受信データの検証
services/user.service.tsDBからの取得と作成
app/api/users/route.tsHTTPリクエストとレスポンス
components/UserCreateForm.tsx入力と送信状態の管理
app/users/page.tsxフォームと一覧の組み立て

登録データの型を定義する

最初に、登録に必要な値を明確にします。

src/types/user.ts

// 登録処理に渡す、検証済みデータの形です
export type CreateUserInput = {
  name: string;
  email: string;
};
TypeScript

これは、DBにあるすべての項目を表す型ではありません。

「今回の登録処理が受け付ける項目」を表します。

DBにはidやcreatedAtがあっても、利用者から自由に送信させる必要はありません。

サーバー側の入力検証を作る

ここは、今回特に重要な部分です。

ブラウザーから受け取る値には、次のようなものも含まれ得ます。

  • 空のオブジェクト。
  • null。
  • 配列。
  • 数値の名前。
  • 空白だけの名前。
  • 長すぎるメールアドレス。
  • 想定していない追加項目。

TypeScriptの型注釈だけでは、受信したJSONの中身は確認できません。今回はunknownとして受け取り、実行時に検証します。

src/lib/validation/user.ts

// 検証に成功した場合の型を読み込みます
import type { CreateUserInput } from "../../types/user";

// 成功と失敗を区別できる結果の型です
type ValidationResult =
  | {
      success: true;
      data: CreateUserInput;
    }
  | {
      success: false;
      message: string;
    };

// 外部から届いた値を、登録可能な形か検証します
export function validateCreateUser(
  input: unknown,
): ValidationResult {
  // null、配列、文字列などは対象外です
  if (
    typeof input !== "object" ||
    input === null ||
    Array.isArray(input)
  ) {
    return {
      success: false,
      message: "名前とメールアドレスを送信してください。",
    };
  }

  // 今回はnameとemail以外の項目を受け付けません
  const allowedKeys = new Set(["name", "email"]);

  if (Object.keys(input).some((key) => !allowedKeys.has(key))) {
    return {
      success: false,
      message: "登録できない項目が含まれています。",
    };
  }

  // まず、文字列であることを確認します
  if (!("name" in input) || typeof input.name !== "string") {
    return {
      success: false,
      message: "名前を文字列で入力してください。",
    };
  }

  if (!("email" in input) || typeof input.email !== "string") {
    return {
      success: false,
      message: "メールアドレスを文字列で入力してください。",
    };
  }

  // 今回は前後の空白を取り除いて保存します
  const name = input.name.trim();
  const email = input.email.trim();

  if (name.length < 1 || name.length > 50) {
    return {
      success: false,
      message: "名前は1〜50文字で入力してください。",
    };
  }

  if (email.length < 1 || email.length > 254) {
    return {
      success: false,
      message: "メールアドレスは254文字以内で入力してください。",
    };
  }

  // 学習用の簡易チェックです
  const simpleEmailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;

  if (!simpleEmailPattern.test(email)) {
    return {
      success: false,
      message: "メールアドレスの形式を確認してください。",
    };
  }

  // 検証した項目だけで、新しいオブジェクトを作ります
  return {
    success: true,
    data: {
      name,
      email,
    },
  };
}
TypeScript

APIでは入力の型・長さ・形式を確認し、受け付ける項目を明確にすることが重要です。(🔗 cheatsheetseries.owasp.org)

なぜ余分な項目を受け付けないのか

たとえば、将来ユーザーに管理者フラグを追加した場合でも、登録APIから自由に指定されてはいけません。

今回のAPIは、入力オブジェクトをそのままDBへ渡さず、許可したnameとemailだけを扱います。

メール形式の確認には限界があります

今回の正規表現は、基本的な入力間違いを見つけるための簡易チェックです。

  • 実在するメールアドレスかは確認できません。
  • そのメールアドレスを本人が所有しているかは確認できません。
  • 国際化されたアドレスなど、すべての有効な形式に対応するものではありません。

実際の会員登録では、採用する検証ライブラリやメール確認フローも含めて設計します。

また、今回は前後の空白だけを除去し、大文字・小文字は変更しません。メールアドレスの重複判定方針は、保存方法やDB設定も含めて、後から曖昧にならないよう決める必要があります。

Prismaでデータを作成するサービスを作る

次に、DBへの保存処理を実装します。

Day 53のuser.service.tsを、次の内容へ変更します。

src/services/user.service.ts

// ブラウザー側からの誤ったimportを防ぎます
import "server-only";

// 共通のPrisma Clientと登録データの型を読み込みます
import { prisma } from "../lib/prisma";
import type { CreateUserInput } from "../types/user";

// ユーザー一覧を取得します
export async function getUsers() {
  return prisma.user.findMany({
    select: {
      id: true,
      name: true,
    },

    // 登録したユーザーを確認しやすいよう、IDの大きい順にします
    orderBy: {
      id: "desc",
    },

    take: 20,
  });
}

// 検証済みのデータを使ってユーザーを作成します
export async function createUser(input: CreateUserInput) {
  return prisma.user.create({
    // 保存する項目を明示します
    data: {
      name: input.name,
      email: input.email,
    },

    // 呼び出し側へ返す項目も明示します
    select: {
      id: true,
      name: true,
    },
  });
}
TypeScript

Prismaのcreate()は、モデルに対応するレコードを作成します。今回はdataへ保存値を指定し、selectで返す項目を限定しています。(🔗 prisma.io)

サービスはHTTPを知らなくてもよい形にする

サービスの中では、NextResponseを返していません。

  • サービスはデータを保存します。
  • Route HandlerがHTTPステータスを決めます。

この分担にすると、将来Server Actionなどから作成処理を呼ぶ場合も、DB操作部分を再利用しやすくなります。

ただし、別の入口から呼ぶ場合も、その入口で入力検証と必要な権限確認を行います。

POST APIを実装する

いよいよ、HTTPリクエストを受け付けます。

src/app/api/users/route.ts

// JSONレスポンスを作るために読み込みます
import { NextResponse } from "next/server";

// 生成クライアントに対応したPrismaのエラー型を使います
import { Prisma } from "../../../generated/prisma/client";

// 入力検証と保存処理を読み込みます
import { validateCreateUser } from "../../../lib/validation/user";
import { createUser } from "../../../services/user.service";

// ローカルSQLiteのドライバーをNode.js環境で動かします
export const runtime = "nodejs";

// JSONレスポンスの共通設定です
function reply(body: unknown, status: number) {
  return NextResponse.json(body, {
    status,
    headers: {
      "Cache-Control": "no-store",
    },
  });
}

// POST /api/users を処理します
export async function POST(request: Request) {
  // 認証未実装のため、今回は開発環境だけで登録を許可します
  if (process.env.NODE_ENV !== "development") {
    return reply(
      {
        message: "この登録APIはローカル学習用です。",
      },
      403,
    );
  }

  // application/json; charset=utf-8 なども扱います
  const mediaType = request.headers
    .get("content-type")
    ?.split(";")[0]
    .trim()
    .toLowerCase();

  if (mediaType !== "application/json") {
    return reply(
      {
        message: "JSON形式で送信してください。",
      },
      415,
    );
  }

  let body: unknown;

  try {
    // 本文の読み取りは、ここで1回だけ行います
    body = await request.json();
  } catch {
    return reply(
      {
        message: "JSONを読み取れませんでした。",
      },
      400,
    );
  }

  // JSONとして読めても、内容が正しいとは限りません
  const result = validateCreateUser(body);

  if (!result.success) {
    return reply(
      {
        message: result.message,
      },
      422,
    );
  }

  try {
    // 検証済みの項目だけをDBへ渡します
    const user = await createUser(result.data);

    return reply(
      {
        message: "ユーザーを登録しました。",
        user,
      },
      201,
    );
  } catch (error) {
    // 今回のモデルではemailの一意制約違反を扱います
    if (
      error instanceof Prisma.PrismaClientKnownRequestError &&
      error.code === "P2002"
    ) {
      return reply(
        {
          message: "このメールアドレスは登録済みです。",
        },
        409,
      );
    }

    // 入力値やDB接続先などを、そのままログへ出しません
    console.error("ユーザー作成処理で予期しないエラーが発生しました。");

    return reply(
      {
        message: "登録に失敗しました。時間をおいてお試しください。",
      },
      500,
    );
  }
}
TypeScript

request.json()で本文を読み取り、NextResponse.json()でJSONの結果を返しています。Route Handlersでは、Web標準のRequest APIを使って本文を取得できます。本文は原則として一度読み取ったものをそのまま再度読むことはできないため、取得した値を変数に保存して使います。(🔗 nextjs.org)

なぜJSONの読み取りとDB処理を分けたのか

すべてをひとつのtry...catchにすると、壊れたJSONもDB障害も、同じ500として返してしまいがちです。

今回は、失敗する場所ごとに意味を分けました。

  • JSONを解釈できない場合は400です。
  • 値の内容が不正なら422です。
  • DBの一意制約に違反したら409です。
  • それ以外の保存失敗は500です。

これにより、利用者にも開発者にも、何を直すべきか伝えやすくなります。

P2002とは何か

Prismaでは、一意制約違反が既知のリクエストエラーとして報告され、コードP2002で識別できます。

今回はemailへ@uniqueを設定しているため、同じ保存値のメールアドレスを登録しようとすると、このエラーを処理します。(🔗 docs.prisma.io)

将来、一意制約のある項目を増やした場合は、すべてのP2002をメール重複と案内してよいか見直します。

先に重複検索すれば十分なのか

登録前に「同じメールがあるか」を検索しても、その直後に別のリクエストが登録する可能性があります。

そのため、DBの一意制約を最終的な防波堤として残し、保存時のエラーも処理することが重要です。

画面上の事前チェックだけで、一意性を保証しようとしないようにします。

まずはAPI単体で確認する

画面を作る前に、APIだけを確認すると原因を切り分けやすくなります。

開発サーバーを起動します。

# 開発環境で起動します
npm run dev
Bash

macOS、Linux、Git Bashなどでは、別のターミナルから次のように送信できます。

# JSONをPOSTし、レスポンスヘッダーも表示します
curl -i http://localhost:3000/api/users \
  -X POST \
  -H 'Content-Type: application/json' \
  --data '{"name":"結衣","email":"day54-yui@example.com"}'
Bash

Windowsでは、環境に合わせてcurl.exeを使うなど、コマンドの引用符や改行方法を調整します。

成功すると、ステータスは201になり、登録したユーザーのIDと名前が返ります。

同じリクエストをもう一度送る

同じメールアドレスで再送すると、今回は409になります。

これはAPIの故障ではありません。重複登録をDBの制約で防ぎ、決めたレスポンスへ変換できている状態です。

ブラウザーでURLを開くだけではPOSTにならない

アドレスバーで/api/usersを開く操作はGETです。

今回のファイルにはPOSTしか定義していないため、GETでユーザー作成は行われません。Route Handlersでは、未対応のHTTPメソッドに対して405が返されます。(🔗 nextjs.org)

登録フォームを作る

API単体で登録できたら、画面から呼び出します。

ここではState、送信イベント、通信状態を使うため、フォームをClient Componentにします。

src/components/UserCreateForm.tsx

"use client";

// 入力値、通信状態、二重送信防止用の参照を使います
import { useRef, useState } from "react";
import type { FormEvent } from "react";

// 保存後に一覧を再取得するために使います
import { useRouter } from "next/navigation";

// レスポンスから、文字列のメッセージだけを読み取ります
function readMessage(value: unknown): string | null {
  if (
    typeof value === "object" &&
    value !== null &&
    "message" in value &&
    typeof value.message === "string"
  ) {
    return value.message;
  }

  return null;
}

export default function UserCreateForm() {
  const router = useRouter();

  // 入力中の値です
  const [name, setName] = useState("");
  const [email, setEmail] = useState("");

  // 表示と操作の状態です
  const [isSubmitting, setIsSubmitting] = useState(false);
  const [successMessage, setSuccessMessage] = useState("");
  const [errorMessage, setErrorMessage] = useState("");

  // 再描画前の短時間の連続実行も抑えます
  const submittingRef = useRef(false);

  async function handleSubmit(
    event: FormEvent<HTMLFormElement>,
  ) {
    // 通常のHTMLフォーム送信を止めます
    event.preventDefault();

    if (submittingRef.current) {
      return;
    }

    submittingRef.current = true;
    setIsSubmitting(true);
    setSuccessMessage("");
    setErrorMessage("");

    try {
      const response = await fetch("/api/users", {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
        },

        // JavaScriptのオブジェクトをJSON文字列に変換します
        body: JSON.stringify({
          name,
          email,
        }),
      });

      // API以外の障害でJSONが返らない可能性も扱います
      const payload: unknown = await response
        .json()
        .catch(() => null);

      const message = readMessage(payload);

      // 400や409などは、fetchのcatchへ自動では入りません
      if (!response.ok) {
        setErrorMessage(
          message ?? "登録処理を完了できませんでした。",
        );
        return;
      }

      setSuccessMessage(
        message ?? "ユーザーを登録しました。",
      );

      // 成功した場合だけ、入力欄を空にします
      setName("");
      setEmail("");

      // 現在のページのServer Componentを再取得します
      router.refresh();
    } catch {
      // 通信が途切れた場合などに表示します
      setErrorMessage(
        "通信結果を確認できませんでした。一覧を確認してから再送してください。",
      );
    } finally {
      // 成功・失敗のどちらでも送信状態を解除します
      submittingRef.current = false;
      setIsSubmitting(false);
    }
  }

  return (
    <section aria-labelledby="create-user-heading">
      <h2 id="create-user-heading">ユーザーを登録する</h2>

      <form onSubmit={handleSubmit}>
        {/* 送信中は入力欄とボタンをまとめて無効化します */}
        <fieldset disabled={isSubmitting}>
          <legend>登録情報</legend>

          <p>
            <label htmlFor="user-name">名前</label>
            <br />
            <input
              id="user-name"
              name="name"
              type="text"
              autoComplete="name"
              required
              maxLength={50}
              value={name}
              onChange={(event) => setName(event.target.value)}
            />
          </p>

          <p>
            <label htmlFor="user-email">メールアドレス</label>
            <br />
            <input
              id="user-email"
              name="email"
              type="email"
              autoComplete="email"
              required
              maxLength={254}
              value={email}
              onChange={(event) => setEmail(event.target.value)}
            />
          </p>

          <button type="submit">
            {isSubmitting ? "登録しています…" : "登録する"}
          </button>
        </fieldset>
      </form>

      {successMessage && (
        <p role="status">{successMessage}</p>
      )}

      {errorMessage && (
        <p role="alert">{errorMessage}</p>
      )}
    </section>
  );
}
TSX

response.okを確認する理由

fetch()は、HTTPの409や500を受け取っただけでは、通常の通信例外としてcatchへ入りません。

HTTP結果を確認するには、response.okやresponse.statusを使います。response.okは200番台のステータスでtrueになります。(🔗 developer.mozilla.org)

今回の役割は、次のように分かれます。

  • !response.okは、APIから返された失敗を扱います。
  • catchは、通信失敗などを扱います。
  • finallyは、送信中の状態を必ず解除します。

エラー時に入力値を消さない理由

入力に問題があった場合、すべて消してしまうと修正し直しにくくなります。

今回は成功した場合だけ入力欄を空にし、失敗時には残しています。

通信失敗は「保存されていない」とは限らない

サーバーで保存した後、レスポンスがブラウザーへ届く前に通信が途切れることも考えられます。

そのため、通信例外のメッセージでは「登録されませんでした」と断定せず、一覧の確認を案内しています。

登録処理を無条件に自動再送する設計には、今回はしていません。

フォームとユーザー一覧を同じページへ配置する

Day 53のユーザー一覧ページを変更します。

src/app/users/page.tsx

// Metadata、フォーム、取得サービスを読み込みます
import type { Metadata } from "next";
import UserCreateForm from "../../components/UserCreateForm";
import { getUsers } from "../../services/user.service";

// SQLiteドライバーをNode.js環境で使います
export const runtime = "nodejs";

// 今回はアクセス時にDBから取得します
// cacheComponentsを有効にしていない構成を前提にします
export const dynamic = "force-dynamic";

export const metadata: Metadata = {
  title: "ユーザー管理",
  description: "ユーザーの登録と一覧表示を学ぶページです。",
};

export default async function UsersPage() {
  const users = await getUsers();

  return (
    <section>
      <h1>ユーザー管理</h1>

      <p>
        このページは、ダミーデータを使うローカル学習用です。
      </p>

      {/* 入力とイベント処理だけをClient Componentにします */}
      <UserCreateForm />

      <section aria-labelledby="user-list-heading">
        <h2 id="user-list-heading">登録済みユーザー</h2>

        <p>IDの大きい順に、最大20件表示します。</p>

        {users.length === 0 ? (
          <p>ユーザーはまだ登録されていません。</p>
        ) : (
          <ul>
            {users.map((user) => (
              <li key={user.id}>
                ID:{user.id} / 名前:{user.name}
              </li>
            ))}
          </ul>
        )}
      </section>
    </section>
  );
}
TSX

ページ全体をClient Componentにしない

今回、DBからの取得はServer Component、操作フォームはClient Componentへ分けています。

フォームがあるからといって、ページ全体に"use client"を付ける必要はありません。

router.refresh()はDBへ保存する命令ではない

保存は、その前にPOST APIで完了しています。

router.refresh()は、現在のページのServer Componentを再取得し、画面を更新するために使っています。また、これはサーバー側のデータキャッシュをすべて無効化する命令ではありません。(🔗 nextjs.org)

今回は動的ページから直接Prismaを呼び、取得処理へ追加のサーバーキャッシュを設定していないため、この構成で一覧を更新します。

将来キャッシュを導入したら、保存後の無効化方針も一緒に設計します。

正常系と異常系をテストする

画面で登録できたら、入力不正や重複も確認します。

確認内容操作・送信内容期待する結果
正常な登録未登録のメールで送信201、DBへ保存
重複同じメールで再送409、行は増えない
空の名前"name": " "422
型の不正"name": 123422
本文がnullJSONのnullを送信422
余分な項目idなどを追加422
壊れたJSON閉じ括弧がない本文400
JSON以外text/plainで送信415
GETアクセスアドレスバーでAPIを開く405
開発環境以外本番起動でPOST今回の保護により403

ブラウザーの入力制限だけで満足しない

requiredやtype="email"があるため、画面からは送れない入力もあります。

しかし、APIへ直接リクエストすれば、ブラウザーのフォーム検証を通らずに送信できます。サーバー側で同じ条件を確認する必要があります。(🔗 cheatsheetseries.owasp.org)

たとえば、名前が空白だけの場合を確認します。

# JSONとしては正しくても、内容は不正な入力です
curl -i http://localhost:3000/api/users \
  -X POST \
  -H 'Content-Type: application/json' \
  --data '{"name":"   ","email":"empty-name@example.com"}'
Bash

壊れたJSONも確認できます。

# JSONの閉じ括弧を省略して、読み取り失敗を確認します
curl -i http://localhost:3000/api/users \
  -X POST \
  -H 'Content-Type: application/json' \
  --data '{"name":"結衣"'
Bash

再起動してもデータが残るか確認する

  • 新しいメールアドレスで登録します。
  • ユーザー一覧へ表示されることを確認します。
  • 開発サーバーを停止します。
  • 再起動して/usersを開きます。
  • 登録したユーザーが残っていることを確認します。

配列やStateだけではなく、DBへ保存できているかを確かめます。

error.tsxだけでは送信エラーを扱えない理由

Day 50では、ページ描画中の取得失敗をerror.tsxで扱いました。

今回のフォーム送信は、クリックや送信イベントの中で実行する通信です。そこで起きるHTTPエラーや通信例外は、今回のように送信処理の中で扱います。

また、POST APIが500を返すことと、ページのエラー境界が自動的に表示されることは別です。APIのレスポンスを受け取ったフォームが、どう案内するかを決めます。

APIのHTTP結果はresponse.okなどで確認する、という基本へ戻って考えると整理しやすくなります。(🔗 developer.mozilla.org)

公開前に追加しなければならない対策

今回のAPIは、開発環境だけで登録できるようにしています。

NODE_ENVによる制限は認証ではありません。 開発サーバーを外部へ公開しないことも含め、ローカルのダミーデータ用として扱います。

公開するユーザー管理APIでは、少なくとも次の点を検討します。

項目必要な設計
認証誰が呼び出しているか確認します
認可その利用者がユーザーを作成してよいか確認します
不正利用対策リクエスト頻度や登録数を制限します
本文サイズ大きすぎる本文を読み取る前に制限します
CSRFCookie認証の方式などに応じた対策を行います
個人情報取得・返却・ログへ出す項目を限定します
通信公開環境ではHTTPSを使用します

保護が必要なAPIは、画面を隠すだけではなく、APIの入口やデータアクセス側で適切に認証・認可する必要があります。CORSも、本人確認の代わりにはなりません。(🔗 cheatsheetseries.owasp.org)

文字数制限と本文サイズ制限は別です

今回の名前50文字、メール254文字という確認は、JSONを読み取った後に実行します。

そのため、巨大な本文を受け取ること自体を防ぐ対策ではありません。公開環境では、利用するサーバーやゲートウェイなどで本文サイズも制限し、過大なリクエストを拒否する設計が必要です。(🔗 cheatsheetseries.owasp.org)

重複の案内が情報公開につながる場合もある

今回の管理練習では「登録済みです」と返しています。

一方、一般公開の会員登録では、そのメールアドレスの登録有無を第三者へ知らせてよいかを検討します。管理者向けAPIと、誰でも使える登録APIでは、同じ返答が適切とは限りません。

二重送信防止は画面だけで完成しない

今回は、送信中の無効化とuseRefで、同じ画面からの連続操作を抑えています。

ただし、別タブや直接のAPI呼び出しまで防ぐものではありません。メール重複はDBの一意制約で防ぎますが、重複が許される別の作成処理では、必要に応じてリクエストの重複処理方針も設計します。

決済などでは、さらに慎重に扱います

同じリクエストを再送したとき、同じ処理をもう一度実行してよいかを決めます。

作成成功と通信成功は別です

DBへの保存成功後に通信が切れると、利用者側では成功を確認できない場合があります。

今回覚えておきたい原則

失敗したように見えたからといって、登録処理を無条件に繰り返さないことです。今回のフォームでも、通信結果が不明な場合は一覧確認を案内しています。

よくあるつまずきと確認方法

症状確認すること改善の方向
APIが404になるファイルの位置app/api/users/route.tsを確認します
ブラウザーで開くと405になるHTTPメソッド作成にはPOSTを送ります
415になるContent-Typeapplication/jsonを指定します
400になるJSONの構文引用符や括弧を確認します
422になる受信データの内容名前・メール・余分な項目を確認します
409になるメールの重複別のダミーメールで試します
本番起動で403になる開発専用の制限今回は意図した動作です
保存後に一覧が変わらない一覧の取得と更新router.refresh()とキャッシュ設定を確認します
DBへアクセスできないDay 53の接続環境変数・生成・Migrationを確認します
フォームの例外がError画面に出ないエラーを扱う場所送信処理の中でHTTP結果と例外を処理します

自力で取り組む練習問題

名前の文字数ルールを変更する

最大文字数を50文字から30文字へ変更します。

  • サーバー側の検証を変更します。
  • 入力欄のmaxLengthも変更します。
  • APIへ直接長い名前を送信し、拒否されることを確認します。

任意のプロフィール欄を追加する

Day 53でbio String?を追加済みの場合は、登録時にも指定できるようにします。

変更前に、次の点を決めます。

  • 未入力はnullとして扱いますか。
  • 空文字のまま保存しますか。
  • 最大文字数はいくつですか。
  • レスポンスに含める必要がありますか。

フォームへ入力欄を増やすだけでなく、型、許可項目、検証、保存処理まで確認します。

成功時に作成したユーザー名を表示する

APIが返したuser.nameを使って、成功メッセージを具体的にします。

その場合は、レスポンスのuserが想定した構造かを確認する処理も追加します。型アサーションだけで、外部データを検証したことにはしないようにします。

本番ビルドで確認する

開発環境で動作したら、型とビルドも確認します。

# 生成クライアントを確認・更新します
npx prisma generate

# TypeScriptの整合性を確認します
npx tsc --noEmit

# 本番用にビルドします
npm run build

# 本番用サーバーを起動します
npm run start
Bash

今回のAPIは、本番起動では登録を拒否します。POSTに403が返るのは、実装した開発専用制限によるものです。

公開用にする場合は、制限を削除するだけで済ませず、先に認証・認可などを実装します。

Day 54のチェックリスト

  • POST /api/usersを作れました。
  • JSONをunknownとして受け取れます。
  • JSONの構文エラーと、入力内容の不正を区別できます。
  • 許可した項目だけをDBへ渡せます。
  • Prismaのcreate()でユーザーを保存できます。
  • 一意制約違反を409として扱えます。
  • 内部エラーをそのままブラウザーへ返さずに処理できます。
  • フォームからPOSTリクエストを送れます。
  • response.okでHTTP結果を確認できます。
  • 保存後に一覧を更新できます。
  • 再起動後もデータが残ることを確認できました。
  • ローカル学習用のAPIと、公開可能なAPIの違いを説明できます。

まとめ

Day 54では、フォームから送信した名前とメールアドレスを、POST APIで受け取り、Prismaを通じてSQLiteへ保存しました。

今回の中心は、「入力を受け取る」「サーバーで検証する」「DBへ保存する」「結果をHTTPで返す」「画面へ反映する」という一連の流れです。保存の成功だけでなく、入力不正、重複、通信結果が分からない場合も分けて扱いました。

この流れを説明できれば、記事投稿、タスク追加、商品登録などにも応用できます。対象データが変わっても、受け付ける項目と権限を明確にし、必要な値だけを保存するという基本は共通です。

タイトルとURLをコピーしました