Next.jsで学ぶReact講座 90日コース | Next.jsでCRUDアプリ開発 - Day 58:CRUD総合演習

React Next.jsで学ぶReact講座90日コース
スポンサーリンク
スポンサーリンク
  1. Day 58:CRUD総合演習 ― メモ管理アプリを完成させる
  2. 今回の完成形を確認する
  3. 最初に今回の範囲を決める
    1. ローカル学習用のアプリとして作る
    2. 更新にはPUTを使う
  4. アプリ全体の役割を分ける
    1. 今回の画面状態の管理方針
  5. 実装前に仕様を書き出す
  6. 完成時のファイル構成
  7. データベースへNoteモデルを追加する
    1. prisma/schema.prismaへ追加するコード
    2. MigrationとClient生成を行う
  8. 画面とAPIで共有する型を作る
    1. src/types/note.ts
  9. 作成・更新の入力検証を作る
    1. src/lib/note-input.ts
    2. 本文へtrimを使わない理由
  10. DB操作をサービスへまとめる
    1. src/services/note.service.ts
  11. APIの共通処理を作る
    1. src/lib/note-http.ts
    2. 共通化する範囲を広げすぎない
  12. 一覧取得と新規作成APIを作る
    1. src/app/api/notes/route.ts
  13. 更新と削除APIを作る
    1. src/app/api/notes/[id]/route.ts
    2. 今回のAPI契約を整理する
  14. API単体で動作確認する
    1. メモを作成する
    2. 一覧を取得する
    3. 更新する
    4. 削除する
  15. CRUDをひとつの画面へまとめる
    1. 編集対象のIDでモードを判断する
  16. メモ管理コンポーネントを作る
    1. src/components/notes/NotesApp.tsx
  17. 画面コードの重要部分を読み解く
    1. 新規作成と編集で同じフォームを使う
    2. 変更成功と一覧取得失敗を区別する
    3. 通信が切れた場合は、保存結果が不明なこともある
    4. 処理中はほかの操作を止める
  18. メモ管理ページを作る
    1. src/app/notes/page.tsx
  19. 初回読み込みと初回エラーを用意する
    1. src/app/notes/loading.tsx
    2. src/app/notes/error.tsx
  20. 画面を開いて一連の操作を確認する
    1. ひとつのメモでCRUDを確認する
  21. 総合演習で確認したい重要なケース
  22. 動作確認のためのCSSについて
  23. よくある失敗を整理する
    1. DB保存とState更新を混同する
    2. 作成と更新で送信先を間違える
    3. 編集中のメモを削除した後も編集IDが残る
    4. 一覧取得失敗を空配列へ変えない
  24. セキュリティとデータ整合性を深掘りする
    1. メモは個人情報や秘密情報になり得る
    2. ownerIdを追加するだけでは保護にならない
    3. 本文をHTMLとして表示しない
    4. 同時編集への対策は未実装
  25. 型チェックと本番ビルドを確認する
  26. 自力で取り組む発展課題
    1. 検索機能を追加する
    2. 作成日時と更新日時を表示する
    3. 未保存変更の確認を追加する
    4. ページネーションを追加する
  27. Day 58のチェックリスト
  28. まとめ

Day 58:CRUD総合演習 ― メモ管理アプリを完成させる

Day 58では、これまで個別に学んだCreate・Read・Update・Deleteを組み合わせ、ひとつのメモ管理アプリを作ります。タイトルと本文を入力して保存し、一覧で確認し、編集し、不要になったら削除できるアプリです。

今回の目標は、APIを4種類作ることだけではありません。データベース、API、入力フォーム、画面の状態をつなぎ、ひとつの操作として矛盾なく動かすことを目指します。

今回の完成形を確認する

メモ管理画面には、新規作成・編集に使うフォームと、保存済みメモの一覧を配置します。

機能利用者の操作サーバー側の処理
Createタイトルと本文を入力して保存しますメモを作成します
Read画面を開く、一覧を更新しますメモ一覧を取得します
Update編集ボタンを押して内容を変更します指定したメモを更新します
Delete対象を確認して削除します指定したメモを削除します

画面のイメージは、次のとおりです。

メモ管理

[新しいメモ]
タイトル:[                     ]
本文    :[                     ]
          [                     ]
[作成する]

[一覧を更新する]

買い物メモ
牛乳とパンを買います。
[編集する][削除する]

Next.jsの復習
CRUDの流れを確認します。
[編集する][削除する]

今回は機能のつながりを理解するため、検索、カテゴリー、ログイン、画像添付などは追加しません。

最初に今回の範囲を決める

ローカル学習用のアプリとして作る

今回も、Day 53以降のPrismaとSQLiteの接続環境を引き継ぎます。

  • Next.js App RouterとTypeScriptを使用します。
  • srcディレクトリを使用します。
  • Prisma Clientの生成先はsrc/generated/prismaです。
  • src/lib/prisma.tsから共通のPrisma Clientを使います。
  • cacheComponents: trueを有効にしていない構成を前提にします。

今回は認証未実装のため、開発環境だけで使えるようにします。実際の個人情報や秘密のメモは保存しないでください。

Route Handlersは、画面からだけでなく直接呼び出せるHTTPエンドポイントです。公開するアプリでは、APIごとの認証・認可が必要です。(🔗 nextjs.org)

