MENU

問い合わせ

    お問い合わせ


    【Honoで作る社内ヘルプデスク 第8回】管理画面をHonoのJSXで作る:サーバー側描画とフォーム、CSRF対策

    ここまでの社内ヘルプデスクは、API(プログラムから呼ぶ窓口)だけでした。担当者が毎日使うには、ブラウザで開ける管理画面が必要です。

    「社内ツールの管理画面に、わざわざ別のフロントエンドを作る必要はある?API と同じ仕組みの中で、手早く安全に画面を作れないの?」

    結論から言うと、Hono の JSX でサーバー側に HTML を作って返し、操作は HTML のフォームで送る形にすると、追加のライブラリなしで管理画面が作れます。その代わり、フォームを使う画面では CSRF(クロスサイト・リクエスト・フォージェリ。ほかのサイトから、ログイン中の人の名前で操作を送らせる攻撃)への対策が必須になります。この回では、Hono の CSRF 対策のミドルウェア(処理の前後に差し込む共通の部品)を使います。

    前回は、対応期限(SLA)を過ぎたチケットを Cron Triggers で見つけて知らせる仕組みを作りました。まだの方は先にご覧ください。

    詳しくは前回の記事で解説しています。

    新しいライブラリのインストールは不要です。JSX も CSRF 対策も hono に含まれています。

    目次

    管理画面をサーバー側描画にする理由

    画面の作り方には、大きく2つあります。

    作り方仕組み向いている場面
    サーバー側描画(SSR)サーバーが HTML を作って返す。操作はフォームの送信で、そのたびに画面が切り替わる社内の管理画面、入力と一覧が中心の画面
    ブラウザ側描画(SPA)最初に JavaScript を読み込み、画面はブラウザで組み立てる。データは API から取る画面の一部だけを頻繁に書き換える、操作の多い画面

    この管理画面は「一覧 → 詳細 → 状態を変える」が中心なので、サーバー側描画で十分です。画面と API が同じ Worker に入り、ログインの Cookie(第3回)もルールの関数もそのまま使えます。また、スクリプトを1行も使わないので、スクリプトの実行を禁じるヘッダーを付けて XSS(クロスサイト・スクリプティング。画面に悪意のあるスクリプトを埋め込む攻撃)の被害を抑えられます。

    Hono の JSX は、React と同じ書き方でサーバー側に HTML を組み立てる仕組みで、ブラウザに送るのは普通の HTML だけです。{ } で埋め込んだ値は自動でエスケープ(< を &lt; にするなど、HTML として解釈されない形に変えること)されます。

    📰 出典:Hono「JSX」

    この回で作るものの全体像

    1. tsconfig.json で JSX を Hono 向けに設定する
    2. 状態の変更を src/ticket-service.ts にまとめ、API と画面の両方から使う
    3. ログインの確認を「API 向け(401 を返す)」と「画面向け(ログイン画面へ移す)」に分けられる形にする
    4. 画面の共通の枠と見た目(src/admin/)を作る
    5. 管理画面のルート(src/routes/admin.tsx)を作り、CSRF 対策と安全のためのヘッダーを付ける
    6. テストで、権限・エスケープ・CSRF・同時更新を確かめる

    画面はログイン・一覧・詳細の3つで、担当者・管理者だけが使えます。

    1. JSX を Hono 向けに設定する

    TypeScript に「JSX は Hono の仕組みで変換する」と伝えます。Wrangler もこの設定を読んで .tsx を変換します。

    tsconfig.json に次の変更を加えます(+ が追加、- が削除)。

    --- a/tsconfig.json
    +++ b/tsconfig.json
    @@ -6,6 +6,8 @@
         "strict": true,
         "noEmit": true,
         "skipLibCheck": true,
    +    "jsx": "react-jsx",
    +    "jsxImportSource": "hono/jsx",
         "types": ["./worker-configuration.d.ts", "@cloudflare/vitest-plugin/types"]
       },
       "include": ["src", "test", "worker-configuration.d.ts"]

    📰 出典:Hono「JSX – Settings」

    2. 状態の変更を API と画面で共通にする

    第2回の「状態を変える」処理を、画面からも使えるよう関数に切り出します。ルールが2か所に分かれると、片方だけ直して食い違いやすいためです。

    画面から使うときのために、expected(画面で見ていた状態)を受け取れるようにしました。画面を開いているあいだにほかの人が状態を変えていたら、変更せずに知らせます。

    // src/ticket-service.ts
    // チケットの状態の変更。API(JSON)と管理画面(フォーム)の両方から呼ぶので、ルールを1か所にまとめる
    import { canTransition, type Status } from './status'
    
    export type ChangeStatusResult =
      | { ok: true; ticket: { id: number; status: Status; updated_at: string } }
      | { ok: false; error: 'not_found' | 'conflict' }
      | { ok: false; error: 'invalid_transition'; from: Status; to: Status }
    
    // expected を渡すと「画面で見ていた状態」と今の状態が違うときに conflict にする(古い画面からの上書きを防ぐ)
    export const changeStatus = async (
      db: D1Database,
      input: { id: number; next: Status; actor: string; expected?: Status },
    ): Promise<ChangeStatusResult> => {
      const { id, next, actor, expected } = input
      const current = await db.prepare('SELECT status FROM tickets WHERE id = ?').bind(id).first<{ status: Status }>()
      if (!current) return { ok: false, error: 'not_found' }
      if (expected && expected !== current.status) return { ok: false, error: 'conflict' }
      if (!canTransition(current.status, next)) {
        return { ok: false, error: 'invalid_transition', from: current.status, to: next }
      }
    
      // 「読んだときの状態のまま」のときだけ更新する。同時に別の人が変えていたら 0 件になる。
      // 更新できたときだけ(changes() = 1)、同じトランザクションで履歴を1行足す
      const [result] = await db.batch([
        db
          .prepare(
            `UPDATE tickets
             SET status = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%SZ', 'now')
             WHERE id = ? AND status = ?
             RETURNING id, status, updated_at`,
          )
          .bind(next, id, current.status),
        db
          .prepare(
            `INSERT INTO ticket_events (ticket_id, actor, type, from_value, to_value)
             SELECT ?, ?, 'status_changed', ?, ? WHERE changes() = 1`,
          )
          .bind(id, actor, current.status, next),
      ])
      const updated = result!.results[0] as { id: number; status: Status; updated_at: string } | undefined
      if (!updated) return { ok: false, error: 'conflict' }
      return { ok: true, ticket: updated }
    }

    API のルートは、この関数を呼ぶだけにします。応答の形(404・409 など)は第2回から変わりません。

    src/routes/tickets.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/src/routes/tickets.ts
    +++ b/src/routes/tickets.ts
    @@ -3,7 +3,7 @@ import { Hono } from 'hono'
     import { requireLogin, requireRole, type AppEnv } from '../auth'
     import { changeStatusSchema, createTicketSchema, listQuerySchema } from '../schemas'
     import { enqueueNotification } from '../notify'
    -import { canTransition, type Status } from '../status'
    +import { changeStatus } from '../ticket-service'
    
     export const tickets = new Hono<AppEnv>()
    
    @@ -100,33 +100,16 @@ tickets.patch(
         if (!result.success) return c.json({ error: 'invalid_request' }, 400)
       }),
       async (c) => {
    -    const id = Number(c.req.param('id'))
    -    const { status: next } = c.req.valid('json')
    -
    -    const current = await c.env.DB.prepare('SELECT status FROM tickets WHERE id = ?')
    -      .bind(id)
    -      .first<{ status: Status }>()
    -    if (!current) return c.json({ error: 'not_found' }, 404)
    -    if (!canTransition(current.status, next)) {
    -      return c.json({ error: 'invalid_transition', from: current.status, to: next }, 409)
    +    const result = await changeStatus(c.env.DB, {
    +      id: Number(c.req.param('id')),
    +      next: c.req.valid('json').status,
    +      actor: c.get('user').email,
    +    })
    +    if (result.ok) return c.json(result.ticket)
    +    if (result.error === 'not_found') return c.json({ error: 'not_found' }, 404)
    +    if (result.error === 'invalid_transition') {
    +      return c.json({ error: 'invalid_transition', from: result.from, to: result.to }, 409)
         }
    -
    -    // 「読んだときの状態のまま」のときだけ更新する。同時に別の人が変えていたら 0 件になる。
    -    // 更新できたときだけ(changes() = 1)、同じトランザクションで履歴を1行足す
    -    const [result] = await c.env.DB.batch([
    -      c.env.DB.prepare(
    -        `UPDATE tickets
    -         SET status = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%SZ', 'now')
    -         WHERE id = ? AND status = ?
    -         RETURNING id, status, updated_at`,
    -      ).bind(next, id, current.status),
    -      c.env.DB.prepare(
    -        `INSERT INTO ticket_events (ticket_id, actor, type, from_value, to_value)
    -         SELECT ?, ?, 'status_changed', ?, ? WHERE changes() = 1`,
    -      ).bind(id, c.get('user').email, current.status, next),
    -    ])
    -    const updated = result!.results[0]
    -    if (!updated) return c.json({ error: 'conflict' }, 409)
    -    return c.json(updated)
    +    return c.json({ error: 'conflict' }, 409)
       },
     )

    3. ログインの確認を画面からも使えるようにする

    第3回の requireLogin は未ログインだと JSON の 401 を返します。画面ではログイン画面へ移したいので、「Cookie を確かめて利用者を引く」部分を loadSessionUser として切り出します。

    src/auth.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/src/auth.ts
    +++ b/src/auth.ts
    @@ -1,3 +1,4 @@
    +import type { Context } from 'hono'
     import { createMiddleware } from 'hono/factory'
     import { deleteCookie, getCookie, setCookie } from 'hono/cookie'
     import { sign, verify } from 'hono/jwt'
    @@ -27,22 +28,25 @@ export const startSession = async (c: Parameters<typeof setCookie>[0], secret: s
     export const endSession = (c: Parameters<typeof deleteCookie>[0]) => deleteCookie(c, COOKIE, { path: '/' })
    
     // 印を確かめ、そのたびに DB から最新の利用者情報を引く。
    -// 退職・停止(active=0)や権限変更が、次のリクエストからすぐ効くようにするため
    -export const requireLogin = createMiddleware<AppEnv>(async (c, next) => {
    +// 退職・停止(active=0)や権限変更が、次のリクエストからすぐ効くようにするため。
    +// ログインしていなければ null(API は 401、管理画面はログイン画面へ移す、と呼び出し側で分ける)
    +export const loadSessionUser = async (c: Context<AppEnv>): Promise<SessionUser | null> => {
       const token = getCookie(c, COOKIE)
    -  if (!token) return c.json({ error: 'unauthorized' }, 401)
    +  if (!token) return null
       let userId: number
       try {
         const payload = await verify(token, c.env.SESSION_SECRET, 'HS256')
         userId = Number(payload.sub)
       } catch {
    -    return c.json({ error: 'unauthorized' }, 401)
    +    return null
       }
    -  const user = await c.env.DB.prepare(
    -    'SELECT id, email, name, role FROM users WHERE id = ? AND active = 1',
    -  )
    +  return c.env.DB.prepare('SELECT id, email, name, role FROM users WHERE id = ? AND active = 1')
         .bind(userId)
         .first<SessionUser>()
    +}
    +
    +export const requireLogin = createMiddleware<AppEnv>(async (c, next) => {
    +  const user = await loadSessionUser(c)
       if (!user) return c.json({ error: 'unauthorized' }, 401)
       c.set('user', user)
       await next()

    ログインの入力チェックとパスワードの確認も、ログインフォームから使えるように切り出します。

    src/routes/auth.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/src/routes/auth.ts
    +++ b/src/routes/auth.ts
    @@ -1,12 +1,13 @@
     import { zValidator } from '@hono/zod-validator'
     import { Hono } from 'hono'
     import { z } from 'zod'
    -import { endSession, requireLogin, startSession, type AppEnv } from '../auth'
    +import { endSession, requireLogin, startSession, type AppEnv, type Role } from '../auth'
     import { verifyPassword } from '../password'
    
     export const auth = new Hono<AppEnv>()
    
    -const loginSchema = z.object({
    +// 管理画面のログインフォームでも同じ入力チェックを使う
    +export const loginSchema = z.object({
       email: z.string().trim().toLowerCase().email().max(254),
       password: z.string().min(1).max(200),
     })
    @@ -14,6 +15,18 @@ const loginSchema = z.object({
     // 存在しないメールのときも同じ重さの計算をして、応答時間で「登録の有無」が分からないようにする
     const DUMMY_HASH = 'pbkdf2$100000$AAAAAAAAAAAAAAAAAAAAAA==$AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA='
    
    +// メールとパスワードを確かめ、正しければ利用者を返す(API と管理画面のログインで共通)
    +export const checkCredentials = async (env: Env, email: string, password: string) => {
    +  const row = await env.DB.prepare(
    +    'SELECT id, email, name, role, password_hash FROM users WHERE email = ? AND active = 1',
    +  )
    +    .bind(email)
    +    .first<{ id: number; email: string; name: string; role: Role; password_hash: string }>()
    +  const ok = await verifyPassword(password, row?.password_hash ?? DUMMY_HASH)
    +  if (!row || !ok) return null
    +  return { id: row.id, email: row.email, name: row.name, role: row.role }
    +}
    +
     auth.post(
       '/login',
       zValidator('json', loginSchema, (result, c) => {
    @@ -21,18 +34,12 @@ auth.post(
       }),
       async (c) => {
         const { email, password } = c.req.valid('json')
    -    const row = await c.env.DB.prepare(
    -      'SELECT id, email, name, role, password_hash FROM users WHERE email = ? AND active = 1',
    -    )
    -      .bind(email)
    -      .first<{ id: number; email: string; name: string; role: string; password_hash: string }>()
    -
    -    const ok = await verifyPassword(password, row?.password_hash ?? DUMMY_HASH)
    +    const user = await checkCredentials(c.env, email, password)
         // 「メールが違う」「パスワードが違う」を区別せず、同じ文言で返す
    -    if (!row || !ok) return c.json({ error: 'invalid_credentials' }, 401)
    +    if (!user) return c.json({ error: 'invalid_credentials' }, 401)
    
    -    await startSession(c, c.env.SESSION_SECRET, row.id)
    -    return c.json({ id: row.id, email: row.email, name: row.name, role: row.role })
    +    await startSession(c, c.env.SESSION_SECRET, user.id)
    +    return c.json(user)
       },
     )
    

    4. 画面の共通の枠と見た目を作る

    共通の枠(レイアウト)

    jsxRenderer は、全画面に共通する <html>・<head>・上部のバーを持つミドルウェアです。各画面は c.render(中身, { title, user }) で中身だけを返します。declare module 'hono' は、c.render の2つ目の引数の型を TypeScript に教える書き方です。

    📰 出典:Hono「JSX Renderer Middleware」

    // src/admin/layout.tsx
    // 管理画面の共通の枠(HTML の head・上部のバー・ログアウト)。jsxRenderer に渡し、各画面は c.render() で中身だけ返す
    import { jsxRenderer } from 'hono/jsx-renderer'
    import type { SessionUser } from '../auth'
    
    // c.render(中身, { title, user }) の2つ目の引数の型を決める(Hono の ContextRenderer を広げる)
    declare module 'hono' {
      interface ContextRenderer {
        (content: string | Promise<string>, props: { title: string; user?: SessionUser }): Response | Promise<Response>
      }
    }
    
    export const renderer = jsxRenderer(({ children, title, user }) => (
      <html lang="ja">
        <head>
          <meta charset="utf-8" />
          <meta name="viewport" content="width=device-width, initial-scale=1" />
          <title>{`${title}|社内ヘルプデスク 管理画面`}</title>
          <link rel="stylesheet" href="/admin/admin.css" />
        </head>
        <body>
          <header class="top-app-bar">
            <h1>社内ヘルプデスク</h1>
            {user && (
              <form method="post" action="/admin/logout">
                <span>{user.name}さん</span>{' '}
                <button type="submit" class="button text">
                  ログアウト
                </button>
              </form>
            )}
          </header>
          <main>{children}</main>
        </body>
      </html>
    ))

    ログアウトも、リンク(GET)ではなくフォームの POST にしています。

    見た目(CSS)

    見た目は Google のデザインの決まり Material 3 の色の役割(color roles)・角の丸み・8dp 刻みの余白に合わせ、色は基本の1色から material-color-utilities で明るい配色と暗い配色を作りました。CSS は、後で付ける CSP(後述)を緩めずに済むよう、別のファイルとして配信します。

    <details> <summary>src/admin/styles.ts の全文</summary>

    // src/admin/styles.ts
    // 管理画面の見た目。Material 3 の色の役割(color roles)・角の丸み(shape)・8dp 刻みの余白に合わせる。
    // 色は基本色 #1F5FA8 から material-color-utilities(Material の配色の仕組み)で作った明るい配色と暗い配色
    export const css = `
    :root {
      color-scheme: light dark;
      --md-sys-color-primary: #3d5f90;
      --md-sys-color-on-primary: #ffffff;
      --md-sys-color-primary-container: #d5e3ff;
      --md-sys-color-on-primary-container: #234777;
      --md-sys-color-secondary-container: #d9e3f8;
      --md-sys-color-on-secondary-container: #3d4758;
      --md-sys-color-tertiary-container: #f8d8fe;
      --md-sys-color-on-tertiary-container: #553f5d;
      --md-sys-color-error: #ba1a1a;
      --md-sys-color-error-container: #ffdad6;
      --md-sys-color-on-error-container: #93000a;
      --md-sys-color-surface: #f9f9ff;
      --md-sys-color-on-surface: #191c20;
      --md-sys-color-on-surface-variant: #43474e;
      --md-sys-color-surface-container-low: #f3f3fa;
      --md-sys-color-surface-container: #ededf4;
      --md-sys-color-surface-container-high: #e7e8ee;
      --md-sys-color-outline: #74777f;
      --md-sys-color-outline-variant: #c4c6cf;
      --md-sys-shape-corner-small: 8px;
      --md-sys-shape-corner-medium: 12px;
      --md-sys-shape-corner-large: 16px;
      --md-sys-shape-corner-extra-large: 28px;
      --md-sys-shape-corner-full: 9999px;
    }
    @media (prefers-color-scheme: dark) {
      :root {
        --md-sys-color-primary: #a7c8ff;
        --md-sys-color-on-primary: #03305f;
        --md-sys-color-primary-container: #234777;
        --md-sys-color-on-primary-container: #d5e3ff;
        --md-sys-color-secondary-container: #3d4758;
        --md-sys-color-on-secondary-container: #d9e3f8;
        --md-sys-color-tertiary-container: #553f5d;
        --md-sys-color-on-tertiary-container: #f8d8fe;
        --md-sys-color-error: #ffb4ab;
        --md-sys-color-error-container: #93000a;
        --md-sys-color-on-error-container: #ffdad6;
        --md-sys-color-surface: #111318;
        --md-sys-color-on-surface: #e1e2e9;
        --md-sys-color-on-surface-variant: #c4c6cf;
        --md-sys-color-surface-container-low: #191c20;
        --md-sys-color-surface-container: #1d2024;
        --md-sys-color-surface-container-high: #282a2f;
        --md-sys-color-outline: #8d9199;
        --md-sys-color-outline-variant: #43474e;
      }
    }
    * { box-sizing: border-box; }
    body {
      margin: 0;
      background: var(--md-sys-color-surface);
      color: var(--md-sys-color-on-surface);
      font: 400 16px/24px system-ui, "Noto Sans JP", sans-serif;
    }
    .top-app-bar {
      display: flex; align-items: center; gap: 16px;
      min-height: 64px; padding: 8px 16px;
      background: var(--md-sys-color-surface-container);
    }
    .top-app-bar h1 { flex: 1; margin: 0; font-size: 22px; line-height: 28px; font-weight: 500; }
    main { max-width: 960px; margin: 0 auto; padding: 24px 16px 48px; }
    h2 { font-size: 28px; line-height: 36px; font-weight: 500; margin: 0 0 16px; }
    h3 { font-size: 16px; line-height: 24px; font-weight: 500; margin: 24px 0 8px; }
    .card > h3:first-child { margin-top: 0; }
    .card {
      background: var(--md-sys-color-surface-container-low);
      border-radius: var(--md-sys-shape-corner-large);
      padding: 24px; margin-bottom: 16px;
    }
    .card.narrow { max-width: 480px; margin: 0 auto; }
    .button {
      display: inline-flex; align-items: center; justify-content: center;
      min-height: 40px; padding: 0 24px; border: 0; cursor: pointer;
      border-radius: var(--md-sys-shape-corner-full);
      font-family: inherit; font-size: 14px; line-height: 20px; font-weight: 500;
      letter-spacing: 0.1px; text-decoration: none;
      transition: border-radius 200ms cubic-bezier(0.2, 0, 0, 1);
    }
    .button:active { border-radius: var(--md-sys-shape-corner-small); }
    .button.filled { background: var(--md-sys-color-primary); color: var(--md-sys-color-on-primary); }
    .button.tonal { background: var(--md-sys-color-secondary-container); color: var(--md-sys-color-on-secondary-container); }
    .button.text { background: transparent; color: var(--md-sys-color-primary); padding: 0 12px; }
    .button:focus-visible, a:focus-visible, select:focus-visible, input:focus-visible {
      outline: 3px solid var(--md-sys-color-primary); outline-offset: 2px;
    }
    label { display: block; margin-bottom: 16px; color: var(--md-sys-color-on-surface-variant); font-size: 14px; }
    input, select {
      display: block; width: 100%; min-height: 56px; margin-top: 8px; padding: 0 16px;
      border: 1px solid var(--md-sys-color-outline); border-radius: var(--md-sys-shape-corner-small);
      background: transparent; color: var(--md-sys-color-on-surface); font: inherit;
    }
    .filters { display: flex; flex-wrap: wrap; gap: 16px; align-items: flex-end; }
    .filters label { flex: 1 1 200px; margin: 0; }
    .list { list-style: none; margin: 0; padding: 0; }
    .list li a {
      display: grid; grid-template-columns: 1fr auto; gap: 4px 16px;
      padding: 16px 24px; margin-bottom: 8px; color: inherit; text-decoration: none;
      background: var(--md-sys-color-surface-container-low);
      border-radius: var(--md-sys-shape-corner-medium);
    }
    .list li a:hover { background: var(--md-sys-color-surface-container-high); }
    .list .meta { grid-column: 1 / -1; color: var(--md-sys-color-on-surface-variant); font-size: 14px; }
    .chip {
      display: inline-flex; align-items: center; min-height: 32px; padding: 0 16px;
      border-radius: var(--md-sys-shape-corner-small); font-size: 14px; font-weight: 500;
      background: var(--md-sys-color-secondary-container); color: var(--md-sys-color-on-secondary-container);
    }
    .chip.high { background: var(--md-sys-color-tertiary-container); color: var(--md-sys-color-on-tertiary-container); }
    .banner {
      padding: 16px 24px; margin-bottom: 16px; border-radius: var(--md-sys-shape-corner-medium);
      background: var(--md-sys-color-primary-container); color: var(--md-sys-color-on-primary-container);
    }
    .banner.error { background: var(--md-sys-color-error-container); color: var(--md-sys-color-on-error-container); }
    .body-text { white-space: pre-wrap; overflow-wrap: anywhere; }
    dl { display: grid; grid-template-columns: max-content 1fr; gap: 8px 24px; margin: 0; }
    dt { color: var(--md-sys-color-on-surface-variant); }
    dd { margin: 0; overflow-wrap: anywhere; }
    .actions { display: flex; flex-wrap: wrap; gap: 8px; }
    .pager { display: flex; justify-content: space-between; align-items: center; gap: 16px; margin-top: 16px; }
    .history { margin: 0; padding-left: 24px; color: var(--md-sys-color-on-surface-variant); font-size: 14px; }
    @media (max-width: 600px) {
      main { padding: 16px 16px 32px; }
      .top-app-bar h1 { font-size: 18px; line-height: 24px; }
      .card { padding: 16px; }
      dl { grid-template-columns: 1fr; gap: 0; }
      dd { margin-bottom: 8px; }
    }
    `

    </details>

    各画面

    ポイントは次の3つです。

    • ボタンは遷移ルールから作る:第2回の遷移表(transitions)で「次に移れる状態」だけをボタンにします
    • 1つのボタンを1つのフォームにする:隠し項目で status(変えたい状態)と expected(画面に出ている状態)を送ります
    • 絞り込みは GET のフォーム:データを変えない操作は GET にして、URL に条件を残します

    <details> <summary>src/admin/pages.tsx の全文</summary>

    // src/admin/pages.tsx
    // 管理画面の各画面。{ } で埋め込んだ値は Hono の JSX が自動でエスケープする(HTML として解釈されない)
    import type { Status } from '../status'
    import { statuses, transitions } from '../status'
    
    export const statusLabel: Record<Status, string> = {
      open: '受付',
      in_progress: '対応中',
      resolved: '解決',
      closed: '完了',
    }
    const priorityLabel: Record<string, string> = { high: '高', normal: '通常', low: '低' }
    const categoryLabel: Record<string, string> = { pc: 'PC・機器', account: 'アカウント', system: '社内システム', other: 'その他' }
    
    // 日時は D1 に UTC で入っているので、画面では日本時間で見せる
    const jst = (iso: string) =>
      new Date(iso).toLocaleString('ja-JP', { timeZone: 'Asia/Tokyo', dateStyle: 'short', timeStyle: 'short' })
    
    export const LoginPage = (props: { error?: string; email?: string }) => (
      <div class="card narrow">
        <h2>ログイン</h2>
        {props.error && (
          <p class="banner error" role="alert">
            {props.error}
          </p>
        )}
        <form method="post" action="/admin/login">
          <label>
            メールアドレス
            <input type="email" name="email" value={props.email ?? ''} autocomplete="username" required />
          </label>
          <label>
            パスワード
            <input type="password" name="password" autocomplete="current-password" required />
          </label>
          <button type="submit" class="button filled">
            ログイン
          </button>
        </form>
      </div>
    )
    
    export type TicketSummary = {
      id: number
      title: string
      category: string
      priority: string
      status: Status
      requester: string
      assignee: string | null
      created_at: string
    }
    
    export const TicketListPage = (props: {
      items: TicketSummary[]
      status?: Status
      page: number
      perPage: number
      total: number
    }) => {
      const lastPage = Math.max(1, Math.ceil(props.total / props.perPage))
      // ページ送りのリンクにも絞り込みの条件を残す
      const pageLink = (page: number) => {
        const q = new URLSearchParams({ page: String(page) })
        if (props.status) q.set('status', props.status)
        return `/admin/tickets?${q}`
      }
      return (
        <>
          <h2>問い合わせ一覧</h2>
          {/* 絞り込みは画面を変えるだけで、データは変えないので GET のフォームにする */}
          <form method="get" action="/admin/tickets" class="card filters">
            <label>
              状態
              <select name="status">
                <option value="">すべて</option>
                {statuses.map((s) => (
                  <option value={s} selected={s === props.status}>
                    {statusLabel[s]}
                  </option>
                ))}
              </select>
            </label>
            <button type="submit" class="button tonal">
              絞り込む
            </button>
          </form>
          <p>{`${props.total}件`}</p>
          {props.items.length === 0 ? (
            <p class="card">該当する問い合わせはありません。</p>
          ) : (
            <ul class="list">
              {props.items.map((t) => (
                <li>
                  <a href={`/admin/tickets/${t.id}`}>
                    <strong>{`#${t.id} ${t.title}`}</strong>
                    <span class={t.priority === 'high' ? 'chip high' : 'chip'}>{statusLabel[t.status]}</span>
                    <span class="meta">
                      {`${categoryLabel[t.category]}・優先度 ${priorityLabel[t.priority]}・${t.requester}・担当 ${t.assignee ?? '未割り当て'}・${jst(t.created_at)}`}
                    </span>
                  </a>
                </li>
              ))}
            </ul>
          )}
          <nav class="pager" aria-label="ページ送り">
            {props.page > 1 ? <a class="button text" href={pageLink(props.page - 1)}>前へ</a> : <span />}
            <span>{`${props.page} / ${lastPage}ページ`}</span>
            {props.page < lastPage ? <a class="button text" href={pageLink(props.page + 1)}>次へ</a> : <span />}
          </nav>
        </>
      )
    }
    
    export type TicketDetail = TicketSummary & { body: string; updated_at: string }
    export type TicketEvent = { actor: string; type: string; from_value: string | null; to_value: string | null; created_at: string }
    
    const messages: Record<string, { text: string; error?: boolean }> = {
      changed: { text: '状態を変更しました。' },
      conflict: { text: 'ほかの人が先に状態を変更していました。最新の内容を確かめてから、もう一度操作してください。', error: true },
      invalid: { text: 'この状態には変更できません。', error: true },
    }
    
    export const TicketDetailPage = (props: { ticket: TicketDetail; events: TicketEvent[]; message?: string }) => {
      const t = props.ticket
      const msg = props.message ? messages[props.message] : undefined
      return (
        <>
          <p>
            <a class="button text" href="/admin/tickets">
              一覧へ戻る
            </a>
          </p>
          {msg && (
            <p class={msg.error ? 'banner error' : 'banner'} role="status">
              {msg.text}
            </p>
          )}
          <section class="card">
            <h2>{`#${t.id} ${t.title}`}</h2>
            <dl>
              <dt>状態</dt>
              <dd>{statusLabel[t.status]}</dd>
              <dt>種別・優先度</dt>
              <dd>{`${categoryLabel[t.category]}・${priorityLabel[t.priority]}`}</dd>
              <dt>申請者</dt>
              <dd>{t.requester}</dd>
              <dt>担当者</dt>
              <dd>{t.assignee ?? '未割り当て'}</dd>
              <dt>登録</dt>
              <dd>{jst(t.created_at)}</dd>
            </dl>
            <h3>内容</h3>
            <p class="body-text">{t.body}</p>
          </section>
    
          <section class="card">
            <h3>状態を変える</h3>
            {transitions[t.status].length === 0 ? (
              <p>完了したチケットは変更できません。</p>
            ) : (
              <div class="actions">
                {transitions[t.status].map((next) => (
                  // 1つのボタンを1つのフォームにする。expected に「いま画面に出ている状態」を入れて送る
                  <form method="post" action={`/admin/tickets/${t.id}/status`}>
                    <input type="hidden" name="expected" value={t.status} />
                    <input type="hidden" name="status" value={next} />
                    <button type="submit" class={next === 'closed' ? 'button tonal' : 'button filled'}>
                      {`「${statusLabel[next]}」にする`}
                    </button>
                  </form>
                ))}
              </div>
            )}
          </section>
    
          <section class="card">
            <h3>変更の履歴</h3>
            {props.events.length === 0 ? (
              <p>まだ変更はありません。</p>
            ) : (
              <ol class="history">
                {props.events.map((e) => (
                  <li>
                    {e.type === 'status_changed'
                      ? `${jst(e.created_at)} ${e.actor}:${statusLabel[e.from_value as Status]} → ${statusLabel[e.to_value as Status]}`
                      : `${jst(e.created_at)} ${e.actor}:担当者を ${e.to_value ?? '未割り当て'} に変更`}
                  </li>
                ))}
              </ol>
            )}
          </section>
        </>
      )
    }
    
    export const MessagePage = (props: { heading: string; text: string }) => (
      <section class="card">
        <h2>{props.heading}</h2>
        <p>{props.text}</p>
      </section>
    )

    </details>

    5. 管理画面のルートを作り、CSRF 対策を付ける

    CSRF が起きる仕組みと、この回の防ぎ方

    CSRF は、ログイン中の担当者が別のサイトを開いたとき、そこに仕込まれたフォームがヘルプデスクへ送られ、担当者の Cookie 付きで操作が通ってしまう攻撃です。この回では次の3つを重ねて防ぎます。

    対策やること防げること
    Hono の csrf ミドルウェアフォームの送信(POST など)で、Origin(送り元のサイト)と Sec-Fetch-Site(ブラウザが付ける「同じサイトからの送信か」の印)を確かめ、どちらも自分のサイトでなければ 403 にするほかのサイトからのフォーム送信
    Cookie の SameSite=Lax第3回で設定済み。ほかのサイトからの POST には、ブラウザがログインの Cookie を付けない同上(ブラウザ側の備え)
    状態を変える操作は POST だけログアウトも含め、データを変える操作をリンク(GET)にしない画像やリンクを開かせるだけの攻撃

    csrf ミドルウェアは、フォームの形式(application/x-www-form-urlencoded など)の送信だけを確かめ、Origin も Sec-Fetch-Site も無い送信は受け付けません。

    📰 出典:Hono「CSRF Protection」

    フォームに推測できない値(トークン)を埋め込んで確かめる方法もよく使われ、IPA の「安全なウェブサイトの作り方」でも対策として挙げられています。この回の方法は、主要なブラウザがこれらのヘッダーを付けることが前提なので、古いブラウザが残る環境ではトークンの方法も検討します。

    📰 出典:IPA「安全なウェブサイトの作り方」

    安全のためのヘッダー

    secureHeaders は、安全のためのヘッダーをまとめて付けるミドルウェアです。CSP(Content-Security-Policy。ページが読み込んでよいものをブラウザに伝えるヘッダー)で、スクリプトは一切実行しない(script-src 'none')、CSS とフォームの送り先は自分のサイトだけ、ほかのサイトの枠(iframe)には表示させない、と絞りました。

    📰 出典:Hono「Secure Headers Middleware」

    ルートの全体

    ログインフォームは API と同じ loginSchema を zValidator('form', …) で使います。送信のあとは 303 で別の画面へ移します(PRG。再読み込みでフォームが二重に送られないようにする形)。

    📰 出典:Hono「Validation」

    <details> <summary>src/routes/admin.tsx の全文</summary>

    // src/routes/admin.tsx
    // 担当者・管理者向けの管理画面。HTML をサーバーで作って返し(サーバー側描画)、操作は HTML のフォームで送る
    import { zValidator } from '@hono/zod-validator'
    import { Hono } from 'hono'
    import { csrf } from 'hono/csrf'
    import { createMiddleware } from 'hono/factory'
    import { secureHeaders } from 'hono/secure-headers'
    import { z } from 'zod'
    import { endSession, loadSessionUser, startSession, type AppEnv } from '../auth'
    import { css } from '../admin/styles'
    import { renderer } from '../admin/layout'
    import {
      LoginPage,
      MessagePage,
      TicketDetailPage,
      TicketListPage,
      type TicketDetail,
      type TicketEvent,
      type TicketSummary,
    } from '../admin/pages'
    import { listQuerySchema } from '../schemas'
    import { statuses } from '../status'
    import { changeStatus } from '../ticket-service'
    import { checkCredentials, loginSchema } from './auth'
    
    export const admin = new Hono<AppEnv>()
    
    // 画面を返すときの安全のためのヘッダー。読み込めるのは自分のサイトの CSS だけ、スクリプトは使わない、
    // フォームの送り先は自分のサイトだけ、ほかのサイトの枠(iframe)の中には表示させない
    admin.use(
      '*',
      secureHeaders({
        contentSecurityPolicy: {
          defaultSrc: ["'self'"],
          scriptSrc: ["'none'"],
          styleSrc: ["'self'"],
          formAction: ["'self'"],
          frameAncestors: ["'none'"],
          baseUri: ["'none'"],
        },
      }),
    )
    // CSRF(ほかのサイトから、ログイン中の人の名前でフォームを送らせる攻撃)への備え。
    // フォームの送信(POST)は、自分のサイトから送られたもの(Origin・Sec-Fetch-Site で判定)だけを受け付ける
    admin.use('*', csrf())
    admin.use('*', renderer)
    
    admin.get('/admin.css', (c) => c.body(css, 200, { 'content-type': 'text/css; charset=utf-8', 'cache-control': 'max-age=300' }))
    
    admin.get('/login', (c) => c.render(<LoginPage />, { title: 'ログイン' }))
    
    admin.post(
      '/login',
      zValidator('form', loginSchema, (result, c) => {
        if (!result.success) {
          c.status(400)
          return c.render(<LoginPage error="メールアドレスとパスワードを入力してください。" />, { title: 'ログイン' })
        }
      }),
      async (c) => {
        const { email, password } = c.req.valid('form')
        const user = await checkCredentials(c.env, email, password)
        if (!user) {
          c.status(401)
          return c.render(<LoginPage error="メールアドレスまたはパスワードが違います。" email={email} />, { title: 'ログイン' })
        }
        await startSession(c, c.env.SESSION_SECRET, user.id)
        // 送信のあとは別の画面へ移す(再読み込みでフォームが二重に送られないようにする。PRG と呼ばれる形)
        return c.redirect('/admin/tickets', 303)
      },
    )
    
    admin.post('/logout', (c) => {
      endSession(c)
      return c.redirect('/admin/login', 303)
    })
    
    // ここから下は担当者・管理者だけ。未ログインはログイン画面へ、社員は「権限がありません」の画面にする
    const requireStaffPage = createMiddleware<AppEnv>(async (c, next) => {
      const user = await loadSessionUser(c)
      if (!user) return c.redirect('/admin/login', 302)
      if (user.role === 'employee') {
        c.status(403)
        return c.render(<MessagePage heading="権限がありません" text="この画面は担当者・管理者用です。" />, {
          title: '権限がありません',
          user,
        })
      }
      c.set('user', user)
      await next()
    })
    admin.use('/tickets', requireStaffPage)
    admin.use('/tickets/*', requireStaffPage)
    
    admin.get(
      '/tickets',
      // 画面の URL は人が書き換えられるので、API と同じ入力チェックを通す。不正な値は既定値に戻して表示する
      zValidator('query', listQuerySchema.catch({ page: 1, perPage: 20 })),
      async (c) => {
        const { status, page, perPage } = c.req.valid('query')
        const where = status ? 'WHERE status = ?' : ''
        const filter = status ? [status] : []
        const [count, list] = await c.env.DB.batch([
          c.env.DB.prepare(`SELECT COUNT(*) AS total FROM tickets ${where}`).bind(...filter),
          c.env.DB.prepare(
            `SELECT id, title, category, priority, status, requester, assignee, created_at
             FROM tickets ${where}
             ORDER BY created_at DESC, id DESC
             LIMIT ? OFFSET ?`,
          ).bind(...filter, perPage, (page - 1) * perPage),
        ])
        const total = (count.results[0] as { total: number }).total
        return c.render(
          <TicketListPage items={list.results as TicketSummary[]} status={status} page={page} perPage={perPage} total={total} />,
          { title: '問い合わせ一覧', user: c.get('user') },
        )
      },
    )
    
    const notFound = (c: Parameters<typeof requireStaffPage>[0]) => {
      c.status(404)
      return c.render(<MessagePage heading="見つかりません" text="指定の問い合わせはありません。" />, {
        title: '見つかりません',
        user: c.get('user'),
      })
    }
    
    admin.get('/tickets/:id{[0-9]+}', async (c) => {
      const id = Number(c.req.param('id'))
      const ticket = await c.env.DB.prepare('SELECT * FROM tickets WHERE id = ?').bind(id).first<TicketDetail>()
      if (!ticket) return notFound(c)
      const { results: events } = await c.env.DB.prepare(
        'SELECT actor, type, from_value, to_value, created_at FROM ticket_events WHERE ticket_id = ? ORDER BY id',
      )
        .bind(id)
        .all<TicketEvent>()
      // 状態の変更のあとに戻ってきたときの知らせ(?done=changed など)。決まった値だけを受け付ける
      const done = c.req.query('done')
      const message = done && ['changed', 'conflict', 'invalid'].includes(done) ? done : undefined
      return c.render(<TicketDetailPage ticket={ticket} events={events} message={message} />, {
        title: `#${ticket.id} ${ticket.title}`,
        user: c.get('user'),
      })
    })
    
    // フォームの値はすべて文字列で届く。状態は一覧にある値だけを受け付ける
    const statusFormSchema = z.object({ status: z.enum(statuses), expected: z.enum(statuses) })
    
    admin.post(
      '/tickets/:id{[0-9]+}/status',
      zValidator('form', statusFormSchema, (result, c) => {
        if (!result.success) return c.redirect(`/admin/tickets/${c.req.param('id')}?done=invalid`, 303)
      }),
      async (c) => {
        const id = Number(c.req.param('id'))
        const { status, expected } = c.req.valid('form')
        // API と同じ changeStatus を使う。遷移のルール・同時更新の扱い・履歴の記録は1か所だけにある
        const result = await changeStatus(c.env.DB, { id, next: status, actor: c.get('user').email, expected })
        if (!result.ok && result.error === 'not_found') return notFound(c)
        const done = result.ok ? 'changed' : result.error === 'conflict' ? 'conflict' : 'invalid'
        return c.redirect(`/admin/tickets/${id}?done=${done}`, 303)
      },
    )

    </details>

    最後に、管理画面を /admin につなぎます。

    src/index.ts に次の変更を加えます(+ が追加、- が削除)。

    --- a/src/index.ts
    +++ b/src/index.ts
    @@ -5,6 +5,7 @@ import { users } from './routes/users'
     import { tickets } from './routes/tickets'
     import { attachments } from './routes/attachments'
     import { comments } from './routes/comments'
    +import { admin } from './routes/admin'
     import { processBatch, type NotificationMessage } from './notify'
     import { detectOverdue } from './sla'
    
    @@ -25,6 +26,7 @@ app.route('/api/users', users)
     app.route('/api/tickets', tickets)
     app.route('/api', attachments)
     app.route('/api', comments)
    +app.route('/admin', admin)
    
     export { app }
    

    6. テストで確かめる

    画面のテストも SELF.fetch で送ります。権限、エスケープ、ほかのサイトからのフォームが 403 になること、古い画面からの送信で状態が変わらないことを確かめます。

    <details> <summary>test/admin.test.ts の全文</summary>

    // test/admin.test.ts
    import { env, SELF } from 'cloudflare:test'
    import { beforeAll, describe, expect, it } from 'vitest'
    import { loginAs, PASSWORD } from './helpers'
    
    const ORIGIN = 'http://example.com'
    let staff = ''
    let agent = ''
    let ticketId = 0
    
    beforeAll(async () => {
      staff = await loginAs('jiro@example.com', 'employee')
      agent = await loginAs('desk@example.com', 'agent')
      // 件名に HTML のタグを含めておき、画面でエスケープされるかを確かめる
      const row = await env.DB.prepare(
        `INSERT INTO tickets (title, body, category, priority, requester)
         VALUES (?, ?, 'pc', 'high', 'jiro@example.com') RETURNING id`,
      )
        .bind('<script>alert(1)</script>画面が固まる', '朝から\n画面が固まります')
        .first<{ id: number }>()
      ticketId = row!.id
    })
    
    // フォームの送信と同じ形(application/x-www-form-urlencoded)で POST する
    const postForm = (path: string, fields: Record<string, string>, headers: Record<string, string> = {}) =>
      SELF.fetch(`${ORIGIN}${path}`, {
        method: 'POST',
        headers: { 'content-type': 'application/x-www-form-urlencoded', ...headers },
        body: new URLSearchParams(fields),
        redirect: 'manual',
      })
    
    describe('管理画面:ログインと権限', () => {
      it('未ログインで一覧を開くと、ログイン画面へ移る', async () => {
        const res = await SELF.fetch(`${ORIGIN}/admin/tickets`, { redirect: 'manual' })
        expect(res.status).toBe(302)
        expect(res.headers.get('location')).toBe('/admin/login')
      })
    
      it('ログイン画面は HTML で返り、スクリプトを禁じるヘッダーが付く', async () => {
        const res = await SELF.fetch(`${ORIGIN}/admin/login`)
        expect(res.status).toBe(200)
        expect(res.headers.get('content-type')).toContain('text/html')
        expect(res.headers.get('content-security-policy')).toContain("script-src 'none'")
        expect(res.headers.get('x-frame-options')).toBe('SAMEORIGIN')
        expect(await res.text()).toContain('<form method="post" action="/admin/login">')
      })
    
      it('フォームでログインすると Cookie が付き、一覧へ移る', async () => {
        const res = await postForm('/admin/login', { email: 'desk@example.com', password: PASSWORD }, { origin: ORIGIN })
        expect(res.status).toBe(303)
        expect(res.headers.get('location')).toBe('/admin/tickets')
        expect(res.headers.get('set-cookie')).toContain('session=')
      })
    
      it('パスワードが違うと 401 で、同じ画面に戻り入力したメールは残る', async () => {
        const res = await postForm('/admin/login', { email: 'desk@example.com', password: 'wrong' }, { origin: ORIGIN })
        expect(res.status).toBe(401)
        const html = await res.text()
        expect(html).toContain('メールアドレスまたはパスワードが違います')
        expect(html).toContain('value="desk@example.com"')
      })
    
      it('社員は管理画面を開けない(403)', async () => {
        const res = await SELF.fetch(`${ORIGIN}/admin/tickets`, { headers: { cookie: staff } })
        expect(res.status).toBe(403)
      })
    })
    
    describe('管理画面:一覧と詳細', () => {
      it('担当者は一覧を開け、件名の HTML はエスケープされて表示される', async () => {
        const res = await SELF.fetch(`${ORIGIN}/admin/tickets`, { headers: { cookie: agent } })
        expect(res.status).toBe(200)
        const html = await res.text()
        expect(html).toContain('&lt;script&gt;alert(1)&lt;/script&gt;画面が固まる')
        expect(html).not.toContain('<script>alert(1)</script>')
      })
    
      it('状態で絞り込める。不正な値は「すべて」として表示する', async () => {
        const closed = await SELF.fetch(`${ORIGIN}/admin/tickets?status=closed`, { headers: { cookie: agent } })
        expect(await closed.text()).toContain('該当する問い合わせはありません')
        const bad = await SELF.fetch(`${ORIGIN}/admin/tickets?status=xxx&page=-1`, { headers: { cookie: agent } })
        expect(bad.status).toBe(200)
      })
    
      it('詳細に次に移れる状態のボタンだけが出る', async () => {
        const html = await (await SELF.fetch(`${ORIGIN}/admin/tickets/${ticketId}`, { headers: { cookie: agent } })).text()
        expect(html).toContain('「対応中」にする')
        expect(html).not.toContain('「完了」にする')
      })
    
      it('存在しない番号は 404', async () => {
        const res = await SELF.fetch(`${ORIGIN}/admin/tickets/999999`, { headers: { cookie: agent } })
        expect(res.status).toBe(404)
      })
    })
    
    describe('管理画面:状態の変更と CSRF', () => {
      it('ほかのサイトから送られたフォームは 403 で、状態は変わらない', async () => {
        const res = await postForm(
          `/admin/tickets/${ticketId}/status`,
          { status: 'in_progress', expected: 'open' },
          { cookie: agent, origin: 'https://evil.example', 'sec-fetch-site': 'cross-site' },
        )
        expect(res.status).toBe(403)
        const row = await env.DB.prepare('SELECT status FROM tickets WHERE id = ?').bind(ticketId).first<{ status: string }>()
        expect(row!.status).toBe('open')
      })
    
      it('Origin の無いフォーム送信も受け付けない', async () => {
        const res = await postForm(`/admin/tickets/${ticketId}/status`, { status: 'in_progress', expected: 'open' }, { cookie: agent })
        expect(res.status).toBe(403)
      })
    
      it('自分のサイトからのフォームなら状態が変わり、履歴が残り、詳細へ戻る', async () => {
        const res = await postForm(
          `/admin/tickets/${ticketId}/status`,
          { status: 'in_progress', expected: 'open' },
          { cookie: agent, origin: ORIGIN },
        )
        expect(res.status).toBe(303)
        expect(res.headers.get('location')).toBe(`/admin/tickets/${ticketId}?done=changed`)
        const html = await (await SELF.fetch(`${ORIGIN}${res.headers.get('location')}`, { headers: { cookie: agent } })).text()
        expect(html).toContain('状態を変更しました')
        expect(html).toContain('desk@example.com:受付 → 対応中')
      })
    
      it('古い画面から送ると(画面の状態と今の状態が違うと)変えずに知らせる', async () => {
        // 画面では「受付」のまま。その間にほかの人が「対応中」にしていた
        const res = await postForm(
          `/admin/tickets/${ticketId}/status`,
          { status: 'in_progress', expected: 'open' },
          { cookie: agent, origin: ORIGIN },
        )
        expect(res.headers.get('location')).toBe(`/admin/tickets/${ticketId}?done=conflict`)
      })
    
      it('社員はフォームを送っても変えられない', async () => {
        const res = await postForm(
          `/admin/tickets/${ticketId}/status`,
          { status: 'resolved', expected: 'in_progress' },
          { cookie: staff, origin: ORIGIN },
        )
        expect(res.status).toBe(403)
      })
    })

    </details>

    実行は、これまでと同じコマンドです。

    npx wrangler types
    npm run typecheck
    npm test

    筆者の環境(2026年11月、Node.js 22系・Hono 4・Wrangler 4)では、型チェックが通り、テストは前回までの61件にこの回の14件を足した75件がすべて通りました。

    動作確認:ブラウザで管理画面を開く

    ローカルのデータベースにマイグレーションを当て、第3回の scripts/make-admin-sql.mjs で管理者を作ってから、wrangler dev を起動します。

    npx wrangler d1 migrations apply helpdesk --local
    ADMIN_PASSWORD='12文字以上の長いパスワード' node scripts/make-admin-sql.mjs admin@example.com 管理者 \
      | npx wrangler d1 execute helpdesk --local --file=/dev/stdin
    npx wrangler dev

    http://localhost:8787/admin/tickets を開くとログイン画面に移り、ログインすると一覧が出ます。次は4件を入れた一覧です(開発環境での確認画面)。4件目の件名の <script> は文字のまま表示されています。

    問い合わせ一覧の画面。状態での絞り込みと、4件の問い合わせが並んでいる

    1件目で「「対応中」にする」を押すと、知らせと履歴が出て、ボタンは「解決」だけに変わりました。

    問い合わせの詳細画面。状態の変更の知らせ、「解決」にするボタン、変更の履歴が表示されている

    スマートフォンの幅・暗い表示でも崩れないことを確かめました。

    スマートフォン幅・暗い表示での問い合わせ一覧

    CSRF 対策は curl で確かめられます。

    curl -s -o /dev/null -w "%{http_code}\n" -X POST \
      -H "Origin: https://evil.example" -H "content-type: application/x-www-form-urlencoded" \
      -d "email=a@example.com&password=x" http://localhost:8787/admin/login

    筆者の環境では 403 が返りました。Origin を http://localhost:8787 にすると、正しいメールとパスワードで 303(一覧への移動)が返ります。

    実際の Cloudflare 環境での表示・動作は、この環境では確認できていません(未確認)。

    つまずきやすい点と注意

    • c.render の前に状態コードを決める:c.render は既定で 200 を返します。エラーの画面を返すときは、先に c.status(400) のように決めておきます
    • CSRF 対策で正しい操作まで 403 になる:拡張機能やプロキシ(通信の中継)が Origin を消すと 403 になります。また、前に別の仕組みを置いて URL が変わる構成では、csrf({ origin: … }) の指定が必要です
    • dangerouslySetInnerHTML を使わない:エスケープせずに HTML を差し込む書き方で、利用者の入力に使うと XSS の原因になります
    • 本番運用で足したいもの:ログイン失敗の回数制限(総当たりへの備え)、管理者の多要素認証、操作ログの画面は、この回では作っていません。社内だけで使う画面なら、Cloudflare Access(Cloudflare の、社員だけが通れる入口を作る仕組み)を前に置く方法もあります

    発注者向けメモ:管理画面を開発会社に頼むときの確認点

    管理画面は、誰が何をできるか、どこまで画面で操作したいかで工数が大きく変わります。次の点を確認しておくと安心です。

    • ☐ 管理画面を使う人の役割(担当者・管理者など)と、役割ごとにできる操作の一覧
    • ☐ 画面で行いたい操作(状態の変更・担当者の割り当て・コメント・利用者の追加など)と、API だけで足りる操作の区別
    • ☐ 社外から開けるようにするか、社内ネットワークや決まった人だけに絞るか
    • ☐ スマートフォンでも使うか、暗い表示に対応するか
    • ☐ 一覧で使いたい絞り込み・並べ替え・CSV の書き出しの有無

    開発会社への質問例です。

    • 「画面と API で、状態の変え方のルールは同じ処理を使っていますか?片方だけ直して食い違うことはありませんか?」
    • 「CSRF と XSS への対策は、どの方法で行い、どうテストしていますか?」
    • 「2人が同時に同じ問い合わせを操作したとき、後から操作した人にはどう見えますか?」

    工数やリスクが増えやすいのは、「画面の一部だけを即時に書き換えたい(一覧が自動で更新されるなど)」「表計算ソフトのように一覧の上で直接編集したい」「細かい権限(部署ごと・項目ごとに見せ分ける)を付けたい」といった要望です。こうした画面はブラウザ側で組み立てる作りが合うこともあり、工数が変わります。見積もりの前に「画面で何をしたいか」を一覧にしておくと話が早く進みます。金額の目安は、依頼先の見積もりで確認してください。

    まとめと次回予告

    この回では、Hono の JSX で管理画面を作りました。ポイントは次の3つです。

    • 状態の変え方などのルールは1つの関数にまとめ、API と画面の両方から使う
    • フォームを使う画面では、csrf ミドルウェアと SameSite の Cookie、「変更は POST だけ」を重ねて CSRF を防ぐ
    • JSX の自動のエスケープに加え、CSP でスクリプトの実行を禁じて XSS の被害を抑える

    次回(第9回)は「hono/client で型安全に API を呼ぶ」です。API の型を画面側と共有し、呼び出し方の間違いを型チェックで見つけられるようにします。

    この連載の記事一覧

    この記事は連載「Honoで作る社内ヘルプデスク」の1回です。連載のほかの回は次のとおりです(連載の一覧ページ)。

    システム制作・運用・保守のお問い合わせはこちら

      お問い合わせ


      よかったらシェアしてね!
      • URLをコピーしました!
      • URLをコピーしました!

      この記事を書いた人

      株式会社THIRD HERO代表取締役 朝野貴朗
      Webシステム開発を中心に、toC向けサービスサイトの運営、ツール開発などを行ってまいりました。

      目次