@aiquants/auth-react-router 0.7.3 → 0.9.0

package/src/server/authenticate-in-loader.ts

@@ -10,10 +10,20 @@
  */
 import type { AuthenticationPayload, MyGoogleProfile, SessionProfile } from "@aiquants/auth-core"
 import { redirect } from "react-router"
-import type { AuthenticateFns } from "./authenticate"
+import { AuthRequiredError, type AuthenticateFns } from "./authenticate"
 import type { AuthServerConfig, LoggerPort } from "./ports"
 import type { AuthSessionStorage } from "./session"
 
+/**
+ * Mode-neutral result of the authentication work, carrying no failure policy.
+ * 失敗時の方針を含まない、モード中立な認証作業の結果。
+ *
+ * リダイレクトするか否かは呼び出し元ごとの方針であり、認証**作業**の一部ではない。
+ * 結果をこの形に保つことで、`failureRedirect` の指定が異なる呼び出し元どうしが
+ * 1 リクエスト 1 回の作業を共有できる。
+ */
+type LoaderAuthOutcome = { readonly kind: "authenticated"; readonly user: MyGoogleProfile; readonly cookie?: string } | { readonly kind: "unauthenticated"; readonly cookie?: string }
+
 /** createAuthenticateInLoader が返すローダーガード関数。 */
 export type AuthenticateInLoader = ReturnType<typeof createAuthenticateInLoader>
 
@@ -58,90 +68,175 @@ export const createAuthenticateInLoader = (config: AuthServerConfig, storage: Au
         return fetchPromise
     }
 
+    // 1 リクエスト = 1 認証。React Router は 1 データパス内の全ローダーへ**同一の** Request
+    // インスタンスを渡す (callLoaderOrAction が単一の request をクローズオーバーする) ため、
+    // Request 同一性をそのままキーにできる。
+    //
+    // キーに `failureRedirect` を含めてはならない。あれは失敗時の**方針**であって認証**作業**では
+    // なく、含めると root (null) と leaf (文字列) が別スロットに落ちて 1 ナビゲーションで二重に
+    // 認証する。期限切れ時には Google のトークン更新が 2 本走り、内容の異なる Set-Cookie が
+    // 2 本返る (React Router の Set-Cookie 重複排除はバイト一致のみ)。
+    //
+    // 保持は Request の寿命と同じで TTL も無効化 API も持たない。ストリーミング応答は Request を
+    // コネクション終了まで掴むため、エントリもその間生き残る。リソースルートはローダーが 1 本
+    // なのでエントリは一度書かれて二度と読まれず、陳腐化の危険は無い。ただしストリーム途中で
+    // 再認証する実装を将来足すと、何時間も前のトークンを掴むことになる。
+    const outcomeByRequest = new WeakMap<Request, Promise<LoaderAuthOutcome>>()
+
     /**
-     * Handles authentication within loader requests by refreshing session tokens when needed.
-     * ローダーリクエスト内で必要に応じてセッショントークンを更新する認証処理。
+     * Performs the authentication work once, independent of any failure policy.
+     * 失敗時の方針から独立した認証作業そのもの。
+     *
+     * 戻り値は**モード中立**で、リダイレクトするか否かの判断を含まない。これにより
+     * `failureRedirect` の指定が異なる複数の呼び出し元が 1 つの結果を共有できる。
      *
      * @param request - リクエストオブジェクト。
-     * @param options - 認証オプション。`failureRedirect: null` でリダイレクトを明示的にスキップ。
-     * @returns 認証済みユーザープロファイルとオプショナルな Set-Cookie 値。
+     * @returns 認証済みか未認証かを判別できる結果。
      */