更新にはPUTを使う

今回は、編集フォームからタイトルと本文の両方を送信するため、更新APIにはPUTを使います。

メソッドURL今回の役割
GET/api/notes一覧取得
POST/api/notes新規作成
PUT/api/notes/[id]タイトルと本文の更新
DELETE/api/notes/[id]1件削除

PATCHも実装すると処理が増えるため、今回は追加しません。部分更新へ発展させる場合は、Day 56で学んだ省略項目の扱いを使います。

アプリ全体の役割を分ける

今回の設計では、初回表示と、その後の操作を次のように分けます。

初回表示
    Server Component
        ↓
    メモ取得サービス
        ↓
    Prisma
        ↓
    SQLite

作成・更新・削除・一覧再取得
    Client Component
        ↓
    API
        ↓
    メモ用サービス
        ↓
    Prisma
        ↓
    SQLite

初回のServer Componentから、わざわざ自分のGET APIへHTTP通信する必要はありません。サービスを直接呼び出します。ブラウザーでの再取得や変更操作にはAPIを使います。(🔗 nextjs.org)

今回の画面状態の管理方針

画面へ渡した初期一覧は、Client ComponentのStateへ入れます。その後の一覧更新は、GET APIを呼び、Stateを置き換えます。

今回、一覧更新にrouter.refresh()は使いません。

ReactのuseState(initialState)に渡した値は、初期化後の再レンダーでは初期値として再採用されません。そのため、「初期一覧をStateへ持つ設計」と「サーバーからのprops更新だけで一覧を変える設計」を混ぜないようにします。(🔗 react.dev)

実装前に仕様を書き出す

小さなアプリでも、先にルールを決めると迷いにくくなります。

項目今回の仕様
タイトル前後の空白を除き、1〜80文字
本文0〜5,000文字
本文の空白・改行入力内容をそのまま保存
一覧の件数最大50件
並び順IDの大きい順
編集タイトルと本文を両方送信
削除確認後に実行
同時操作通信中はほかの操作を無効化
変更成功後GET APIで一覧を再取得
一覧再取得だけ失敗保存成功と表示更新失敗を区別

IDの大きい順を使うため、編集しただけでは先頭へ移動しません。今回は「更新日時の新しい順」ではないことを、画面の説明ともそろえます。

完成時のファイル構成

既存のユーザー管理機能は残したまま、メモ用のファイルを追加します。

prisma/
└── schema.prisma

src/
├── app/
│   ├── api/
│   │   └── notes/
│   │       ├── [id]/
│   │       │   └── route.ts
│   │       └── route.ts
│   └── notes/
│       ├── error.tsx
│       ├── loading.tsx
│       └── page.tsx
├── components/
│   └── notes/
│       └── NotesApp.tsx
├── lib/
│   ├── prisma.ts
│   ├── note-input.ts
│   └── note-http.ts
├── services/
│   └── note.service.ts
└── types/
    └── note.ts

src/lib/prisma.tsは、これまで動作確認できているものをそのまま使います。

データベースへNoteモデルを追加する

まず、保存するメモの形を定義します。

prisma/schema.prismaへ追加するコード

既存のgenerator、datasource、Userモデルなどは削除しません。

// メモ1件を表すモデルです
model Note {
  // メモを一意に識別します
  id Int @id @default(autoincrement())

  // メモのタイトルです
  title String

  // 本文は空文字も許可します
  content String @default("")

  // 作成日時です
  createdAt DateTime @default(now()) @map("created_at")

  // Prisma経由の更新時に日時を更新します
  updatedAt DateTime @updatedAt @map("updated_at")

  // 実際のテーブル名です
  @@map("notes")
}
Prisma

@updatedAtは、Prisma側で更新日時を扱うための指定です。DBのどの操作経路でも自動的に更新されるトリガーと同じものではありません。(🔗 prisma.io)

今回は日時を保存しますが、画面やAPIではID、タイトル、本文だけを使います。

MigrationとClient生成を行う

# スキーマの書式を整えます
npx prisma format

# notesテーブルを作る変更を生成・適用します
npx prisma migrate dev --name add_notes

# Noteモデルに対応するクライアントを生成します
npx prisma generate
Bash

Prisma Clientはスキーマに合わせて生成されます。モデル追加後は、DBへの反映と、クライアント生成の両方を行います。(🔗 prisma.io)

メモの初期データは、後ほど画面から作成するため、Seedは不要です。

画面とAPIで共有する型を作る

src/types/note.ts

// APIや画面で扱う、メモ1件の形です
export type NoteItem = {
  id: number;
  title: string;
  content: string;
};

// 作成・更新で受け付ける項目です
export type NoteInput = {
  title: string;
  content: string;
};
TypeScript

NoteInputには、IDや日時を含めません。

利用者が入力できる値と、DBが管理する値を分けるためです。

作成・更新の入力検証を作る

今回はPOSTとPUTで同じ入力条件を使います。

src/lib/note-input.ts

// 検証後の入力型を読み込みます
import type { NoteInput } from "../types/note";

// 成功と失敗を区別します
type ValidationResult =
  | { success: true; data: NoteInput }
  | { success: false; message: string };

