@auth-gate/react 0.1.0

package/dist/server.cjs

@@ -0,0 +1,348 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/server.ts
+var server_exports = {};
+__export(server_exports, {
+  createAuthRoutes: () => createAuthRoutes
+});
+module.exports = __toCommonJS(server_exports);
+var import_hono = require("hono");
+var import_cookie = require("hono/cookie");
+var import_core = require("@auth-gate/core");
+function createAuthRoutes(options) {
+  const client = (0, import_core.createAuthGateClient)(options);
+  const appUrl = options.appUrl;
+  async function setSessionCookie(c, user) {
+    const encrypted = await client.encryptSession(user);
+    const opts = client.getSessionCookieOptions();
+    (0, import_cookie.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 = (0, import_cookie.getCookie)(c, client.cookieName);
+    if (!cookie) return null;
+    return client.decryptSession(cookie);
+  }
+  const routes = new import_hono.Hono().get("/:provider/login", async (c) => {
+    const provider = c.req.param("provider");
+    if (!import_core.SUPPORTED_PROVIDERS.includes(provider)) {
+      return c.json({ error: "Unsupported provider" }, 400);
+    }
+    const { state, nonce } = await client.createState();
+    const nonceOpts = client.getNonceCookieOptions();
+    (0, import_cookie.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 = (0, import_cookie.getCookie)(c, client.nonceCookieName)) != null ? _a : "";
+      (0, import_cookie.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) {
+      (0, import_cookie.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) {
+      (0, import_cookie.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 = (0, import_cookie.getCookie)(c, client.refreshTokenCookieName);
+    if (refreshCookie) {
+      const result = await client.refreshToken(refreshCookie);
+      if (!result) {
+        (0, import_cookie.deleteCookie)(c, client.cookieName, { path: "/" });
+        (0, import_cookie.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) {
+      (0, import_cookie.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 = (0, import_cookie.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 = (0, import_cookie.getCookie)(c, client.refreshTokenCookieName);
+    if (refreshCookie) {
+      await client.revokeSession(refreshCookie);
+      (0, import_cookie.deleteCookie)(c, client.refreshTokenCookieName, { path: "/" });
+    }
+    (0, import_cookie.deleteCookie)(c, client.cookieName, { path: "/" });
+    return c.json({ success: true });
+  });
+  return routes;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createAuthRoutes
+});

package/dist/server.d.cts

@@ -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 };