-    const authenticateInLoader = async (request: Request, options: { failureRedirect: string } | { failureRedirect: null }): Promise<{ user?: MyGoogleProfile; cookie?: string }> => {
+    const resolveOutcome = async (request: Request): Promise<LoaderAuthOutcome> => {
         // DB 接続プールが確実にオープンするのを待ってから処理を開始する (E2E 等でのコールドスタート競合回避)
         if (config.warmup) {
             await config.warmup()
         }
 
-        const { failureRedirect } = options
         const session = await storage.getSession(request)
         const currentUser = await storage.getSessionUser(request)
 
         if (currentUser === undefined) {
-            if (failureRedirect === null) {
-                return {}
-            }
-            throw redirect(failureRedirect)
+            return { kind: "unauthenticated" }
         }
 
+        // try で覆うのは**認証そのもの**だけに限る。写真取得ポートやセッション保存まで含めると、
+        // DB プールの一時的な失敗が「認証失敗」に化け、有効なセッションを持つ利用者が
+        // 無関係な障害で再ログインを強いられる
+        let authenticatedTokens: Awaited<ReturnType<typeof authFns.authenticate>>
         try {
-            // トークンの有効期限を確認し、必要に応じて更新
-            const authenticatedTokens = await authFns.authenticate(request, session, {
-                failureRedirect: failureRedirect ?? undefined,
-            })
-
-            // 認証ペイロードの構築
-            const authenticationPayload: AuthenticationPayload = {
-                accessToken: authenticatedTokens.accessToken,
-                refreshToken: authenticatedTokens.refreshToken,
-                expirationDateMs: authenticatedTokens.expirationDateMs,
-                provider: currentUser.provider,
-            }
-            // セッション内のユーザ情報
-            const updatedSessionUser: SessionProfile = {
-                id: currentUser.id,
-                displayName: currentUser.displayName,
-                name: currentUser.name,
-                emails: currentUser.emails,
-                ...authenticationPayload,
-                role: currentUser.role,
+            // 常に null モードで呼ぶ。ここで失敗方針を渡すと結果がモード依存になり共有できない
+            authenticatedTokens = await authFns.authenticate(request, session, { failureRedirect: null })
+        } catch (error) {
+            if (error instanceof AuthRequiredError) {
+                // 認証失敗。セッション破棄を伴う経路では破棄 Set-Cookie を運ぶ
+                // (捨てると無効セッションがブラウザに残り続ける)
+                return error.setCookie !== undefined ? { kind: "unauthenticated", cookie: error.setCookie } : { kind: "unauthenticated" }
             }
+            // 認証失敗ではない予期せぬ失敗。セッションを破棄してログインへ飛ばすとインフラ障害が
+            // ログアウトに化けて真因が消えるため、どのモードでも素通しする
+            logger.error("Error in authenticateInLoader:", error)
+            throw error
+        }
 
-            // ユーザー写真をキャッシュまたはポートから取得
-            const photo = await getCachedOpenidPhoto(currentUser.id)
+        // ここから先は認証済み。写真取得やセッション保存の失敗は「認証失敗」ではないため畳まず、
+        // そのまま送出して呼び出し側 (ErrorBoundary / 500) に本当の原因を見せる
 
-            // ユーザープロファイル情報
-            const updatedUser: MyGoogleProfile = {
-                ...currentUser,
-                ...authenticationPayload,
-                photo,
-            }
+        // 認証ペイロードの構築
+        const authenticationPayload: AuthenticationPayload = {
+            accessToken: authenticatedTokens.accessToken,
+            refreshToken: authenticatedTokens.refreshToken,
+            expirationDateMs: authenticatedTokens.expirationDateMs,
+            provider: currentUser.provider,
+        }
+        // セッション内のユーザ情報
+        const updatedSessionUser: SessionProfile = {
+            id: currentUser.id,
+            displayName: currentUser.displayName,
+            name: currentUser.name,
+            emails: currentUser.emails,
+            ...authenticationPayload,
+            role: currentUser.role,
+        }
 
-            // トークンが更新 (リフレッシュ) された場合のみ、セッションを保存して Cookie ヘッダーを設定する
-            const isRefreshed = authenticatedTokens.accessToken !== currentUser.accessToken
-            const cookie = isRefreshed ? await storage.saveSession(request, updatedSessionUser) : undefined
+        // ユーザー写真をキャッシュまたはポートから取得
+        const photo = await getCachedOpenidPhoto(currentUser.id)
 
-            return { user: updatedUser, cookie }
-        } catch (error) {
-            if (error instanceof Response && error.headers.get("Location")) {
-                throw error
-            }
-            logger.error("Error in authenticateInLoader:", error)
-            // 認証エラー時はセッションを破棄してリダイレクト
-            if (failureRedirect !== null) {
-                // セッション破棄のみを try で保護する。redirect の throw を try 内に置くと
-                // 同じ catch(destroyError) に捕捉されて Set-Cookie 無しの fallback に差し替わってしまうため、
-                // throw redirect は必ず try の外で行う。
-                let destroyedCookie: string | undefined
-                try {
-                    destroyedCookie = await storage.destroySession(session)
-                } catch (destroyError) {
-                    logger.error("Failed to destroy session during auth error:", destroyError)
-                }
-                // 破棄に成功していれば Set-Cookie を付与し、失敗してもとにかくリダイレクトは試みる
-                throw destroyedCookie !== undefined ? redirect(failureRedirect, { headers: { "Set-Cookie": destroyedCookie } }) : redirect(failureRedirect)
-            }
-            throw error
+        // ユーザープロファイル情報
+        const updatedUser: MyGoogleProfile = {
+            ...currentUser,
+            ...authenticationPayload,
+            photo,
+        }
+
+        // トークンが更新 (リフレッシュ) された場合のみ、セッションを保存して Cookie ヘッダーを設定する
+        const isRefreshed = authenticatedTokens.accessToken !== currentUser.accessToken
+        const cookie = isRefreshed ? await storage.saveSession(request, updatedSessionUser) : undefined
+
+        return cookie !== undefined ? { kind: "authenticated", user: updatedUser, cookie } : { kind: "authenticated", user: updatedUser }
+    }
+
+    /**
+     * Returns the per-request authentication outcome, computing it at most once.
+     * リクエスト単位の認証結果を返す (計算は高々 1 回)。
+     *
+     * この関数を `async` にしてはならない。`get` と `set` の間に await 境界が入ると、
+     * 並行する 2 つの呼び出しが両方とも miss して二重認証に戻る。
+     *
+     * @param request - リクエストオブジェクト。
+     * @returns 共有される認証結果の Promise。
+     */
+    const sharedOutcome = (request: Request): Promise<LoaderAuthOutcome> => {
+        const cached = outcomeByRequest.get(request)
+        if (cached !== undefined) {
+            return cached
+        }
+        const pending = resolveOutcome(request)
+        outcomeByRequest.set(request, pending)
+        return pending
+    }
+
+    /**
+     * Handles authentication within loader requests, redirecting on any authentication failure.
+     * ローダーリクエスト内の認証処理 (認証失敗時は必ずリダイレクトを throw)。
+     *
+     * `failureRedirect` に文字列を渡した場合、認証失敗は例外 (redirect Response) として送出される
+     * ため、正常に戻った時点で `user` は必ず存在する。呼び出し側に到達不能な `!user` ガードを
+     * 書かせないよう、戻り値の `user` を必須として型付けする。
+     *
+     * 認証以外の失敗 (認証処理内部の予期せぬ例外・写真取得ポートの障害・セッション保存の失敗) は
+     * リダイレクトへ畳まず送出する。認証の可否とは無関係な障害であり、ログアウトに化けさせると
+     * 有効なセッションが失われたうえ真因も消える。
+     *
+     * @param request - リクエストオブジェクト。
+     * @param options - 認証オプション。`failureRedirect` は認証失敗時のリダイレクト先。
+     * @returns 認証済みユーザープロファイルとオプショナルな Set-Cookie 値。
+     */
+    async function authenticateInLoader(request: Request, options: { failureRedirect: string }): Promise<{ user: MyGoogleProfile; cookie?: string }>
+    /**
+     * Handles authentication within loader requests without ever redirecting.
+     * ローダーリクエスト内の認証処理 (リダイレクトを一切発生させない)。
+     *
+     * `failureRedirect: null` では全ての**認証**失敗経路が `{}` を返す。セッション破棄を伴う失敗
+     * (期限切れ + リフレッシュ失敗) では破棄 Set-Cookie を `cookie` に載せて返すため、呼び出し側は
+     * 未認証応答にもこれを転送すること (捨てると無効セッションがブラウザに残り続ける)。
+     *
+     * 認証以外の失敗は文字列モードと同じく送出する。両モードの観測可能な差はリダイレクトの
+     * 有無だけであり、それ以外に差を作らない。
+     *
+     * @param request - リクエストオブジェクト。
+     * @param options - 認証オプション。`failureRedirect: null` でリダイレクトを明示的にスキップ。
+     * @returns 未認証なら `user` を持たない結果、認証済みならユーザープロファイル。
+     */
+    async function authenticateInLoader(request: Request, options: { failureRedirect: null }): Promise<{ user?: MyGoogleProfile; cookie?: string }>
+    /**
+     * Implementation signature shared by both overloads (not part of the public API).
+     * 両オーバーロードが共有する実装シグネチャ (公開 API ではない)。
+     */
+    async function authenticateInLoader(request: Request, options: { failureRedirect: string } | { failureRedirect: null }): Promise<{ user?: MyGoogleProfile; cookie?: string }> {
+        const { failureRedirect } = options
+        // 空文字は「既定でよい」という表明ではなく取り違えである。既定へ倒すと意図しない遷移先を
+        // 黙って使うことになるため、認証の成否を待たず入口で失敗させる
+        if (failureRedirect === "") {
+            throw new TypeError("failureRedirect must not be an empty string; pass null to skip redirecting")
+        }
+
+        const outcome = await sharedOutcome(request)
+        if (outcome.kind === "authenticated") {
+            return outcome.cookie !== undefined ? { user: outcome.user, cookie: outcome.cookie } : { user: outcome.user }
+        }
+
+        // 未認証。ここから先が呼び出し元ごとの失敗方針であり、共有される作業には含めない
+        if (failureRedirect === null) {
+            return outcome.cookie !== undefined ? { cookie: outcome.cookie } : {}
         }
+        throw outcome.cookie !== undefined ? redirect(failureRedirect, { headers: { "Set-Cookie": outcome.cookie } }) : redirect(failureRedirect)
     }
 
     return authenticateInLoader

package/src/server/authenticate.ts

@@ -31,6 +31,25 @@ export class GoogleInvalidGrantError extends TokenRefreshError {
     }
 }
 
+/**
+ * Signals that authentication is required when the caller opted out of redirecting.
+ * 呼び出し側がリダイレクトを拒否した (`failureRedirect: null`) 際に認証要求を伝えるエラー。
+ *
+ * `redirect()` を投げてしまうと React Router がそれを本物の 302 として扱うため、
+ * 「リダイレクトしない」という契約を型で表現できるこのエラーへ置き換える。
+ * セッション破棄が発生した場合はその `Set-Cookie` を `setCookie` で運ぶ
+ * (捨てると無効セッションがブラウザに残り続ける)。
+ */
+export class AuthRequiredError extends Error {
+    readonly setCookie?: string
+
+    constructor(setCookie?: string) {
+        super("Authentication required")
+        this.name = "AuthRequiredError"
+        this.setCookie = setCookie
+    }
+}
+
 /** createAuthenticate が返す認証関数束。 */
 export type AuthenticateFns = ReturnType<typeof createAuthenticate>
 
@@ -124,8 +143,24 @@ export const createAuthenticate = (config: AuthServerConfig, storage: AuthSessio
      * Validates session tokens, refreshing them when expired; destroys the session on refresh failure.
      * セッショントークンを検証し、期限切れならリフレッシュする。失敗時はセッションを破棄する。
      */
-    const authenticate = async (request: Request, session: Session, options?: { failureRedirect?: string }) => {
+    const authenticate = async (request: Request, session: Session, options?: { failureRedirect?: string | null }) => {
         const { failureRedirect } = options || {}
+
+        // failureRedirect が null のときはリダイレクトを作らず AuthRequiredError を投げる。
+        // undefined / 文字列のときは従来どおり redirect() を投げる。
+        const authFailure = (setCookie?: string) => {
+            if (failureRedirect === null) {
+                return new AuthRequiredError(setCookie)
+            }
+            // 未指定 (undefined) は「既定のログイン先で良い」という表明なので loginPath へ倒す。
+            // 空文字は表明ではなく取り違えであり、既定へ倒すと意図しない遷移先を黙って使うことに
+            // なるため失敗させる (`||` で両者を同一視しない)
+            if (failureRedirect === "") {
+                throw new TypeError("failureRedirect must not be an empty string; pass null to skip redirecting")
+            }
+            const target = failureRedirect ?? loginPath
+            return setCookie !== undefined ? redirect(target, { headers: { "Set-Cookie": setCookie } }) : redirect(target)
+        }
         try {
             // テストバックドア (ポート注入時のみ有効)
             if (config.mockUser?.enabled(request)) {
@@ -139,7 +174,7 @@ export const createAuthenticate = (config: AuthServerConfig, storage: AuthSessio
             // セッションから認証データを取得
             const user = session.get(sessionKey)
             if (!(user?.accessToken && user.expirationDateMs)) {
-                throw redirect(failureRedirect || loginPath)
+                throw authFailure()
             }
 
             const { accessToken, refreshToken, expirationDateMs } = user
@@ -147,8 +182,8 @@ export const createAuthenticate = (config: AuthServerConfig, storage: AuthSessio
             // 期限切れならエラーを投げてリフレッシュ経路へ
             if (expirationDateMs < Date.now()) {
                 if (!refreshToken) {
-                    // リフレッシュトークンがない場合は更新できないのでログインページへ
-                    throw redirect(failureRedirect || loginPath)
+                    // リフレッシュトークンがない場合は更新できないので認証失敗として扱う
+                    throw authFailure()
                 }
                 throw new Error("Expired")
             }
@@ -176,9 +211,7 @@ export const createAuthenticate = (config: AuthServerConfig, storage: AuthSessio
                     }
                     // リフレッシュに失敗した場合はセッションを破棄してログインページへ
                     const cookie = await storage.destroySession(session)
-                    throw redirect(failureRedirect || loginPath, {
-                        headers: { "Set-Cookie": cookie },
-                    })
+                    throw authFailure(cookie)
                 }
             }
 

package/src/server.ts

@@ -5,7 +5,7 @@
 
 export type { AuthServer } from "./server/auth-server"
 export { createAuthServer } from "./server/auth-server"
-export { createAuthenticate, GoogleInvalidGrantError, TokenRefreshError } from "./server/authenticate"
+export { AuthRequiredError, createAuthenticate, GoogleInvalidGrantError, TokenRefreshError } from "./server/authenticate"
 export { createAuthenticateInLoader } from "./server/authenticate-in-loader"
 export { createGoogleAuthenticator } from "./server/google-strategy"
 export { createAuthHandlers } from "./server/handlers"