// 外部から届いたJSONの内容を確認します
export function validateNoteInput(
  input: unknown,
): ValidationResult {
  if (
    typeof input !== "object" ||
    input === null ||
    Array.isArray(input)
  ) {
    return {
      success: false,
      message: "タイトルと本文を送信してください。",
    };
  }

  // 変更を許可する項目だけを受け付けます
  const allowedKeys = new Set(["title", "content"]);

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

  if (
    !("title" in input) ||
    typeof input.title !== "string" ||
    !("content" in input) ||
    typeof input.content !== "string"
  ) {
    return {
      success: false,
      message: "タイトルと本文は文字列で指定してください。",
    };
  }

  // タイトルだけ、前後の空白を取り除きます
  const title = input.title.trim();

  // 本文の改行や空白は保存します
  const content = input.content;

  if (title.length < 1 || title.length > 80) {
    return {
      success: false,
      message: "タイトルは1〜80文字で入力してください。",
    };
  }

  if (content.length > 5000) {
    return {
      success: false,
      message: "本文は5,000文字以内で入力してください。",
    };
  }

  return {
    success: true,
    data: { title, content },
  };
}
TypeScript

今回の文字数は、JavaScriptのlengthを基準とします。絵文字などでは見た目の文字数と一致しない場合があるため、厳密な文字数仕様が必要なアプリでは、数え方も別途決めます。

本文へtrimを使わない理由

本文では、意図的に入れた改行や空白を残したい場合があります。

そのため、タイトルは整形しますが、本文はそのまま保存します。「すべての文字列を同じように加工する」のではなく、項目の意味に応じて決めます。

DB操作をサービスへまとめる

ここで、CRUDの4つの関数をひとつのファイルへ用意します。

src/services/note.service.ts

import "server-only";

// 共通の接続と型を読み込みます
import { prisma } from "../lib/prisma";
import type { NoteInput, NoteItem } from "../types/note";

// 返す項目を統一します
const noteSelect = {
  id: true,
  title: true,
  content: true,
} as const;

// Read:最大50件を取得します
export async function getNotes(): Promise<NoteItem[]> {
  return prisma.note.findMany({
    select: noteSelect,
    orderBy: { id: "desc" },
    take: 50,
  });
}

// Create:メモを1件作成します
export async function createNote(
  input: NoteInput,
): Promise<NoteItem> {
  return prisma.note.create({
    data: {
      title: input.title,
      content: input.content,
    },
    select: noteSelect,
  });
}

// Update:主キーで指定したメモを更新します
export async function updateNote(
  id: number,
  input: NoteInput,
): Promise<NoteItem> {
  return prisma.note.update({
    where: { id },
    data: {
      title: input.title,
      content: input.content,
    },
    select: noteSelect,
  });
}

// Delete:主キーで指定したメモを削除します
export async function deleteNote(id: number) {
  return prisma.note.delete({
    where: { id },
    select: { id: true },
  });
}
TypeScript

Prisma Clientでは、findMany()、create()、update()、delete()などでCRUDを表現します。今回は保存項目と取得項目を明示し、更新・削除は主キーで対象を限定しています。(🔗 prisma.io)

サービスは、検証済みのデータを受け取る前提です。HTTP以外から呼ぶ場合も、その入口で入力と権限を確認します。

APIの共通処理を作る

APIごとに同じコードを何度も書かないよう、今回のメモAPI専用の共通処理を用意します。

まとめるのは、次の処理です。

  • 開発環境の確認。
  • JSONレスポンスの作成。
  • 入力エラーの表現。
  • JSON本文の読み取りと検証。
  • IDの検証。
  • 未存在と予期しないエラーの変換。

src/lib/note-http.ts

import "server-only";

import { NextResponse } from "next/server";
import { Prisma } from "../generated/prisma/client";
import { validateNoteInput } from "./note-input";

// APIで意図的に返すエラーを表します
export class NoteApiError extends Error {
  constructor(
    public status: number,
    message: string,
  ) {
    super(message);
  }
}

// JSONレスポンスを作ります
export function noteJson(body: unknown, status = 200) {
  return NextResponse.json(body, {
    status,
    headers: {
      "Cache-Control": "no-store",
    },
  });
}

// URLから受け取ったIDを検証します
export function parseNoteId(rawId: string): number {
  if (!/^[1-9]\d{0,9}$/.test(rawId)) {
    throw new NoteApiError(400, "メモIDの形式が不正です。");
  }

  const id = Number(rawId);

  if (!Number.isSafeInteger(id) || id > 2_147_483_647) {
    throw new NoteApiError(400, "メモIDが範囲外です。");
  }

  return id;
}

// POSTとPUTの本文を読み取り、検証します
export async function readNoteInput(request: Request) {
  const mediaType = request.headers
    .get("content-type")
    ?.split(";")[0]
    .trim()
    .toLowerCase();

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

  let body: unknown;

  try {
    body = await request.json();
  } catch {
    throw new NoteApiError(400, "JSONを読み取れませんでした。");
  }

  const result = validateNoteInput(body);

  if (!result.success) {
    throw new NoteApiError(422, result.message);
  }

  return result.data;
}

