@reauth-dev/sdk 0.2.0 → 0.3.0

package/dist/chunk-DMNMTW2C.mjs

@@ -1,336 +0,0 @@
-import {
-  DEFAULT_TIMEOUT_MS
-} from "./chunk-EY5LQCDG.mjs";
-
-// src/client.ts
-function assertHttpsUrl(url) {
-  let parsed;
-  try {
-    parsed = new URL(url);
-  } catch {
-    throw new Error("URL must use HTTPS");
-  }
-  if (parsed.protocol !== "https:") {
-    throw new Error("URL must use HTTPS");
-  }
-}
-function createReauthClient(config) {
-  const { domain } = config;
-  if (config.timeout !== void 0 && (!Number.isFinite(config.timeout) || config.timeout <= 0)) {
-    throw new Error("timeout must be a positive finite number in milliseconds");
-  }
-  const timeoutMs = config.timeout ?? DEFAULT_TIMEOUT_MS;
-  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",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to get session: ${res.status}`);
-      }
-      return res.json();
-    },
-    /**
-     * Refresh the access token using the refresh token.
-     * Call this when getSession() returns valid: false but no error_code.
-     * @throws Error on failed refresh (401) or server error
-     */
-    async refresh() {
-      const res = await fetch(`${baseUrl}/auth/refresh`, {
-        method: "POST",
-        credentials: "include",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to refresh: ${res.status}`);
-      }
-    },
-    /**
-     * 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 or network unreachable
-     * @throws Error on server errors (non-401 HTTP status codes) or request timeout
-     *
-     * @example
-     * ```typescript
-     * try {
-     *   const tokenResponse = await reauth.getToken();
-     *   if (tokenResponse) {
-     *     fetch('/api/data', {
-     *       headers: { Authorization: `Bearer ${tokenResponse.accessToken}` }
-     *     });
-     *   }
-     * } catch (err) {
-     *   // Server error or timeout — do not log the user out
-     * }
-     * ```
-     */
-    async getToken() {
-      try {
-        const res = await fetch(`${baseUrl}/auth/token`, {
-          method: "GET",
-          credentials: "include",
-          signal: AbortSignal.timeout(timeoutMs)
-        });
-        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 (err) {
-        if (err instanceof TypeError) return null;
-        throw err;
-      }
-    },
-    /**
-     * Log out the user by clearing all session cookies.
-     * @throws Error on server error
-     */
-    async logout() {
-      const res = await fetch(`${baseUrl}/auth/logout`, {
-        method: "POST",
-        credentials: "include",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to logout: ${res.status}`);
-      }
-    },
-    /**
-     * Delete the user's own account (self-service).
-     * @throws Error on permission denied or server error
-     */
-    async deleteAccount() {
-      const res = await fetch(`${baseUrl}/auth/account`, {
-        method: "DELETE",
-        credentials: "include",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to delete account: ${res.status}`);
-      }
-    },
-    // ========================================================================
-    // Billing Methods
-    // ========================================================================
-    /**
-     * Get available subscription plans for the domain.
-     * Only returns public plans sorted by display order.
-     * @throws Error on server error
-     */
-    async getPlans() {
-      const res = await fetch(`${baseUrl}/billing/plans`, {
-        credentials: "include",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to get plans: ${res.status}`);
-      }
-      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.map((f) => ({
-            code: f.code,
-            name: f.name,
-            featureType: f.feature_type,
-            numericValue: f.numeric_value,
-            unitLabel: f.unit_label
-          })),
-          displayOrder: p.display_order,
-          creditsAmount: p.credits_amount,
-          planType: p.plan_type,
-          contactUrl: p.contact_url
-        })
-      );
-    },
-    /**
-     * Get the current user's subscription status.
-     */
-    async getSubscription() {
-      const res = await fetch(`${baseUrl}/billing/subscription`, {
-        credentials: "include",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to get subscription: ${res.status}`);
-      }
-      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",
-        signal: AbortSignal.timeout(timeoutMs),
-        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
-      );
-      assertHttpsUrl(checkoutUrl);
-      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",
-        signal: AbortSignal.timeout(timeoutMs),
-        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();
-      assertHttpsUrl(data.portal_url);
-      window.location.href = data.portal_url;
-    },
-    /**
-     * Cancel the user's subscription at period end.
-     * @throws Error on failure or server error
-     */
-    async cancelSubscription() {
-      const res = await fetch(`${baseUrl}/billing/cancel`, {
-        method: "POST",
-        credentials: "include",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        throw new Error(`Failed to cancel subscription: ${res.status}`);
-      }
-    },
-    // ========================================================================
-    // Balance Methods
-    // ========================================================================
-    /**
-     * Get the current user's balance.
-     * @returns Object with the current balance
-     */
-    async getBalance() {
-      const res = await fetch(`${baseUrl}/balance`, {
-        credentials: "include",
-        signal: AbortSignal.timeout(timeoutMs)
-      });
-      if (!res.ok) {
-        if (res.status === 401) throw new Error("Not authenticated");
-        throw new Error(`Failed to get balance: ${res.status}`);
-      }
-      const data = await res.json();
-      return { balance: data.balance };
-    },
-    /**
-     * 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", signal: AbortSignal.timeout(timeoutMs) }
-      );
-      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
-          })
-        )
-      };
-    }
-  };
-}
-
-export {
-  createReauthClient
-};