@aiquants/auth-react-router 0.4.0 → 0.5.0

package/src/admin.ts

@@ -0,0 +1,5 @@
+/**
+ * @aiquants/auth-react-router/admin — user administration UI and store adapters.
+ * ユーザー管理 UI およびストアアダプタのバレル。
+ */
+export * from "./admin/app"

package/src/server/auth-server.ts

@@ -29,6 +29,7 @@ export const createAuthServer = (config: AuthServerConfig) => {
         mockUser: config.mockUser,
         loginPath: config.loginPath,
         postLoginRedirect: config.postLoginRedirect,
+        isUserActive: config.isUserActive,
     })
 
     // Google 認証器 (verify コールバックはポート結線済み)

package/src/server/google-strategy-impl.spec.ts

@@ -56,6 +56,14 @@ describe("authorizationParams", () => {
         expect(params.get("access_type")).toBe("offline")
         expect(params.get("include_granted_scopes")).toBe("true")
         expect(params.get("prompt")).toBe("consent")
+        expect(params.get("scope")).toBe("openid https://www.googleapis.com/auth/userinfo.profile https://www.googleapis.com/auth/userinfo.email")
+    })
+
+    it("formats multiple scopes cleanly with space separation including custom scopes like drive.readonly", () => {
+        const customScopes = ["openid", "email", "https://www.googleapis.com/auth/drive.readonly"] as const
+        // biome-ignore lint/suspicious/noExplicitAny: Custom scopes for testing
+        const params = makeProbe({ scopes: customScopes as any }).exposeAuthorizationParams(new URLSearchParams())
+        expect(params.get("scope")).toBe("openid email https://www.googleapis.com/auth/drive.readonly")
     })
 
     it("sets hd and login_hint only when provided", () => {

package/src/server/google-strategy-impl.ts

@@ -72,6 +72,7 @@ type OAuth2AccessTokenSource = { accessToken(): string }
  */
 export class GoogleStrategy<User> extends OAuth2Strategy<User> {
     name = GoogleStrategyDefaultName
+    private readonly scopes: GoogleScope[]
     private readonly accessType: "online" | "offline"
     private readonly prompt?: "none" | "consent" | "select_account"
     private readonly includeGrantedScopes: boolean
@@ -79,6 +80,7 @@ export class GoogleStrategy<User> extends OAuth2Strategy<User> {
     private readonly loginHint?: string
 
     constructor({ clientId, clientSecret, redirectURI, scopes, accessType, includeGrantedScopes, prompt, hd, loginHint }: GoogleStrategyOptions, verify: OAuth2Strategy<User>["verify"]) {
+        const scopeList = scopes ?? GoogleStrategyDefaultScopes
         super(
             {
                 clientId,
@@ -86,10 +88,11 @@ export class GoogleStrategy<User> extends OAuth2Strategy<User> {
                 redirectURI,
                 authorizationEndpoint: "https://accounts.google.com/o/oauth2/v2/auth",
                 tokenEndpoint: "https://oauth2.googleapis.com/token",
-                scopes: scopes ?? GoogleStrategyDefaultScopes,
+                scopes: scopeList,
             },
             verify,
         )
+        this.scopes = scopeList
         this.accessType = accessType ?? "online"
         this.includeGrantedScopes = includeGrantedScopes ?? false
         this.prompt = prompt
@@ -104,6 +107,9 @@ export class GoogleStrategy<User> extends OAuth2Strategy<User> {
     protected authorizationParams(params: URLSearchParams, _request?: Request): URLSearchParams {
         params.set("access_type", this.accessType)
         params.set("include_granted_scopes", String(this.includeGrantedScopes))
+        if (this.scopes && this.scopes.length > 0) {
+            params.set("scope", this.scopes.join(" "))
+        }
         if (this.prompt) {
             params.set("prompt", this.prompt)
         }

package/src/server/google-strategy.spec.ts

@@ -184,6 +184,62 @@ describe("verify callback", () => {
         expect(signup).not.toHaveBeenCalled()
     })
 
+    // ⚠️ 回帰ガード: `isEmailAllowed` は非同期実装を許すため、呼び出し側の `await` が外れると
+    //    `!Promise` が常に false となり **許可判定を素通り (fail-open)** する。型検査では検出できない。
+    it("REGRESSION GUARD: an ASYNC deny predicate must still block (missing await would fail OPEN)", async () => {
+        const signup = vi.fn(async () => ({}))
+        createGoogleAuthenticator(makeConfig({ isEmailAllowed: async () => false, backendAuth: { verify: async () => true, signup } }))
+        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
+        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.notAllowed)}`)
+        expect(signup).not.toHaveBeenCalled()
+    })
+
+    it("an ASYNC allow predicate lets the login through (await resolves the value, not the Promise)", async () => {
+        const allowlist = vi.fn(async () => true)
+        createGoogleAuthenticator(makeConfig({ isEmailAllowed: allowlist }))
+        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
+        expect(user?.photo).toBe("https://example.com/p.png")
+        expect(allowlist).toHaveBeenCalledWith("user@example.com")
+    })
+
+    it("a REJECTING allowlist (e.g. database unreachable) fails CLOSED", async () => {
+        const signup = vi.fn(async () => ({}))
+        createGoogleAuthenticator(
+            makeConfig({
+                isEmailAllowed: async () => {
+                    throw new Error("ECONNREFUSED sql")
+                },
+                backendAuth: { verify: async () => true, signup },
+            }),
+        )
+        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
+        // 許可されない以上ログインは成立しない (メッセージは汎用エラー)
+        expect(location).toContain("/auth/login?error=")
+        expect(signup).not.toHaveBeenCalled()
+    })
+
+    it("REGRESSION GUARD: a DEACTIVATED account cannot sign in even when the allowlist permits it", async () => {
+        const signup = vi.fn(async () => ({}))
+        createGoogleAuthenticator(makeConfig({ isEmailAllowed: () => true, isUserActive: async () => false, backendAuth: { verify: async () => true, signup } }))
+        const location = await expectLoginRedirect(captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() }) as Promise<unknown>)
+        expect(location).toBe(`/auth/login?error=${encodeURIComponent(defaultAuthMessages.notAllowed)}`)
+        expect(signup).not.toHaveBeenCalled()
+    })
+
+    it("an ACTIVE account signs in normally, and the port receives the profile", async () => {
+        const isUserActive = vi.fn(async () => true)
+        createGoogleAuthenticator(makeConfig({ isUserActive }))
+        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
+        expect(user?.photo).toBe("https://example.com/p.png")
+        expect(isUserActive).toHaveBeenCalledWith(expect.objectContaining({ emails: [{ value: "user@example.com" }] }))
+    })
+
+    it("omitting isUserActive keeps the previous behaviour", async () => {
+        createGoogleAuthenticator(makeConfig({}))
+        const user = await captured.verify?.({ request: new Request("http://localhost/"), tokens: tokens() })
+        expect(user?.photo).toBe("https://example.com/p.png")
+    })
+
     it("redirects with unexpected on generic signup failure", async () => {
         createGoogleAuthenticator(
             makeConfig({

package/src/server/google-strategy.ts

@@ -102,13 +102,22 @@ export const createGoogleAuthenticator = (config: AuthServerConfig): Authenticat
                 }
 
                 // メールアドレスまたはドメインベースでのアクセス制限チェック (論理和は allowlist 実装側)
+                // ⚠️ `await` 必須。非同期実装を await せずに評価すると Promise が truthy 判定され
+                //    許可判定を素通りする (fail-open)。この await は spec で門番されている。
                 const userEmail = profile.emails[0]?.value
-                if (!config.isEmailAllowed(userEmail)) {
+                if (!(await config.isEmailAllowed(userEmail))) {
                     const error = new Error("You are not allowed to access this application")
                     logger.error(error)
                     throw error
                 }
 
+                // 無効化済みアカウントはログインさせない (allowlist とは別軸の判定)
+                if (config.isUserActive && !(await config.isUserActive(profile))) {
+                    const error = new Error("You are not allowed to access this application")
+                    logger.error("Deactivated account attempted to sign in:", userEmail)
+                    throw error
+                }
+
                 // バックエンドでのサインアップ処理 (毎ログイン実行の挙動を保存)
                 if (config.backendAuth) {
                     await config.backendAuth.signup(provider, accessToken)

package/src/server/ports.ts

@@ -6,7 +6,7 @@
  * アプリ固有の結合 (env・backend HTTP・DB 由来の写真解決・DB ウォームアップ・テストバックドア) は
  * すべてここで定義するポートとして注入する。パッケージ内には汎用ロジックだけを置く。
  */
-import type { AuthMessages, SessionProfile } from "@aiquants/auth-core"
+import type { AuthMessages, GoogleProfileBase, SessionProfile } from "@aiquants/auth-core"
 
 /** OAuth Google の資格情報とオプション (scopes はアプリ注入 — sanledge が拡張)。 */
 export type GoogleOAuthConfig = {
@@ -41,7 +41,7 @@ export type BackendAuthPort = {
     signup: (provider: string, accessToken: string) => Promise<unknown>
 }
 
-/** ユーザー写真解決ポート (drizzle TDOpenid 等はアプリ側)。キャッシュ + dedup はパッケージ内。 */
+/** ユーザー写真解決ポート (DB 参照等の実装はアプリ側)。キャッシュ + dedup はパッケージ内。 */
 export type UserPhotoPort = (openid: string) => Promise<string>
 
 /** 毎リクエストの DB 接続ウォームアップ (quants は 2 プール、sanledge は 1 プール)。 */
@@ -66,8 +66,26 @@ export type LoggerPort = {
 export type AuthServerConfig = {
     google: GoogleOAuthConfig
     session: SessionConfig
-    /** allowlist 判定 (auth-core の emailDomainAllowlist を推奨)。 */
-    isEmailAllowed: (email: string | null | undefined) => boolean
+    /**
+     * allowlist 判定 (auth-core の `emailDomainAllowlist` を推奨)。
+     *
+     * 非同期を許すのは、環境変数に加えてデータベース等の可変な供給元を参照する構成のため。
+     * ⚠️ 呼び出し側は必ず `await` すること。`Promise` は常に truthy なので `if (!fn(email))`
+     *    のまま非同期実装を渡すと **判定が素通りして fail-open** になる (型検査では検出できない)。
+     */
+    isEmailAllowed: (email: string | null | undefined) => boolean | Promise<boolean>
+    /**
+     * Account-status port: return `false` ONLY for a known-deactivated account.
+     * アカウント状態ポート。**無効化済みと判明した場合のみ** `false` を返す。
+     *
+     * allowlist が「そのメールアドレスがこのアプリを使ってよいか」を判定するのに対し、こちらは
+     * 「そのアカウントが現在有効か」を判定する。ログイン時と **毎リクエストのセッション解決時** の
+     * 双方で参照されるため、無効化は既存セッションに対しても即座に効く。
+     *
+     * 未登録ユーザー (初回ログインでこれから作成される) では `true` を返すこと。`false` を返すと
+     * サインアップ経路ごと塞いでしまう。省略時は常に有効として扱う (既存構成の挙動を変えない)。
+     */
+    isUserActive?: (profile: GoogleProfileBase) => boolean | Promise<boolean>
     /** バックエンド verify/signup。省略時はスキップ (フロント単独運用)。 */
     backendAuth?: BackendAuthPort
     /** ユーザー写真解決。省略時は常に空文字。 */

package/src/server/session.spec.ts

@@ -111,3 +111,55 @@ describe("createAuthSessionStorage", () => {
         expect(destroyed).toContain("Expires=Thu, 01 Jan 1970")
     })
 })
+
+/**
+ * 無効化済みアカウントの即時失効。
+ * `getSessionUser` は `requireUser` と `authenticateInLoader` の双方が通る唯一の絞り込み点であり、
+ * ここで弾くことで既存セッション Cookie を持っていても全ルートで未認証扱いになる。
+ */
+describe("createAuthSessionStorage — isUserActive による無効化の即時反映", () => {
+    const profile = { id: "sub-1", displayName: "U", name: { familyName: "U", givenName: "U" }, emails: [{ value: "u@example.com" }] } as never
+
+    /** セッション Cookie を持つリクエストを組み立てる。 */
+    const requestWithSession = async (storage: ReturnType<typeof createAuthSessionStorage>) => {
+        const cookie = await storage.saveSession(new Request("http://x/"), profile)
+        return new Request("http://x/", { headers: { Cookie: cookie.split(";")[0] } })
+    }
+
+    it("有効なアカウントはこれまでどおりセッションから解決される", async () => {
+        const storage = createAuthSessionStorage({ secrets: [SECRET] }, { isUserActive: () => true })
+        expect(await storage.getSessionUser(await requestWithSession(storage))).toMatchObject({ id: "sub-1" })
+    })
+
+    it("無効化済みアカウントは有効な Cookie を持っていても未認証として扱われる", async () => {
+        const storage = createAuthSessionStorage({ secrets: [SECRET] }, { isUserActive: () => false })
+        expect(await storage.getSessionUser(await requestWithSession(storage))).toBeUndefined()
+    })
+
+    it("無効化済みなら requireUser はログインへリダイレクトする", async () => {
+        const storage = createAuthSessionStorage({ secrets: [SECRET] }, { isUserActive: async () => false })
+        const request = await requestWithSession(storage)
+        await expect(storage.requireUser(request)).rejects.toBeInstanceOf(Response)
+    })
+
+    it("ポート未指定なら従来どおり (既存構成の挙動を変えない)", async () => {
+        const storage = createAuthSessionStorage({ secrets: [SECRET] })
+        expect(await storage.getSessionUser(await requestWithSession(storage))).toMatchObject({ id: "sub-1" })
+    })
+
+    it("ポートには解決したプロファイルが渡される", async () => {
+        const seen: unknown[] = []
+        const storage = createAuthSessionStorage(
+            { secrets: [SECRET] },
+            {
+                isUserActive: (p) => {
+                    seen.push(p)
+                    return true
+                },
+            },
+        )
+        await storage.getSessionUser(await requestWithSession(storage))
+        expect(seen).toHaveLength(1)
+        expect(seen[0]).toMatchObject({ id: "sub-1" })
+    })
+})

package/src/server/session.ts

@@ -8,7 +8,7 @@
  * (2) テストバックドア (mock_user cookie) をハードコードから `mockUser` ポート注入に変えた、
  * の 2 点のみ。cookie 形状 (`__session`/httpOnly/lax/30d、キー "user") は byte 互換。
  */
-import type { SessionProfile } from "@aiquants/auth-core"
+import type { GoogleProfileBase, SessionProfile } from "@aiquants/auth-core"
 import { createCookieSessionStorage, redirect } from "react-router"
 import type { MockUserPort, SessionConfig } from "./ports"
 
@@ -21,7 +21,7 @@ export type AuthSessionStorage = ReturnType<typeof createAuthSessionStorage>
  *
  * @throws secrets が空の場合 (fail-closed の設定ガード)。
  */
-export const createAuthSessionStorage = (config: SessionConfig, options?: { mockUser?: MockUserPort; loginPath?: string; postLoginRedirect?: string }) => {
+export const createAuthSessionStorage = (config: SessionConfig, options?: { mockUser?: MockUserPort; loginPath?: string; postLoginRedirect?: string; isUserActive?: (profile: GoogleProfileBase) => boolean | Promise<boolean> }) => {
     // ファクトリ実行時検証 (import 時副作用の排除)
     if (!config.secrets || config.secrets.length === 0 || config.secrets.some((s) => !s)) {
         throw new Error("REMIX_SESSION_SECRET must be set")
@@ -32,6 +32,7 @@ export const createAuthSessionStorage = (config: SessionConfig, options?: { mock
     const loginPath = options?.loginPath ?? "/auth/login"
     const postLoginRedirect = options?.postLoginRedirect ?? "/"
     const mockUser = options?.mockUser
+    const isUserActive = options?.isUserActive
 
     const sessionStorage = createCookieSessionStorage({
         cookie: {
@@ -65,6 +66,10 @@ export const createAuthSessionStorage = (config: SessionConfig, options?: { mock
 
         const session = await getSession(request)
         const user = session.get(sessionKey) as SessionProfile | undefined
+        if (user === undefined) return undefined
+        // 無効化済みアカウントは「未認証」として扱う。これにより、既に発行済みのセッション Cookie を
+        // 持っていてもガードは通らず、無効化がその場で全ルートへ波及する。
+        if (isUserActive && !(await isUserActive(user))) return undefined
         return user
     }