// メモAPIに共通する許可条件とエラー処理です
export async function runNoteApi(
  action: () => Promise<Response>,
): Promise<Response> {
  // 認証未実装のため、本番環境では利用できません
  if (process.env.NODE_ENV !== "development") {
    return noteJson(
      { message: "このAPIはローカル学習用です。" },
      403,
    );
  }

  try {
    return await action();
  } catch (error) {
    if (error instanceof NoteApiError) {
      return noteJson(
        { message: error.message },
        error.status,
      );
    }

    // 更新・削除の対象が見つからない場合です
    if (
      error instanceof Prisma.PrismaClientKnownRequestError &&
      error.code === "P2025"
    ) {
      return noteJson(
        { message: "対象のメモが見つかりません。" },
        404,
      );
    }

    // 接続先や本文を、そのまま公開しません
    console.error("メモAPIで予期しないエラーが発生しました。");

    return noteJson(
      { message: "処理を完了できませんでした。" },
      500,
    );
  }
}
TypeScript

PrismaのP2025は、処理に必要な対象レコードが見つからない場合などに使われる既知エラーです。今回は更新・削除対象の未存在を404へ変換します。(🔗 prisma.io)

共通化する範囲を広げすぎない

このファイルは、すべてのアプリで使える巨大なAPI基盤ではありません。

今回のメモAPIで繰り返される処理をまとめただけです。最初からあらゆるケースへ対応させるより、現在必要なルールを明確にします。

一覧取得と新規作成APIを作る

src/app/api/notes/route.ts

// メモ用の共通HTTP処理です
import {
  noteJson,
  readNoteInput,
  runNoteApi,
} from "../../../lib/note-http";

// データ操作を読み込みます
import {
  createNote,
  getNotes,
} from "../../../services/note.service";

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

// GET /api/notes
export async function GET() {
  return runNoteApi(async () => {
    const notes = await getNotes();
    return noteJson({ notes });
  });
}

// POST /api/notes
export async function POST(request: Request) {
  return runNoteApi(async () => {
    const input = await readNoteInput(request);
    const note = await createNote(input);

    return noteJson(
      {
        message: "メモを作成しました。",
        note,
      },
      201,
    );
  });
}
TypeScript

一覧が0件なら、notes: []を200で返します。

「メモがない」と「DBの取得に失敗した」は別の状態として扱います。

更新と削除APIを作る

src/app/api/notes/[id]/route.ts

import {
  noteJson,
  parseNoteId,
  readNoteInput,
  runNoteApi,
} from "../../../../lib/note-http";

import {
  deleteNote,
  updateNote,
} from "../../../../services/note.service";

export const runtime = "nodejs";

// 動的ルートから受け取るパラメータです
type Context = {
  params: Promise<{ id: string }>;
};

// PUT /api/notes/[id]
export async function PUT(
  request: Request,
  context: Context,
) {
  return runNoteApi(async () => {
    const { id: rawId } = await context.params;
    const id = parseNoteId(rawId);
    const input = await readNoteInput(request);

    const note = await updateNote(id, input);

    return noteJson({
      message: "メモを更新しました。",
      note,
    });
  });
}

// DELETE /api/notes/[id]
export async function DELETE(
  _request: Request,
  context: Context,
) {
  return runNoteApi(async () => {
    const { id: rawId } = await context.params;
    const id = parseNoteId(rawId);

    const note = await deleteNote(id);

    return noteJson({
      message: "メモを削除しました。",
      deletedNoteId: note.id,
    });
  });
}
TypeScript

動的ルートのparamsはPromiseとして受け取り、awaitして使います。HTTPメソッドごとの関数をexportする構成は、これまでのAPIと同じです。(🔗 nextjs.org)

今回のAPI契約を整理する

操作成功主な失敗
一覧取得200、{ notes }500
新規作成201、{ message, note }400、415、422、500
更新200、{ message, note }400、404、415、422、500
削除200、{ message, deletedNoteId }400、404、500

すべてのAPIで、開発環境以外は403です。

今回はメモに関連テーブルを作っていないため、外部キーによる削除拒否の処理は追加していません。

API単体で動作確認する

画面を作る前に、APIだけで確認します。

# 開発サーバーを起動します
npm run dev
Bash

メモを作成する

# ダミーのメモを1件作成します
curl -i "http://localhost:3000/api/notes" \
  -X POST \
  -H 'Content-Type: application/json' \
  --data '{"title":"最初のメモ","content":"CRUDの動作を確認します。"}'
Bash

返されたnote.idを確認します。

一覧を取得する

# 保存したメモが含まれるか確認します
curl -i "http://localhost:3000/api/notes"
Bash

更新する

以下は、作成されたIDが1だった場合の例です。実際に返されたIDへ変更します。

# 編集対象の全項目を送ります
curl -i "http://localhost:3000/api/notes/1" \
  -X PUT \
  -H 'Content-Type: application/json' \
  --data '{"title":"更新したメモ","content":"内容を書き換えました。"}'
Bash

削除する

# 確認用に作成した対象だけを削除します
curl -i "http://localhost:3000/api/notes/1" \
  -X DELETE
Bash

Windowsのシェルなどでは、引用符や改行方法を環境に合わせて調整してください。

CRUDをひとつの画面へまとめる

ここからが総合演習の中心です。

ひとつのフォームを、新規作成と編集で使い分けます。

編集対象のIDでモードを判断する

今回のフォームでは、editingIdを使います。

