@reauth-dev/sdk 0.1.0

package/dist/react/index.js

@@ -0,0 +1,448 @@
+"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/react/index.ts
+var react_exports = {};
+__export(react_exports, {
+  AuthProvider: () => AuthProvider,
+  ProtectedRoute: () => ProtectedRoute,
+  useAuth: () => useAuth,
+  useAuthContext: () => useAuthContext
+});
+module.exports = __toCommonJS(react_exports);
+
+// src/react/useAuth.ts
+var import_react = require("react");
+
+// src/client.ts
+function createReauthClient(config) {
+  const { domain } = config;
+  const baseUrl = `https://reauth.${domain}/api/public`;
+  return {
+    /**
+     * Redirect the user to the reauth.dev login page.
+     * After successful login, they'll be redirected back to your configured redirect URL.
+     */
+    login() {
+      if (typeof window === "undefined") {
+        throw new Error("login() can only be called in browser");
+      }
+      window.location.href = `https://reauth.${domain}/`;
+    },
+    /**
+     * Check if the user is authenticated.
+     * Returns session info including user ID, email, and roles.
+     */
+    async getSession() {
+      const res = await fetch(`${baseUrl}/auth/session`, {
+        credentials: "include"
+      });
+      return res.json();
+    },
+    /**
+     * Refresh the access token using the refresh token.
+     * Call this when getSession() returns valid: false but no error_code.
+     * @returns true if refresh succeeded, false otherwise
+     */
+    async refresh() {
+      const res = await fetch(`${baseUrl}/auth/refresh`, {
+        method: "POST",
+        credentials: "include"
+      });
+      return res.ok;
+    },
+    /**
+     * Get an access token for Bearer authentication.
+     * Use this when calling your own API that uses local token verification.
+     *
+     * @returns TokenResponse with access token, or null if not authenticated
+     *
+     * @example
+     * ```typescript
+     * const tokenResponse = await reauth.getToken();
+     * if (tokenResponse) {
+     *   fetch('/api/data', {
+     *     headers: { Authorization: `Bearer ${tokenResponse.accessToken}` }
+     *   });
+     * }
+     * ```
+     */
+    async getToken() {
+      try {
+        const res = await fetch(`${baseUrl}/auth/token`, {
+          method: "GET",
+          credentials: "include"
+        });
+        if (!res.ok) {
+          if (res.status === 401) return null;
+          throw new Error(`Failed to get token: ${res.status}`);
+        }
+        const data = await res.json();
+        return {
+          accessToken: data.access_token,
+          expiresIn: data.expires_in,
+          tokenType: data.token_type
+        };
+      } catch {
+        return null;
+      }
+    },
+    /**
+     * Log out the user by clearing all session cookies.
+     */
+    async logout() {
+      await fetch(`${baseUrl}/auth/logout`, {
+        method: "POST",
+        credentials: "include"
+      });
+    },
+    /**
+     * Delete the user's own account (self-service).
+     * @returns true if deletion succeeded, false otherwise
+     */
+    async deleteAccount() {
+      const res = await fetch(`${baseUrl}/auth/account`, {
+        method: "DELETE",
+        credentials: "include"
+      });
+      return res.ok;
+    },
+    // ========================================================================
+    // Billing Methods
+    // ========================================================================
+    /**
+     * Get available subscription plans for the domain.
+     * Only returns public plans sorted by display order.
+     */
+    async getPlans() {
+      const res = await fetch(`${baseUrl}/billing/plans`, {
+        credentials: "include"
+      });
+      if (!res.ok) return [];
+      const data = await res.json();
+      return data.map(
+        (p) => ({
+          id: p.id,
+          code: p.code,
+          name: p.name,
+          description: p.description,
+          priceCents: p.price_cents,
+          currency: p.currency,
+          interval: p.interval,
+          intervalCount: p.interval_count,
+          trialDays: p.trial_days,
+          features: p.features,
+          displayOrder: p.display_order
+        })
+      );
+    },
+    /**
+     * Get the current user's subscription status.
+     */
+    async getSubscription() {
+      const res = await fetch(`${baseUrl}/billing/subscription`, {
+        credentials: "include"
+      });
+      const data = await res.json();
+      return {
+        id: data.id,
+        planCode: data.plan_code,
+        planName: data.plan_name,
+        status: data.status,
+        currentPeriodEnd: data.current_period_end,
+        trialEnd: data.trial_end,
+        cancelAtPeriodEnd: data.cancel_at_period_end
+      };
+    },
+    /**
+     * Create a Stripe checkout session to subscribe to a plan.
+     * @param planCode The plan code to subscribe to
+     * @param successUrl URL to redirect to after successful payment
+     * @param cancelUrl URL to redirect to if checkout is canceled
+     * @returns Checkout session with URL to redirect the user to
+     */
+    async createCheckout(planCode, successUrl, cancelUrl) {
+      const res = await fetch(`${baseUrl}/billing/checkout`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          plan_code: planCode,
+          success_url: successUrl,
+          cancel_url: cancelUrl
+        })
+      });
+      if (!res.ok) {
+        const err = await res.json().catch(() => ({}));
+        throw new Error(err.message || "Failed to create checkout session");
+      }
+      const data = await res.json();
+      return { checkoutUrl: data.checkout_url };
+    },
+    /**
+     * Redirect user to subscribe to a plan.
+     * Creates a checkout session and redirects to Stripe.
+     * @param planCode The plan code to subscribe to
+     */
+    async subscribe(planCode) {
+      if (typeof window === "undefined") {
+        throw new Error("subscribe() can only be called in browser");
+      }
+      const currentUrl = window.location.href;
+      const { checkoutUrl } = await this.createCheckout(
+        planCode,
+        currentUrl,
+        currentUrl
+      );
+      window.location.href = checkoutUrl;
+    },
+    /**
+     * Open the Stripe customer portal for managing subscription.
+     * @param returnUrl URL to return to after leaving the portal
+     */
+    async openBillingPortal(returnUrl) {
+      if (typeof window === "undefined") {
+        throw new Error("openBillingPortal() can only be called in browser");
+      }
+      const res = await fetch(`${baseUrl}/billing/portal`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include",
+        body: JSON.stringify({
+          return_url: returnUrl || window.location.href
+        })
+      });
+      if (!res.ok) {
+        throw new Error("Failed to open billing portal");
+      }
+      const data = await res.json();
+      window.location.href = data.portal_url;
+    },
+    /**
+     * Cancel the user's subscription at period end.
+     * @returns true if cancellation succeeded
+     */
+    async cancelSubscription() {
+      const res = await fetch(`${baseUrl}/billing/cancel`, {
+        method: "POST",
+        credentials: "include"
+      });
+      return res.ok;
+    },
+    // ========================================================================
+    // Balance Methods
+    // ========================================================================
+    /**
+     * Get the current user's balance.
+     * @returns Object with the current balance
+     */
+    async getBalance() {
+      const res = await fetch(`${baseUrl}/balance`, {
+        credentials: "include"
+      });
+      if (!res.ok) {
+        if (res.status === 401) throw new Error("Not authenticated");
+        throw new Error(`Failed to get balance: ${res.status}`);
+      }
+      return res.json();
+    },
+    /**
+     * Get the current user's balance transaction history.
+     * @param opts - Optional pagination (limit, offset)
+     * @returns Object with array of transactions (newest first)
+     */
+    async getTransactions(opts) {
+      const params = new URLSearchParams();
+      if (opts?.limit !== void 0) params.set("limit", String(opts.limit));
+      if (opts?.offset !== void 0) params.set("offset", String(opts.offset));
+      const qs = params.toString();
+      const res = await fetch(
+        `${baseUrl}/balance/transactions${qs ? `?${qs}` : ""}`,
+        { credentials: "include" }
+      );
+      if (!res.ok) {
+        if (res.status === 401) throw new Error("Not authenticated");
+        throw new Error(`Failed to get transactions: ${res.status}`);
+      }
+      const data = await res.json();
+      return {
+        transactions: data.transactions.map(
+          (t) => ({
+            id: t.id,
+            amountDelta: t.amount_delta,
+            reason: t.reason,
+            balanceAfter: t.balance_after,
+            createdAt: t.created_at
+          })
+        )
+      };
+    }
+  };
+}
+
+// src/react/useAuth.ts
+function useAuth(config) {
+  const client = (0, import_react.useMemo)(() => createReauthClient(config), [config.domain]);
+  const [state, setState] = (0, import_react.useState)({
+    user: null,
+    loading: true,
+    error: null,
+    isOnWaitlist: false,
+    waitlistPosition: null
+  });
+  const checkSession = (0, import_react.useCallback)(async () => {
+    try {
+      let session = await client.getSession();
+      if (!session.valid && !session.error_code && !session.end_user_id) {
+        const refreshed = await client.refresh();
+        if (refreshed) {
+          session = await client.getSession();
+        }
+      }
+      if (session.error_code === "ACCOUNT_SUSPENDED") {
+        setState({
+          user: null,
+          loading: false,
+          error: "Account suspended",
+          isOnWaitlist: false,
+          waitlistPosition: null
+        });
+        return;
+      }
+      if (session.valid && session.waitlist_position) {
+        setState({
+          user: {
+            id: session.end_user_id,
+            email: session.email,
+            roles: session.roles || []
+          },
+          loading: false,
+          error: null,
+          isOnWaitlist: true,
+          waitlistPosition: session.waitlist_position
+        });
+        return;
+      }
+      if (session.valid && session.end_user_id) {
+        setState({
+          user: {
+            id: session.end_user_id,
+            email: session.email,
+            roles: session.roles || []
+          },
+          loading: false,
+          error: null,
+          isOnWaitlist: false,
+          waitlistPosition: null
+        });
+        return;
+      }
+      setState({
+        user: null,
+        loading: false,
+        error: null,
+        isOnWaitlist: false,
+        waitlistPosition: null
+      });
+    } catch {
+      setState({
+        user: null,
+        loading: false,
+        error: "Auth check failed",
+        isOnWaitlist: false,
+        waitlistPosition: null
+      });
+    }
+  }, [client]);
+  (0, import_react.useEffect)(() => {
+    checkSession();
+  }, [checkSession]);
+  const logout = (0, import_react.useCallback)(async () => {
+    await client.logout();
+    setState({
+      user: null,
+      loading: false,
+      error: null,
+      isOnWaitlist: false,
+      waitlistPosition: null
+    });
+  }, [client]);
+  return {
+    ...state,
+    login: client.login,
+    logout,
+    refetch: checkSession
+  };
+}
+
+// src/react/AuthProvider.tsx
+var import_react2 = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var AuthContext = (0, import_react2.createContext)(null);
+function AuthProvider({ config, children }) {
+  const auth = useAuth(config);
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(AuthContext.Provider, { value: auth, children });
+}
+function useAuthContext() {
+  const context = (0, import_react2.useContext)(AuthContext);
+  if (!context) {
+    throw new Error("useAuthContext must be used within AuthProvider");
+  }
+  return context;
+}
+
+// src/react/ProtectedRoute.tsx
+var import_react3 = require("react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function ProtectedRoute({
+  children,
+  fallback = null,
+  onUnauthenticated,
+  onWaitlist
+}) {
+  const { user, loading, isOnWaitlist, login } = useAuthContext();
+  (0, import_react3.useEffect)(() => {
+    if (!loading && !user) {
+      if (onUnauthenticated) {
+        onUnauthenticated();
+      } else {
+        login();
+      }
+    }
+  }, [loading, user, login, onUnauthenticated]);
+  (0, import_react3.useEffect)(() => {
+    if (!loading && isOnWaitlist && onWaitlist) {
+      onWaitlist();
+    }
+  }, [loading, isOnWaitlist, onWaitlist]);
+  if (loading) {
+    return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children: fallback });
+  }
+  if (!user || isOnWaitlist) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_jsx_runtime2.Fragment, { children });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthProvider,
+  ProtectedRoute,
+  useAuth,
+  useAuthContext
+});

