@auth-gate/react 0.1.0

package/dist/server.d.ts

@@ -0,0 +1,316 @@
+import * as hono_hono_base from 'hono/hono-base';
+import * as hono_utils_http_status from 'hono/utils/http-status';
+import * as hono_types from 'hono/types';
+import { AuthGateConfig } from '@auth-gate/core';
+
+/**
+ * Configuration for {@link createAuthRoutes}.
+ * Extends {@link AuthGateConfig} with the app's public URL.
+ */
+interface AuthRoutesOptions extends AuthGateConfig {
+    /** Your app's public URL (e.g. `"http://localhost:5173"`). Used to build callback URLs. */
+    appUrl: string;
+}
+/**
+ * Create a Hono router with all AuthGate auth endpoints.
+ *
+ * Mount the returned router at `/api/auth` (or any prefix you prefer):
+ *
+ * @example
+ * ```ts
+ * import { Hono } from "hono";
+ * import { createAuthRoutes } from "@auth-gate/react/server";
+ *
+ * const app = new Hono();
+ * const auth = createAuthRoutes({
+ *   apiKey: process.env.AUTHGATE_API_KEY!,
+ *   projectId: process.env.AUTHGATE_PROJECT_ID!,
+ *   baseUrl: process.env.AUTHGATE_URL!,
+ *   sessionSecret: process.env.SESSION_SECRET!,
+ *   appUrl: "http://localhost:5173",
+ * });
+ *
+ * app.route("/api/auth", auth);
+ * ```
+ *
+ * @param options - AuthGate config plus `appUrl`.
+ * @returns A Hono router instance with all auth routes.
+ */
+declare function createAuthRoutes(options: AuthRoutesOptions): hono_hono_base.HonoBase<hono_types.BlankEnv, {
+    "/:provider/login": {
+        $get: {
+            input: {
+                param: {
+                    provider: string;
+                };
+            };
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {
+                param: {
+                    provider: string;
+                };
+            };
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        };
+    };
+} & {
+    "/callback": {
+        $get: {
+            input: {};
+            output: undefined;
+            outputFormat: "redirect";
+            status: 302;
+        };
+    };
+} & {
+    "/email/signup": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                success: true;
+                redirect: string;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/email/signin": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                mfa_required: true;
+                mfa_challenge: any;
+                mfa_methods: any;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                success: true;
+                redirect: string;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/email/forgot-password": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/email/reset-password": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                success: true;
+                redirect: string;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/email/verify-code": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                success: true;
+                email_verified: true;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/magic-link/send": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/sms/send-code": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/sms/verify-code": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                success: true;
+                redirect: string;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/me": {
+        $get: {
+            input: {};
+            output: {
+                user: null;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        } | {
+            input: {};
+            output: {
+                user: {
+                    id: string;
+                    email: string | null;
+                    phone: string | null;
+                    name: string | null;
+                    picture: string | null;
+                    provider: string;
+                };
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/mfa/verify": {
+        $post: {
+            input: {};
+            output: {};
+            outputFormat: "json";
+            status: 400;
+        } | {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                success: true;
+                redirect: string;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/refresh": {
+        $post: {
+            input: {};
+            output: {
+                error: string;
+            };
+            outputFormat: "json";
+            status: 401;
+        } | {
+            input: {};
+            output: {
+                success: true;
+                token: string;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+} & {
+    "/logout": {
+        $post: {
+            input: {};
+            output: {
+                success: true;
+            };
+            outputFormat: "json";
+            status: hono_utils_http_status.ContentfulStatusCode;
+        };
+    };
+}, "/", "/logout">;
+
+export { type AuthRoutesOptions, createAuthRoutes };

package/dist/server.mjs

@@ -0,0 +1,326 @@
+// src/server.ts
+import { Hono } from "hono";
+import { getCookie, setCookie, deleteCookie } from "hono/cookie";
+import {
+  createAuthGateClient,
+  SUPPORTED_PROVIDERS
+} from "@auth-gate/core";
+function createAuthRoutes(options) {
+  const client = createAuthGateClient(options);
+  const appUrl = options.appUrl;
+  async function setSessionCookie(c, user) {
+    const encrypted = await client.encryptSession(user);
+    const opts = client.getSessionCookieOptions();
+    setCookie(c, client.cookieName, encrypted, {
+      httpOnly: opts.httpOnly,
+      secure: opts.secure,
+      sameSite: opts.sameSite === "lax" ? "Lax" : opts.sameSite === "strict" ? "Strict" : "None",
+      maxAge: opts.maxAge,
+      path: opts.path
+    });
+  }
+  async function getSessionUser(c) {
+    const cookie = getCookie(c, client.cookieName);
+    if (!cookie) return null;
+    return client.decryptSession(cookie);
+  }
+  const routes = new Hono().get("/:provider/login", async (c) => {
+    const provider = c.req.param("provider");
+    if (!SUPPORTED_PROVIDERS.includes(provider)) {
+      return c.json({ error: "Unsupported provider" }, 400);
+    }
+    const { state, nonce } = await client.createState();
+    const nonceOpts = client.getNonceCookieOptions();
+    setCookie(c, client.nonceCookieName, nonce, {
+      httpOnly: nonceOpts.httpOnly,
+      secure: nonceOpts.secure,
+      sameSite: nonceOpts.sameSite === "lax" ? "Lax" : nonceOpts.sameSite === "strict" ? "Strict" : "None",
+      maxAge: nonceOpts.maxAge,
+      path: nonceOpts.path
+    });
+    const callbackUrl = `${appUrl}${client.callbackPath}`;
+    const authUrl = new URL(
+      client.getOAuthUrl(provider, callbackUrl)
+    );
+    authUrl.searchParams.set("state", state);
+    return c.redirect(authUrl.toString());
+  }).get("/callback", async (c) => {
+    var _a;
+    const token = c.req.query("token");
+    const state = c.req.query("state");
+    const mfaChallenge = c.req.query("mfa_challenge");
+    const mfaMethods = c.req.query("mfa_methods");
+    const mfaSetupRequired = c.req.query("mfa_setup_required");
+    const refreshTokenParam = c.req.query("refresh_token");
+    if (mfaChallenge) {
+      const mfaUrl = new URL("/mfa-verify", appUrl);
+      mfaUrl.searchParams.set("mfa_challenge", mfaChallenge);
+      if (mfaMethods) mfaUrl.searchParams.set("mfa_methods", mfaMethods);
+      return c.redirect(mfaUrl.toString());
+    }
+    if (!token) {
+      return c.redirect(`${appUrl}/login?error=missing_token`);
+    }
+    if (state) {
+      const nonce = (_a = getCookie(c, client.nonceCookieName)) != null ? _a : "";
+      deleteCookie(c, client.nonceCookieName, { path: "/" });
+      if (!await client.verifyState(state, nonce)) {
+        return c.redirect(`${appUrl}/login?error=invalid_state`);
+      }
+    }
+    const result = await client.verifyToken(token);
+    if (!result.valid || !result.user) {
+      return c.redirect(`${appUrl}/login?error=invalid_token`);
+    }
+    await setSessionCookie(c, result.user);
+    if (refreshTokenParam) {
+      setCookie(c, client.refreshTokenCookieName, refreshTokenParam, {
+        httpOnly: true,
+        secure: process.env.NODE_ENV === "production",
+        sameSite: "Lax",
+        maxAge: client.sessionMaxAge,
+        path: "/"
+      });
+    }
+    if (mfaSetupRequired) {
+      return c.redirect(`${appUrl}/mfa-setup`);
+    }
+    return c.redirect(`${appUrl}/dashboard`);
+  }).post("/email/signup", async (c) => {
+    const body = await c.req.json();
+    const { email, password, name } = body;
+    if (!email || !password) {
+      return c.json({ error: "Missing email or password" }, 400);
+    }
+    const response = await client.emailSignup({
+      email,
+      password,
+      name,
+      callbackUrl: `${appUrl}${client.callbackPath}`
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    const data = await response.json().catch(() => ({ error: "Request failed" }));
+    const verified = await client.verifyToken(data.token);
+    if (!verified.valid || !verified.user) {
+      return c.json({ error: "Token verification failed" }, 401);
+    }
+    await setSessionCookie(c, verified.user);
+    return c.json({ success: true, redirect: "/dashboard" });
+  }).post("/email/signin", async (c) => {
+    const body = await c.req.json();
+    const { email, password } = body;
+    if (!email || !password) {
+      return c.json({ error: "Missing email or password" }, 400);
+    }
+    const response = await client.emailSignin({
+      email,
+      password,
+      callbackUrl: `${appUrl}${client.callbackPath}`
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    const data = await response.json().catch(() => ({ error: "Request failed" }));
+    if (data.mfa_required) {
+      return c.json({
+        mfa_required: true,
+        mfa_challenge: data.mfa_challenge,
+        mfa_methods: data.mfa_methods
+      });
+    }
+    const verified = await client.verifyToken(data.token);
+    if (!verified.valid || !verified.user) {
+      return c.json({ error: "Token verification failed" }, 401);
+    }
+    await setSessionCookie(c, verified.user);
+    if (data.refresh_token) {
+      setCookie(c, client.refreshTokenCookieName, data.refresh_token, {
+        httpOnly: true,
+        secure: process.env.NODE_ENV === "production",
+        sameSite: "Lax",
+        maxAge: client.sessionMaxAge,
+        path: "/"
+      });
+    }
+    return c.json({
+      success: true,
+      redirect: data.mfa_setup_required ? "/mfa-setup" : "/dashboard"
+    });
+  }).post("/email/forgot-password", async (c) => {
+    const body = await c.req.json();
+    const { email } = body;
+    if (!email) {
+      return c.json({ error: "Missing email" }, 400);
+    }
+    const response = await client.emailForgotPassword({
+      email,
+      callbackUrl: `${appUrl}/reset-password`
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    return c.json({ success: true });
+  }).post("/email/reset-password", async (c) => {
+    const body = await c.req.json();
+    const { token, password } = body;
+    if (!token || !password) {
+      return c.json({ error: "Missing token or password" }, 400);
+    }
+    const response = await client.emailResetPassword({ token, password });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    const data = await response.json().catch(() => ({ error: "Request failed" }));
+    if (data.token) {
+      const verified = await client.verifyToken(data.token);
+      if (verified.valid && verified.user) {
+        await setSessionCookie(c, verified.user);
+        return c.json({ success: true, redirect: "/dashboard" });
+      }
+    }
+    return c.json({ success: true, redirect: "/login" });
+  }).post("/email/verify-code", async (c) => {
+    const body = await c.req.json();
+    const { email, code } = body;
+    if (!email || !code) {
+      return c.json({ error: "Missing email or code" }, 400);
+    }
+    const response = await client.emailVerifyCode({ email, code });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    return c.json({ success: true, email_verified: true });
+  }).post("/magic-link/send", async (c) => {
+    const body = await c.req.json();
+    const { email } = body;
+    if (!email) {
+      return c.json({ error: "Missing email" }, 400);
+    }
+    const response = await client.magicLinkSend({
+      email,
+      callbackUrl: `${appUrl}${client.callbackPath}`
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    return c.json({ success: true });
+  }).post("/sms/send-code", async (c) => {
+    const body = await c.req.json();
+    const { phone } = body;
+    if (!phone) {
+      return c.json({ error: "Missing phone number" }, 400);
+    }
+    const response = await client.smsSendCode({
+      phone,
+      callbackUrl: `${appUrl}${client.callbackPath}`
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    return c.json({ success: true });
+  }).post("/sms/verify-code", async (c) => {
+    const body = await c.req.json();
+    const { phone, code } = body;
+    if (!phone || !code) {
+      return c.json({ error: "Missing phone or code" }, 400);
+    }
+    const response = await client.smsVerifyCode({
+      phone,
+      code,
+      callbackUrl: `${appUrl}${client.callbackPath}`
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    const data = await response.json().catch(() => ({ error: "Request failed" }));
+    const verified = await client.verifyToken(data.token);
+    if (!verified.valid || !verified.user) {
+      return c.json({ error: "Token verification failed" }, 401);
+    }
+    await setSessionCookie(c, verified.user);
+    return c.json({ success: true, redirect: "/dashboard" });
+  }).get("/me", async (c) => {
+    const user = await getSessionUser(c);
+    if (!user) {
+      return c.json({ user: null });
+    }
+    const refreshCookie = getCookie(c, client.refreshTokenCookieName);
+    if (refreshCookie) {
+      const result = await client.refreshToken(refreshCookie);
+      if (!result) {
+        deleteCookie(c, client.cookieName, { path: "/" });
+        deleteCookie(c, client.refreshTokenCookieName, { path: "/" });
+        return c.json({ user: null });
+      }
+      const verified = await client.verifyToken(result.token);
+      if (verified.valid && verified.user) {
+        await setSessionCookie(c, verified.user);
+        return c.json({ user: verified.user });
+      }
+    }
+    return c.json({ user });
+  }).post("/mfa/verify", async (c) => {
+    const body = await c.req.json();
+    const { challenge, code, method } = body;
+    if (!challenge || !code || !method) {
+      return c.json({ error: "Missing challenge, code, or method" }, 400);
+    }
+    const response = await client.mfaVerify({ challenge, code, method });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Request failed" }));
+      return c.json(error, response.status);
+    }
+    const data = await response.json();
+    const verified = await client.verifyToken(data.token);
+    if (!verified.valid || !verified.user) {
+      return c.json({ error: "Token verification failed" }, 401);
+    }
+    await setSessionCookie(c, verified.user);
+    if (data.refresh_token) {
+      setCookie(c, client.refreshTokenCookieName, data.refresh_token, {
+        httpOnly: true,
+        secure: process.env.NODE_ENV === "production",
+        sameSite: "Lax",
+        maxAge: client.sessionMaxAge,
+        path: "/"
+      });
+    }
+    return c.json({ success: true, redirect: "/dashboard" });
+  }).post("/refresh", async (c) => {
+    const refreshCookie = getCookie(c, client.refreshTokenCookieName);
+    if (!refreshCookie) {
+      return c.json({ error: "No refresh token" }, 401);
+    }
+    const result = await client.refreshToken(refreshCookie);
+    if (!result) {
+      return c.json({ error: "Invalid refresh token" }, 401);
+    }
+    const verified = await client.verifyToken(result.token);
+    if (verified.valid && verified.user) {
+      await setSessionCookie(c, verified.user);
+    }
+    return c.json({ success: true, token: result.token });
+  }).post("/logout", async (c) => {
+    const refreshCookie = getCookie(c, client.refreshTokenCookieName);
+    if (refreshCookie) {
+      await client.revokeSession(refreshCookie);
+      deleteCookie(c, client.refreshTokenCookieName, { path: "/" });
+    }
+    deleteCookie(c, client.cookieName, { path: "/" });
+    return c.json({ success: true });
+  });
+  return routes;
+}
+export {
+  createAuthRoutes
+};

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@auth-gate/react",
+  "version": "0.1.0",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs"
+    },
+    "./server": {
+      "types": "./dist/server.d.ts",
+      "import": "./dist/server.mjs",
+      "require": "./dist/server.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@auth-gate/core": "0.1.0"
+  },
+  "peerDependencies": {
+    "react": ">=18",
+    "hono": ">=4"
+  },
+  "devDependencies": {
+    "react": "^19.0.0",
+    "@types/react": "^19",
+    "hono": "^4.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
+  }
+}