editingId画面の状態保存時の処理
null新規作成POST
数値編集PUT

編集中のメモを削除した場合は、フォームも新規作成状態へ戻します。

また、一覧の再取得だけでは、入力中のフォームを勝手に書き換えない方針にします。

メモ管理コンポーネントを作る

少し長いコードですが、役割は次の4つです。

  • フォーム入力を管理します。
  • APIへリクエストします。
  • 一覧を再取得します。
  • 成功・失敗・通信中を表示します。

src/components/notes/NotesApp.tsx

"use client";

import { useRef, useState } from "react";
import type { FormEvent } from "react";
import type { NoteItem } from "../../types/note";

// JSONオブジェクトかを確認します
function isRecord(
  value: unknown,
): value is Record<string, unknown> {
  return (
    typeof value === "object" &&
    value !== null &&
    !Array.isArray(value)
  );
}

// APIが返したメモの形を確認します
function isNoteItem(value: unknown): value is NoteItem {
  return (
    isRecord(value) &&
    typeof value.id === "number" &&
    Number.isSafeInteger(value.id) &&
    value.id > 0 &&
    typeof value.title === "string" &&
    typeof value.content === "string"
  );
}

// HTTP結果とJSONの基本形を確認する共通処理です
async function requestJson(
  url: string,
  options: RequestInit = {},
): Promise<Record<string, unknown>> {
  let response: Response;

  try {
    response = await fetch(url, {
      ...options,
      cache: "no-store",
    });
  } catch {
    throw new Error(
      "通信結果を確認できません。最新一覧を確認してから再操作してください。",
    );
  }

  const payload: unknown = await response
    .json()
    .catch(() => null);

  if (!response.ok) {
    const message =
      isRecord(payload) &&
      typeof payload.message === "string"
        ? payload.message
        : "処理を完了できませんでした。";

    throw new Error(message);
  }

  if (!isRecord(payload)) {
    throw new Error(
      "応答形式を確認できません。最新一覧を確認してください。",
    );
  }

  return payload;
}

// 利用者向けのメッセージへ変換します
function getErrorMessage(error: unknown): string {
  return error instanceof Error
    ? error.message
    : "処理を完了できませんでした。";
}

type NotesAppProps = {
  initialNotes: NoteItem[];
};

