@saas-support/react 0.2.0

package/dist/index.js

@@ -0,0 +1,524 @@
+class b extends Error {
+  constructor(t, e, s = "unknown") {
+    super(e), this.name = "SaaSError", this.code = t, this.domain = s;
+  }
+  get isNotFound() {
+    return this.code === 404;
+  }
+  get isUnauthorized() {
+    return this.code === 401;
+  }
+  get isForbidden() {
+    return this.code === 403;
+  }
+  get isConflict() {
+    return this.code === 409;
+  }
+  get isRateLimited() {
+    return this.code === 429;
+  }
+}
+class m {
+  constructor(t, e) {
+    this.baseUrl = t, this.authMode = e;
+  }
+  async request(t, e, s, r) {
+    const i = {
+      "Content-Type": "application/json",
+      ...this.getAuthHeaders(),
+      ...r
+    }, a = await (await fetch(`${this.baseUrl}${e}`, {
+      method: t,
+      headers: i,
+      body: s ? JSON.stringify(s) : void 0
+    })).json();
+    if (a.code && a.code >= 400) {
+      const d = this.inferDomain(e);
+      throw new b(a.code, a.message || "Request failed", d);
+    }
+    return a.data;
+  }
+  async get(t, e) {
+    return this.request("GET", t, void 0, e);
+  }
+  async post(t, e, s) {
+    return this.request("POST", t, e, s);
+  }
+  async patch(t, e, s) {
+    return this.request("PATCH", t, e, s);
+  }
+  async del(t, e) {
+    return this.request("DELETE", t, void 0, e);
+  }
+  getAuthHeaders() {
+    switch (this.authMode.type) {
+      case "publishableKey":
+      case "apiKey":
+        return { "X-API-Key": this.authMode.key };
+      case "portalToken":
+      case "embedToken":
+        return { Authorization: `Bearer ${this.authMode.token}` };
+    }
+  }
+  inferDomain(t) {
+    return t.startsWith("/auth") ? "auth" : t.startsWith("/billing") ? "billing" : t.startsWith("/report") ? "report" : "unknown";
+  }
+}
+class w {
+  constructor(t) {
+    this.accessToken = null, this.refreshToken = null, this.refreshTimer = null, this.onRefreshNeeded = null, this.storageKey = `ss_rt_${t.slice(0, 12)}`, this.refreshToken = this.loadRefreshToken();
+  }
+  setRefreshCallback(t) {
+    this.onRefreshNeeded = t;
+  }
+  getAccessToken() {
+    return this.accessToken;
+  }
+  getRefreshToken() {
+    return this.refreshToken;
+  }
+  hasRefreshToken() {
+    return this.refreshToken !== null;
+  }
+  setTokens(t, e) {
+    this.accessToken = t, this.refreshToken = e, this.saveRefreshToken(e), this.scheduleRefresh(t);
+  }
+  clearTokens() {
+    this.accessToken = null, this.refreshToken = null, this.removeRefreshToken(), this.refreshTimer && (clearTimeout(this.refreshTimer), this.refreshTimer = null);
+  }
+  destroy() {
+    this.refreshTimer && (clearTimeout(this.refreshTimer), this.refreshTimer = null);
+  }
+  scheduleRefresh(t) {
+    var r;
+    this.refreshTimer && clearTimeout(this.refreshTimer);
+    const e = this.getTokenExpiry(t);
+    if (!e) return;
+    const s = e * 1e3 - Date.now() - 6e4;
+    if (s <= 0) {
+      (r = this.onRefreshNeeded) == null || r.call(this);
+      return;
+    }
+    this.refreshTimer = setTimeout(() => {
+      var i;
+      (i = this.onRefreshNeeded) == null || i.call(this);
+    }, s);
+  }
+  getTokenExpiry(t) {
+    try {
+      const e = t.split(".")[1];
+      return JSON.parse(atob(e)).exp ?? null;
+    } catch {
+      return null;
+    }
+  }
+  loadRefreshToken() {
+    try {
+      return localStorage.getItem(this.storageKey);
+    } catch {
+      return null;
+    }
+  }
+  saveRefreshToken(t) {
+    try {
+      localStorage.setItem(this.storageKey, t);
+    } catch {
+    }
+  }
+  removeRefreshToken() {
+    try {
+      localStorage.removeItem(this.storageKey);
+    } catch {
+    }
+  }
+}
+class S {
+  constructor() {
+    this.listeners = /* @__PURE__ */ new Map();
+  }
+  on(t, e) {
+    return this.listeners.has(t) || this.listeners.set(t, /* @__PURE__ */ new Set()), this.listeners.get(t).add(e), () => {
+      var s;
+      (s = this.listeners.get(t)) == null || s.delete(e);
+    };
+  }
+  emit(t, e) {
+    var s;
+    (s = this.listeners.get(t)) == null || s.forEach((r) => r(e));
+  }
+  removeAll() {
+    this.listeners.clear();
+  }
+}
+const k = 500, T = 600, $ = 5 * 60 * 1e3;
+class R {
+  constructor(t, e, s, r) {
+    this.cachedUser = null, this.cachedSettings = null, this.loaded = !1, this.transport = t, this.tokenManager = e, this.emitter = s, this.baseUrl = r;
+  }
+  // ---------------------------------------------------------------------------
+  // Lifecycle
+  // ---------------------------------------------------------------------------
+  async load() {
+    var t, e;
+    if (!this.loaded) {
+      try {
+        this.cachedSettings = await this.transport.get("/auth/settings");
+      } catch {
+      }
+      if ((t = this.tokenManager) != null && t.hasRefreshToken())
+        try {
+          await this.performRefresh();
+        } catch {
+          (e = this.tokenManager) == null || e.clearTokens();
+        }
+      this.loaded = !0;
+    }
+  }
+  // ---------------------------------------------------------------------------
+  // Core auth operations
+  // ---------------------------------------------------------------------------
+  async signIn(t, e) {
+    const s = await this.transport.post("/auth/login", { email: t, password: e });
+    if ("mfaRequired" in s && s.mfaRequired)
+      return s;
+    const r = s;
+    return this.setSession(r), r;
+  }
+  async signUp(t, e) {
+    const s = await this.transport.post("/auth/register", { email: t, password: e });
+    return this.setSession(s), s;
+  }
+  async signOut() {
+    var e;
+    const t = (e = this.tokenManager) == null ? void 0 : e.getRefreshToken();
+    if (t)
+      try {
+        await this.transport.post("/auth/logout", { refreshToken: t });
+      } catch {
+      }
+    this.clearSession();
+  }
+  async signInWithOAuth(t) {
+    const e = `${this.baseUrl}/auth/oauth/${t}/popup-callback`, { authUrl: s, state: r } = await this.transport.get(
+      `/auth/oauth/${t}?redirect_uri=${encodeURIComponent(e)}`
+    ), i = window.screenX + (window.innerWidth - k) / 2, g = window.screenY + (window.innerHeight - T) / 2, a = window.open(
+      s,
+      "saas-support-oauth",
+      `width=${k},height=${T},left=${i},top=${g},toolbar=no,menubar=no`
+    );
+    return new Promise((d, c) => {
+      let o = !1;
+      const u = async (h) => {
+        var f;
+        if (((f = h.data) == null ? void 0 : f.type) === "saas-support:oauth-callback" && !o) {
+          if (o = !0, window.removeEventListener("message", u), clearTimeout(y), clearInterval(p), a == null || a.close(), h.data.error) {
+            c(new Error(`OAuth error: ${h.data.error}`));
+            return;
+          }
+          try {
+            const l = await this.transport.post(
+              `/auth/oauth/${t}/callback`,
+              { code: h.data.code, state: h.data.state || r }
+            );
+            this.setSession(l), d(l);
+          } catch (l) {
+            c(l);
+          }
+        }
+      };
+      window.addEventListener("message", u);
+      const y = setTimeout(() => {
+        o || (o = !0, window.removeEventListener("message", u), clearInterval(p), a == null || a.close(), c(new Error("OAuth popup timed out")));
+      }, $), p = setInterval(() => {
+        a != null && a.closed && !o && (o = !0, clearInterval(p), clearTimeout(y), window.removeEventListener("message", u), c(new Error("OAuth popup was closed")));
+      }, 500);
+    });
+  }
+  async submitMfaCode(t, e) {
+    const s = await this.transport.post("/auth/login/mfa", { mfaToken: t, code: e });
+    return this.setSession(s), s;
+  }
+  // ---------------------------------------------------------------------------
+  // Magic link & password reset
+  // ---------------------------------------------------------------------------
+  async sendMagicLink(t, e) {
+    await this.transport.post("/auth/magic-link/send", { email: t, redirectUrl: e });
+  }
+  async verifyMagicLink(t) {
+    const e = await this.transport.post("/auth/magic-link/verify", { token: t });
+    return this.setSession(e), e;
+  }
+  async sendPasswordReset(t, e) {
+    await this.transport.post("/auth/password-reset/send", { email: t, redirectUrl: e });
+  }
+  async resetPassword(t, e) {
+    await this.transport.post("/auth/password-reset/verify", { token: t, newPassword: e });
+  }
+  // ---------------------------------------------------------------------------
+  // MFA management
+  // ---------------------------------------------------------------------------
+  async setupMfa() {
+    return this.transport.post("/auth/mfa/setup", void 0, this.authHeaders());
+  }
+  async verifyMfa(t) {
+    return this.transport.post("/auth/mfa/verify", { code: t }, this.authHeaders());
+  }
+  async disableMfa(t) {
+    await this.transport.post("/auth/mfa/disable", { code: t }, this.authHeaders());
+  }
+  // ---------------------------------------------------------------------------
+  // Token & user access
+  // ---------------------------------------------------------------------------
+  async getToken() {
+    var e, s, r;
+    const t = ((e = this.tokenManager) == null ? void 0 : e.getAccessToken()) ?? null;
+    if (t) return t;
+    if ((s = this.tokenManager) != null && s.hasRefreshToken())
+      try {
+        return await this.performRefresh(), ((r = this.tokenManager) == null ? void 0 : r.getAccessToken()) ?? null;
+      } catch {
+        return this.clearSession(), null;
+      }
+    return null;
+  }
+  async getUser() {
+    if (this.cachedUser) return this.cachedUser;
+    const t = await this.getToken();
+    if (!t) return null;
+    try {
+      return this.cachedUser = await this.transport.get("/auth/me", { Authorization: `Bearer ${t}` }), this.cachedUser;
+    } catch {
+      return null;
+    }
+  }
+  getUserSync() {
+    return this.cachedUser;
+  }
+  isLoaded() {
+    return this.loaded;
+  }
+  async getSettings() {
+    if (this.cachedSettings) return this.cachedSettings;
+    try {
+      return this.cachedSettings = await this.transport.get("/auth/settings"), this.cachedSettings;
+    } catch {
+      return null;
+    }
+  }
+  onAuthStateChange(t) {
+    return this.emitter.on("authStateChange", t);
+  }
+  // ---------------------------------------------------------------------------
+  // Profile
+  // ---------------------------------------------------------------------------
+  async updateProfile(t) {
+    const e = await this.transport.patch("/auth/me", { metadata: t }, this.authHeaders());
+    return this.cachedUser = e, this.emitter.emit("authStateChange", e), e;
+  }
+  // ---------------------------------------------------------------------------
+  // Organizations
+  // ---------------------------------------------------------------------------
+  async listOrgs() {
+    return this.transport.get("/auth/orgs", this.authHeaders());
+  }
+  async createOrg(t, e) {
+    return this.transport.post("/auth/orgs", { name: t, slug: e }, this.authHeaders());
+  }
+  async getOrg(t) {
+    return this.transport.get(`/auth/orgs/${t}`, this.authHeaders());
+  }
+  async updateOrg(t, e) {
+    return this.transport.patch(`/auth/orgs/${t}`, e, this.authHeaders());
+  }
+  async deleteOrg(t) {
+    await this.transport.del(`/auth/orgs/${t}`, this.authHeaders());
+  }
+  // ---------------------------------------------------------------------------
+  // Members & Invites
+  // ---------------------------------------------------------------------------
+  async listMembers(t) {
+    return this.transport.get(`/auth/orgs/${t}/members`, this.authHeaders());
+  }
+  async sendInvite(t, e, s) {
+    return this.transport.post(`/auth/orgs/${t}/invites`, { email: e, role: s }, this.authHeaders());
+  }
+  async updateMemberRole(t, e, s) {
+    await this.transport.patch(`/auth/orgs/${t}/members/${e}`, { role: s }, this.authHeaders());
+  }
+  async removeMember(t, e) {
+    await this.transport.del(`/auth/orgs/${t}/members/${e}`, this.authHeaders());
+  }
+  async acceptInvite(t) {
+    return this.transport.post(`/auth/invites/${t}/accept`, void 0, this.authHeaders());
+  }
+  // ---------------------------------------------------------------------------
+  // Internal
+  // ---------------------------------------------------------------------------
+  /** @internal */
+  async performRefresh() {
+    var s;
+    const t = (s = this.tokenManager) == null ? void 0 : s.getRefreshToken();
+    if (!t) throw new Error("No refresh token");
+    const e = await this.transport.post(
+      "/auth/refresh",
+      { refreshToken: t }
+    );
+    if (this.tokenManager.setTokens(e.accessToken, e.refreshToken), !this.cachedUser)
+      try {
+        this.cachedUser = await this.transport.get("/auth/me", { Authorization: `Bearer ${e.accessToken}` }), this.emitter.emit("authStateChange", this.cachedUser);
+      } catch {
+      }
+  }
+  setSession(t) {
+    var e;
+    (e = this.tokenManager) == null || e.setTokens(t.accessToken, t.refreshToken), this.cachedUser = t.user, this.emitter.emit("authStateChange", t.user);
+  }
+  clearSession() {
+    var t;
+    (t = this.tokenManager) == null || t.clearTokens(), this.cachedUser = null, this.emitter.emit("authStateChange", null);
+  }
+  authHeaders() {
+    var e;
+    const t = (e = this.tokenManager) == null ? void 0 : e.getAccessToken();
+    return t ? { Authorization: `Bearer ${t}` } : {};
+  }
+}
+class U {
+  constructor(t) {
+    this.transport = t;
+  }
+  // --- Customer ---
+  async createCustomer(t) {
+    return this.transport.post("/billing/customers", t);
+  }
+  async getCustomer(t) {
+    return this.transport.get(`/billing/customers/${t}`);
+  }
+  async updateCustomer(t, e) {
+    return this.transport.patch(`/billing/customers/${t}`, e);
+  }
+  // --- Subscription ---
+  async subscribe(t, e) {
+    return this.transport.post(`/billing/customers/${t}/subscribe`, { planId: e });
+  }
+  async changePlan(t, e) {
+    return this.transport.patch(`/billing/customers/${t}/subscription`, { planId: e });
+  }
+  async cancelSubscription(t) {
+    return this.transport.del(`/billing/customers/${t}/subscription`);
+  }
+  // --- Invoices ---
+  async getInvoices(t) {
+    return this.transport.get(`/billing/customers/${t}/invoices`);
+  }
+  // --- Usage ---
+  async ingestUsageEvent(t) {
+    return this.transport.post("/billing/events", t);
+  }
+  async getCurrentUsage(t) {
+    return this.transport.get(`/billing/customers/${t}/usage`);
+  }
+  // --- Portal ---
+  async createPortalToken(t, e) {
+    return this.transport.post("/billing/portal-tokens", { customerId: t, expiresIn: e });
+  }
+  // --- Coupon ---
+  async applyCoupon(t, e) {
+    return this.transport.post(`/billing/customers/${t}/coupon`, { code: e });
+  }
+}
+class M {
+  constructor(t) {
+    this.transport = t;
+  }
+  // --- Query ---
+  async executeQuery(t) {
+    return this.transport.post("/report/query", t);
+  }
+  // --- Saved Queries ---
+  async listQueries(t) {
+    const e = t ? this.toQueryString(t) : "";
+    return this.transport.get(`/report/queries${e}`);
+  }
+  async saveQuery(t) {
+    return this.transport.post("/report/queries", t);
+  }
+  async updateQuery(t, e) {
+    return this.transport.patch(`/report/queries/${t}`, e);
+  }
+  async deleteQuery(t) {
+    await this.transport.del(`/report/queries/${t}`);
+  }
+  // --- Dashboards ---
+  async listDashboards(t) {
+    const e = t ? this.toQueryString(t) : "";
+    return this.transport.get(`/report/dashboards${e}`);
+  }
+  async createDashboard(t) {
+    return this.transport.post("/report/dashboards", t);
+  }
+  async getDashboard(t) {
+    return this.transport.get(`/report/dashboards/${t}`);
+  }
+  async updateDashboard(t, e) {
+    return this.transport.patch(`/report/dashboards/${t}`, e);
+  }
+  async deleteDashboard(t) {
+    await this.transport.del(`/report/dashboards/${t}`);
+  }
+  // --- Embed Tokens ---
+  async createEmbedToken(t) {
+    return this.transport.post("/report/embed-tokens", t);
+  }
+  async listEmbedTokens() {
+    return this.transport.get("/report/embed-tokens");
+  }
+  async revokeEmbedToken(t) {
+    await this.transport.del(`/report/embed-tokens/${t}`);
+  }
+  toQueryString(t) {
+    const e = Object.entries(t).filter(([, s]) => s != null && s !== "");
+    return e.length === 0 ? "" : "?" + e.map(([s, r]) => `${s}=${encodeURIComponent(String(r))}`).join("&");
+  }
+}
+const v = "https://api.saas-support.com/v1";
+class E {
+  constructor(t) {
+    if (this.tokenManager = null, this.loaded = !1, !t.publishableKey && !t.apiKey)
+      throw new Error("SaaSSupport: either publishableKey or apiKey is required");
+    const e = t.baseUrl ?? v;
+    this.emitter = new S();
+    const s = t.publishableKey ? new m(e, { type: "publishableKey", key: t.publishableKey }) : null, r = t.apiKey ? new m(e, { type: "apiKey", key: t.apiKey }) : null;
+    t.publishableKey && (this.tokenManager = new w(t.publishableKey)), this.auth = new R(
+      s ?? r,
+      this.tokenManager,
+      this.emitter,
+      e
+    ), this.billing = new U(r ?? s), this.report = new M(r ?? s), this.tokenManager && this.tokenManager.setRefreshCallback(() => this.auth.performRefresh());
+  }
+  async load() {
+    this.loaded || (await this.auth.load(), this.loaded = !0);
+  }
+  isLoaded() {
+    return this.loaded;
+  }
+  onError(t) {
+    return this.emitter.on("error", t);
+  }
+  destroy() {
+    var t;
+    (t = this.tokenManager) == null || t.destroy(), this.emitter.removeAll();
+  }
+}
+function H(n) {
+  return "mfaRequired" in n && n.mfaRequired === !0;
+}
+export {
+  R as AuthClient,
+  U as BillingClient,
+  M as ReportClient,
+  b as SaaSError,
+  E as SaaSSupport,
+  m as Transport,
+  H as isMfaRequired
+};