package/dist/react/index.mjs

@@ -0,0 +1,154 @@
+import {
+  createReauthClient
+} from "../chunk-JX2J36FS.mjs";
+
+// src/react/useAuth.ts
+import { useState, useEffect, useCallback, useMemo } from "react";
+function useAuth(config) {
+  const client = useMemo(() => createReauthClient(config), [config.domain]);
+  const [state, setState] = useState({
+    user: null,
+    loading: true,
+    error: null,
+    isOnWaitlist: false,
+    waitlistPosition: null
+  });
+  const checkSession = useCallback(async () => {
+    try {
+      let session = await client.getSession();
+      if (!session.valid && !session.error_code && !session.end_user_id) {
+        const refreshed = await client.refresh();
+        if (refreshed) {
+          session = await client.getSession();
+        }
+      }
+      if (session.error_code === "ACCOUNT_SUSPENDED") {
+        setState({
+          user: null,
+          loading: false,
+          error: "Account suspended",
+          isOnWaitlist: false,
+          waitlistPosition: null
+        });
+        return;
+      }
+      if (session.valid && session.waitlist_position) {
+        setState({
+          user: {
+            id: session.end_user_id,
+            email: session.email,
+            roles: session.roles || []
+          },
+          loading: false,
+          error: null,
+          isOnWaitlist: true,
+          waitlistPosition: session.waitlist_position
+        });
+        return;
+      }
+      if (session.valid && session.end_user_id) {
+        setState({
+          user: {
+            id: session.end_user_id,
+            email: session.email,
+            roles: session.roles || []
+          },
+          loading: false,
+          error: null,
+          isOnWaitlist: false,
+          waitlistPosition: null
+        });
+        return;
+      }
+      setState({
+        user: null,
+        loading: false,
+        error: null,
+        isOnWaitlist: false,
+        waitlistPosition: null
+      });
+    } catch {
+      setState({
+        user: null,
+        loading: false,
+        error: "Auth check failed",
+        isOnWaitlist: false,
+        waitlistPosition: null
+      });
+    }
+  }, [client]);
+  useEffect(() => {
+    checkSession();
+  }, [checkSession]);
+  const logout = useCallback(async () => {
+    await client.logout();
+    setState({
+      user: null,
+      loading: false,
+      error: null,
+      isOnWaitlist: false,
+      waitlistPosition: null
+    });
+  }, [client]);
+  return {
+    ...state,
+    login: client.login,
+    logout,
+    refetch: checkSession
+  };
+}
+
+// src/react/AuthProvider.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var AuthContext = createContext(null);
+function AuthProvider({ config, children }) {
+  const auth = useAuth(config);
+  return /* @__PURE__ */ jsx(AuthContext.Provider, { value: auth, children });
+}
+function useAuthContext() {
+  const context = useContext(AuthContext);
+  if (!context) {
+    throw new Error("useAuthContext must be used within AuthProvider");
+  }
+  return context;
+}
+
+// src/react/ProtectedRoute.tsx
+import { useEffect as useEffect2 } from "react";
+import { Fragment, jsx as jsx2 } from "react/jsx-runtime";
+function ProtectedRoute({
+  children,
+  fallback = null,
+  onUnauthenticated,
+  onWaitlist
+}) {
+  const { user, loading, isOnWaitlist, login } = useAuthContext();
+  useEffect2(() => {
+    if (!loading && !user) {
+      if (onUnauthenticated) {
+        onUnauthenticated();
+      } else {
+        login();
+      }
+    }
+  }, [loading, user, login, onUnauthenticated]);
+  useEffect2(() => {
+    if (!loading && isOnWaitlist && onWaitlist) {
+      onWaitlist();
+    }
+  }, [loading, isOnWaitlist, onWaitlist]);
+  if (loading) {
+    return /* @__PURE__ */ jsx2(Fragment, { children: fallback });
+  }
+  if (!user || isOnWaitlist) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx2(Fragment, { children });
+}
+export {
+  AuthProvider,
+  ProtectedRoute,
+  useAuth,
+  useAuthContext
+};