export default function NotesApp({
  initialNotes,
}: NotesAppProps) {
  // 一覧は初期表示後、このStateをGET結果で更新します
  const [notes, setNotes] = useState(initialNotes);

  // 新規作成と編集で共用するフォームです
  const [editingId, setEditingId] = useState<number | null>(
    null,
  );
  const [title, setTitle] = useState("");
  const [content, setContent] = useState("");

  const [busy, setBusy] = useState(false);
  const busyRef = useRef(false);

  const [success, setSuccess] = useState("");
  const [error, setError] = useState("");

  // 再描画前の短い間隔の連続実行も抑えます
  function beginOperation(): boolean {
    if (busyRef.current) {
      return false;
    }

    busyRef.current = true;
    setBusy(true);
    setSuccess("");
    setError("");
    return true;
  }

  function endOperation() {
    busyRef.current = false;
    setBusy(false);
  }

  function resetEditor() {
    setEditingId(null);
    setTitle("");
    setContent("");
  }

  // GET APIで最新の一覧を取得します
  async function reloadNotes() {
    const payload = await requestJson("/api/notes");

    if (
      !Array.isArray(payload.notes) ||
      !payload.notes.every(isNoteItem)
    ) {
      throw new Error("一覧データの形式が正しくありません。");
    }

    setNotes(payload.notes);
  }

  // 保存成功と、その後の一覧取得失敗を分けます
  async function reloadAfterMutation() {
    try {
      await reloadNotes();
    } catch {
      setError(
        "変更は完了しましたが、一覧を更新できませんでした。" +
          "「一覧を更新する」で再確認してください。",
      );
    }
  }

  async function handleReload() {
    if (!beginOperation()) return;

    try {
      await reloadNotes();
      setSuccess("一覧を更新しました。");
    } catch (error) {
      setError(getErrorMessage(error));
    } finally {
      endOperation();
    }
  }

  // 編集ボタンで、選んだメモをフォームへ読み込みます
  function startEditing(note: NoteItem) {
    if (busyRef.current) return;

    setEditingId(note.id);
    setTitle(note.title);
    setContent(note.content);
    setSuccess("");
    setError("");
  }

  // 作成と更新を、編集IDの有無で切り替えます
  async function handleSave(
    event: FormEvent<HTMLFormElement>,
  ) {
    event.preventDefault();

    if (!beginOperation()) return;

    const isEditing = editingId !== null;

    try {
      await requestJson(
        isEditing
          ? `/api/notes/${editingId}`
          : "/api/notes",
        {
          method: isEditing ? "PUT" : "POST",
          headers: {
            "Content-Type": "application/json",
          },
          body: JSON.stringify({ title, content }),
        },
      );

      setSuccess(
        isEditing
          ? "メモを更新しました。"
          : "メモを作成しました。",
      );

      // 変更処理に成功した場合だけフォームを初期化します
      resetEditor();

      // この取得の失敗を、保存失敗とは案内しません
      await reloadAfterMutation();
    } catch (error) {
      // 保存失敗時は、入力内容を残します
      setError(getErrorMessage(error));
    } finally {
      endOperation();
    }
  }

  async function handleDelete(note: NoteItem) {
    if (busyRef.current) return;

    const confirmed = window.confirm(
      `「${note.title}」(ID: ${note.id})を削除しますか?\n` +
        "この画面からは元に戻せません。",
    );

    if (!confirmed || !beginOperation()) return;

    try {
      await requestJson(`/api/notes/${note.id}`, {
        method: "DELETE",
      });

      // 編集していたメモを削除したら、編集状態も解除します
      if (editingId === note.id) {
        resetEditor();
      }

      setSuccess("メモを削除しました。");
      await reloadAfterMutation();
    } catch (error) {
      setError(getErrorMessage(error));
    } finally {
      endOperation();
    }
  }

  return (
    <div>
      <section aria-labelledby="note-form-heading">
        <h2 id="note-form-heading">
          {editingId === null
            ? "新しいメモ"
            : `メモを編集する:ID ${editingId}`}
        </h2>

        <form onSubmit={handleSave}>
          <fieldset disabled={busy}>
            <legend>メモの内容</legend>

            <p>
              <label htmlFor="note-title">タイトル</label>
              <br />
              <input
                id="note-title"
                name="title"
                required
                maxLength={80}
                value={title}
                onChange={(event) =>
                  setTitle(event.target.value)
                }
              />
            </p>

            <p>
              <label htmlFor="note-content">本文</label>
              <br />
              <textarea
                id="note-content"
                name="content"
                rows={6}
                maxLength={5000}
                value={content}
                onChange={(event) =>
                  setContent(event.target.value)
                }
              />
            </p>

            <button type="submit">
              {editingId === null
                ? "作成する"
                : "変更を保存する"}
            </button>{" "}

            {editingId !== null && (
              <button
                type="button"
                onClick={resetEditor}
              >
                編集をキャンセルする
              </button>
            )}
          </fieldset>
        </form>
      </section>

      {busy && (
        <p role="status">処理しています。</p>
      )}

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

      {error && (
        <p role="alert">{error}</p>
      )}

      <section aria-labelledby="note-list-heading">
        <h2 id="note-list-heading">保存済みのメモ</h2>

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

        <button
          type="button"
          onClick={handleReload}
          disabled={busy}
        >
          一覧を更新する
        </button>

        {notes.length === 0 ? (
          <p>メモはまだありません。</p>
        ) : (
          <ul>
            {notes.map((note) => (
              <li key={note.id}>
                <article>
                  <h3>{note.title}</h3>

                  {/* 本文はHTMLとして解釈させず表示します */}
                  <p style={{ whiteSpace: "pre-wrap" }}>
                    {note.content || "本文はありません。"}
                  </p>

                  <p>ID:{note.id}</p>

                  <button
                    type="button"
                    onClick={() => startEditing(note)}
                    disabled={busy}
                    aria-label={`${note.title}を編集する`}
                  >
                    編集する
                  </button>{" "}

                  <button
                    type="button"
                    onClick={() => handleDelete(note)}
                    disabled={busy}
                    aria-label={`${note.title}を削除する`}
                  >
                    削除する
                  </button>
                </article>
              </li>
            ))}
          </ul>
        )}
      </section>
    </div>
  );
}
TSX

画面コードの重要部分を読み解く

新規作成と編集で同じフォームを使う

保存時の分岐は、次の部分です。

// 編集対象がなければ作成、あれば更新します
const isEditing = editingId !== null;
TypeScript

フォームの入力項目は同じなので、操作の目的だけを切り替えています。

  • 新規作成ではPOSTを送ります。
  • 編集では対象ID付きのURLへPUTを送ります。
  • 成功したら新規作成状態へ戻します。
  • 失敗したら入力内容を残します。

編集ボタンを押すと、現在入力中の値は選んだメモで置き換わります。今回の学習版ではその仕様にしていますが、実際のアプリでは未保存変更の破棄確認も検討します。

変更成功と一覧取得失敗を区別する

今回、特に重要なのが次の流れです。

POSTでDB保存に成功
    ↓
成功を案内する
    ↓
GETで一覧を再取得
    ↓
GETだけ失敗したら
「変更は完了したが、一覧更新は失敗」と案内する

すべてを同じ失敗として扱うと、すでに作成済みなのに利用者が再送して、同じメモを増やす原因になります。

今回のメモにはタイトルの一意制約がないため、同じ内容での作成を繰り返せば、複数のメモができます。

通信が切れた場合は、保存結果が不明なこともある

サーバーが保存した後、応答が届く前に通信が切れる可能性があります。

そのため、通信例外の案内では、「保存されなかった」と断定しません。まず一覧を取得して状態を確かめるようにします。

処理中はほかの操作を止める

今回は、保存・削除・再取得のいずれかを実行中なら、ほかの操作を無効化します。

これは、複数の応答が異なる順番で返り、古い一覧で上書きされるような複雑さを、学習段階で増やさないための方針です。

ただし、別タブや別利用者からの更新まで止める仕組みではありません。

メモ管理ページを作る

初回の一覧は、Server Componentから取得します。

src/app/notes/page.tsx

import type { Metadata } from "next";
import NotesApp from "../../components/notes/NotesApp";
import { getNotes } from "../../services/note.service";

export const runtime = "nodejs";

// 今回はリクエスト時にDBを読み取ります
// cacheComponentsを有効にしていない構成が前提です
export const dynamic = "force-dynamic";

export const metadata: Metadata = {
  title: "メモ管理",
  description: "CRUDを学ぶローカル用メモ管理アプリです。",
};

export default async function NotesPage() {
  // APIだけでなく、初回表示も開発環境へ制限します
  if (process.env.NODE_ENV !== "development") {
    return (
      <section>
        <h1>メモ管理</h1>
        <p>このページはローカル学習用です。</p>
      </section>
    );
  }

  const notes = await getNotes();

  return (
    <section>
      <h1>メモ管理アプリ</h1>

      <p>
        ダミーデータを使って、作成・取得・更新・削除を練習します。
      </p>

      <NotesApp initialNotes={notes} />
    </section>
  );
}
TSX

APIを制限していても、ページがDBから直接表示すれば、そのページ側の公開範囲も考える必要があります。

今回は、初回表示も開発環境だけにしています。

初回読み込みと初回エラーを用意する

ボタン操作中の表示はClient Componentで扱っています。

それとは別に、最初のページ表示でDB取得を待つ場合と、取得に失敗した場合のUIを用意します。

src/app/notes/loading.tsx

// 初回表示でメモ取得を待つ間の案内です
export default function Loading() {
  return (
    <section>
      <h1>メモを読み込んでいます</h1>
      <p role="status">しばらくお待ちください。</p>
    </section>
  );
}
TSX

src/app/notes/error.tsx

"use client";

// 初回描画などで発生した予期しないエラーを案内します
export default function NotesError() {
  return (
    <section>
      <h1>メモを表示できませんでした</h1>

      <p role="alert">
        データベースの接続状態を確認してください。
      </p>

      <button
        type="button"
        onClick={() => window.location.reload()}
      >
        ページを再読み込みする
      </button>
    </section>
  );
}
TSX

初回表示の失敗と、保存ボタンを押した後の失敗は、同じ場所で処理しません。後者は、今回のNotesAppがAPIの結果を確認して案内します。

画面を開いて一連の操作を確認する

開発サーバーを起動し、次のURLを開きます。

# 開発環境で起動します
npm run dev
Bash
http://localhost:3000/notes

ひとつのメモでCRUDを確認する

  • タイトルと本文を入力して作成します。
  • 一覧に作成したメモが出ることを確認します。
  • 編集ボタンを押し、フォームへ内容が入ることを確認します。
  • タイトルと本文を変更して保存します。
  • 一覧が更新されることを確認します。
  • 削除ボタンを押し、まずキャンセルします。
  • メモが残ることを確認します。
  • 再度削除し、一覧から消えることを確認します。

作成した直後と、更新・削除した直後の画面を確認するだけでなく、ブラウザーを再読み込みしてもDBの状態と一致するか確かめます。

総合演習で確認したい重要なケース

ケース操作期待する結果
初期状態空の学習用DBで開く未登録の案内
作成正常なタイトルと本文一覧へ追加
本文なし本文を空にして作成作成できる
空白タイトル空白だけで送信422、保存しない
長すぎる本文APIへ5,001文字以上を送信422
編集キャンセル編集後にキャンセルDBは変わらない
更新タイトルと本文を変更同じIDのメモが変わる
削除キャンセル確認で中止DELETEを送らない
削除確認して実行一覧から消える
未存在削除済みIDを更新・削除404
再起動サーバーを停止・再起動保存済みデータが残る
51件以上多数のダミーメモを登録最大50件だけ表示

最大50件は、DBに保存できる総数の制限ではありません。

51件以上になったら、表示対象外のメモも存在します。すべてを閲覧できるアプリへ発展させるには、ページネーションなどを追加します。

動作確認のためのCSSについて

今回のコードは、見た目よりCRUDの完成を優先しています。最低限読みやすくする場合は、既存のglobals.cssへ次のような調整を追加できます。

/* 入力欄を親要素からはみ出しにくくします */
input,
textarea {
  max-width: 100%;
  font: inherit;
}

/* フォームの入力幅をそろえます */
input,
textarea {
  width: min(100%, 40rem);
  padding: 0.6rem;
}

/* 長いタイトルや本文の折り返しを許可します */
article {
  overflow-wrap: anywhere;
}

/* キーボード操作中の位置を見やすくします */
button:focus-visible,
input:focus-visible,
textarea:focus-visible {
  outline: 3px solid #d97706;
  outline-offset: 3px;
}

/* 通信中の操作不可状態を表します */
button:disabled {
  opacity: 0.6;
  cursor: wait;
}

既存CSSとの組み合わせで、ほかのページへも影響する点を確認します。必要になった段階で、CSS Modulesなどを使ってメモ画面へ適用範囲を絞ります。

よくある失敗を整理する

DB保存とState更新を混同する

Stateを変更するだけでは、今回のSQLiteへの保存は行われません。

反対に、DBを変更しただけでは、Client Componentが持っている一覧のStateは自動で置き換わりません。

今回の設計では、次の2段階です。

APIでDBを変更する
    ↓
GETで最新一覧を取得してStateを更新する

作成と更新で送信先を間違える

新規作成のつもりで編集IDを残すと、既存メモを更新してしまいます。

そのため、成功後と編集キャンセル時には、editingId、タイトル、本文をまとめてリセットします。

編集中のメモを削除した後も編集IDが残る

削除したIDがフォームに残ると、次の保存で404になる原因になります。

今回は、削除対象が編集中のIDと同じなら、フォームを初期化しています。

一覧取得失敗を空配列へ変えない

DBエラーや通信失敗を、何でも[]へ変えると、「メモが全部なくなった」と誤解される可能性があります。

今回の再取得では、失敗したときにsetNotes([])を呼ばず、前の一覧とエラー案内を残します。ただし、その一覧は古い可能性があるため、再確認を促します。

セキュリティとデータ整合性を深掘りする

メモは個人情報や秘密情報になり得る

ユーザー名だけの一覧よりも、自由入力のメモ本文には、意図せず秘密情報が含まれる可能性があります。

今回のローカル版を、そのままインターネットへ公開しないでください。

公開する際は、利用者を識別し、メモの所有者を保存し、取得・更新・削除のすべてで対象へのアクセス権限を確認する設計が必要です。認証と認可は別々の確認です。(🔗 nextjs.org)

ownerIdを追加するだけでは保護にならない

将来、メモへ所有者を追加しても、ブラウザーから送られた所有者IDをそのまま信用してはいけません。

ログイン済みの利用者をサーバー側で確認し、その利用者のメモだけを操作できる条件にします。

一覧だけを絞り込み、更新・削除ではIDだけを見ている、という不一致も避けます。(🔗 nextjs.org)

本文をHTMLとして表示しない

今回は、本文を次のように文字列で表示しています。

// 本文を文字列として表示し、改行だけCSSで保持します
<p style={{ whiteSpace: "pre-wrap" }}>
  {note.content}
</p>
TSX

メモへ装飾を付けたいという理由だけで、未検証の本文をHTMLとして挿入する設計へ変えないようにします。

同時編集への対策は未実装

今回のアプリでは、別タブで同じメモを編集すると、後から保存した値で上書きされる可能性があります。

更新日時があるだけでは競合を防げない

updatedAtを保存していますが、今回の更新条件には使っていません。

そのため、更新日時を持たせただけで競合対策が完成したとは考えません。

発展として考えること

バージョン番号などを使い、「自分が読み取った時点から変わっていない場合だけ更新する」仕組みを検討します。

今回の到達点

CRUDの基本動作と、競合を防ぐ仕組みは別の段階です。 今回のコードが何を保証し、何を保証していないかを説明できることも、総合演習の成果です。

型チェックと本番ビルドを確認する

# Prisma Clientを生成します
npx prisma generate

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

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

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

今回のアプリは、本番起動ではメモ画面を学習用案内に切り替え、APIは403を返します。

これは意図した制限です。公開するときは、この制限を削除するだけで済ませず、認証・認可、本文サイズ制限、不正利用対策、保存先やバックアップの方針などを追加します。

自力で取り組む発展課題

検索機能を追加する

タイトルでメモを検索できるようにします。

  • 画面の表示済み50件だけを検索するのか、DB全体を検索するのか決めます。
  • APIへ条件を渡す場合は、キーワードの長さを制限します。
  • 検索結果0件と取得失敗を区別します。

作成日時と更新日時を表示する

APIと画面に必要な日時を追加します。

その際は、DBの日時型をAPIでどのような文字列として返すか、画面でどのタイムゾーン・形式で表示するかを決めます。

未保存変更の確認を追加する

編集途中で別のメモを選んだ場合に、そのまま入力を破棄してよいか確認します。

保存済みの値と現在の入力値を、どう比較するか考えます。

ページネーションを追加する

50件を超えたメモも閲覧できるようにします。

取得件数だけでなく、並び順、次ページの指定方法、追加・削除後の表示方針も合わせて決めます。

Day 58のチェックリスト

  • Noteモデルを追加し、Migrationを適用できました。
  • POSTでメモを作成できます。
  • GETでメモ一覧を取得できます。
  • PUTで同じIDのメモを更新できます。
  • DELETEで指定したメモを削除できます。
  • 新規作成と編集を、ひとつのフォームで切り替えられます。
  • 失敗時に入力値を残せます。
  • 削除前に対象を確認できます。
  • 変更成功と一覧更新失敗を区別できます。
  • 通信中の連続操作を抑えられます。
  • 再読み込み・再起動後も、DBの状態と表示が一致します。
  • 認証や同時編集対策が未実装だと説明できます。

まとめ

Day 58では、メモの作成・取得・更新・削除を、ひとつの画面とデータベースへつなげました。

今回の中心は、DB操作、APIの契約、フォームの状態、一覧の更新を分けながら連携させることです。特に、保存の成功と一覧更新の失敗を混同しないこと、編集IDを適切に管理すること、削除後のフォーム状態まで整えることが、総合演習ならではの重要点です。

CRUDをひととおり実装できたら、次はコードを見ずに処理の流れを説明してみます。「ボタンを押してから、どのファイルを通り、どこへ保存され、どう画面へ戻るのか」を説明できれば、別の題材でもCRUDアプリを組み立てる力につながります。

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