@genation/sdk 0.1.0

package/dist/genation.es.js

@@ -0,0 +1,626 @@
+class w extends Error {
+  code;
+  cause;
+  constructor(e, t, r) {
+    super(e), this.name = "GenationError", this.code = t, this.cause = r;
+  }
+}
+class h extends w {
+  constructor(e, t, r) {
+    super(e, t, r), this.name = "AuthError";
+  }
+  static invalidGrant(e = "Invalid authorization code or refresh token") {
+    return new h(e, "invalid_grant");
+  }
+  static accessDenied(e = "User denied access") {
+    return new h(e, "access_denied");
+  }
+  static expiredToken(e = "Token has expired") {
+    return new h(e, "expired_token");
+  }
+  static invalidState(e = "State mismatch, possible CSRF attack") {
+    return new h(e, "invalid_state");
+  }
+  static pkceVerificationFailed(e = "PKCE verification failed") {
+    return new h(e, "pkce_verification_failed");
+  }
+}
+class c extends w {
+  status;
+  constructor(e, t, r) {
+    super(e, "network_error", r), this.name = "NetworkError", this.status = t;
+  }
+  static fromResponse(e) {
+    return new c(
+      `HTTP ${e.status}: ${e.statusText}`,
+      e.status
+    );
+  }
+}
+class u extends w {
+  constructor(e) {
+    super(e, "config_error"), this.name = "ConfigError";
+  }
+  static missingField(e) {
+    return new u(`Missing required config field: ${e}`);
+  }
+}
+class p {
+  baseUrl;
+  timeout;
+  constructor(e) {
+    this.baseUrl = e.baseUrl.replace(/\/$/, ""), this.timeout = e.timeout ?? 3e4;
+  }
+  /**
+   * Make an HTTP request
+   */
+  async request(e, t = {}) {
+    const { method: r = "GET", headers: n = {}, body: a, params: l } = t;
+    let o = `${this.baseUrl}${e}`;
+    if (l) {
+      const i = new URLSearchParams(l);
+      o += `?${i.toString()}`;
+    }
+    const m = new AbortController(), y = setTimeout(() => m.abort(), this.timeout);
+    try {
+      const i = await fetch(o, {
+        method: r,
+        headers: {
+          "Content-Type": "application/json",
+          ...n
+        },
+        body: a ? JSON.stringify(a) : void 0,
+        signal: m.signal
+      });
+      if (clearTimeout(y), !i.ok)
+        throw c.fromResponse(i);
+      return await i.json();
+    } catch (i) {
+      throw clearTimeout(y), i instanceof c ? i : i instanceof Error && i.name === "AbortError" ? new c("Request timeout", void 0, i) : new c("Network request failed", void 0, i);
+    }
+  }
+  /**
+   * POST request with form data (for OAuth token exchange)
+   */
+  async postForm(e, t, r = {}) {
+    const n = `${this.baseUrl}${e}`, a = new AbortController(), l = setTimeout(() => a.abort(), this.timeout);
+    try {
+      const o = await fetch(n, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          ...r
+        },
+        body: new URLSearchParams(t).toString(),
+        signal: a.signal
+      });
+      if (clearTimeout(l), !o.ok)
+        throw c.fromResponse(o);
+      return await o.json();
+    } catch (o) {
+      throw clearTimeout(l), o instanceof c ? o : new c("Network request failed", void 0, o);
+    }
+  }
+}
+function k(s) {
+  return btoa(String.fromCharCode(...s)).replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function T() {
+  const s = new Uint8Array(32);
+  return crypto.getRandomValues(s), k(s);
+}
+async function b(s) {
+  const t = new TextEncoder().encode(s), r = await crypto.subtle.digest("SHA-256", t);
+  return k(new Uint8Array(r));
+}
+async function v() {
+  const s = T(), e = await b(s);
+  return {
+    codeVerifier: s,
+    codeChallenge: e,
+    codeChallengeMethod: "S256"
+  };
+}
+function _() {
+  const s = new Uint8Array(16);
+  return crypto.getRandomValues(s), k(s);
+}
+const d = "tokens", g = "pkce", f = "state";
+class C {
+  storage;
+  constructor(e) {
+    this.storage = e;
+  }
+  /**
+   * Store token set
+   */
+  async setTokens(e) {
+    await this.storage.set(d, JSON.stringify(e));
+  }
+  /**
+   * Get stored tokens
+   */
+  async getTokens() {
+    const e = await this.storage.get(d);
+    if (!e) return null;
+    try {
+      return JSON.parse(e);
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * Clear stored tokens
+   */
+  async clearTokens() {
+    await this.storage.remove(d);
+  }
+  /**
+   * Check if access token is expired
+   */
+  async isTokenExpired() {
+    const e = await this.getTokens();
+    if (!e) return !0;
+    const t = e.issuedAt + e.expiresIn * 1e3;
+    return Date.now() > t - 6e4;
+  }
+  /**
+   * Store PKCE verifier for later validation
+   */
+  async setPKCE(e) {
+    await this.storage.set(g, e);
+  }
+  /**
+   * Get and clear stored PKCE verifier
+   */
+  async consumePKCE() {
+    const e = await this.storage.get(g);
+    return e && await this.storage.remove(g), e;
+  }
+  /**
+   * Store state for CSRF validation
+   */
+  async setState(e) {
+    await this.storage.set(f, e);
+  }
+  /**
+   * Get and clear stored state
+   */
+  async consumeState() {
+    const e = await this.storage.get(f);
+    return e && await this.storage.remove(f), e;
+  }
+  /**
+   * Clear all auth-related data
+   */
+  async clearAll() {
+    await this.storage.clear();
+  }
+}
+const I = "https://mnnoheowoowbtpuoguul.supabase.co/auth/v1";
+class U {
+  config;
+  http;
+  tokenManager;
+  constructor(e, t) {
+    this.config = {
+      clientId: e.clientId,
+      clientSecret: e.clientSecret,
+      redirectUri: e.redirectUri,
+      scopes: e.scopes,
+      authUrl: e.authUrl ?? I
+    }, this.http = new p({ baseUrl: this.config.authUrl }), this.tokenManager = t;
+  }
+  /**
+   * Generate authorization URL for OAuth flow
+   * Stores PKCE verifier and state for later validation
+   */
+  async getAuthorizationUrl() {
+    const e = await v(), t = _();
+    await this.tokenManager.setPKCE(e.codeVerifier), await this.tokenManager.setState(t);
+    const r = new URLSearchParams({
+      response_type: "code",
+      client_id: this.config.clientId,
+      redirect_uri: this.config.redirectUri,
+      state: t,
+      code_challenge: e.codeChallenge,
+      code_challenge_method: e.codeChallengeMethod
+    });
+    return this.config.scopes && this.config.scopes.length > 0 && r.append("scope", this.config.scopes.join(" ")), `${this.config.authUrl}/oauth/authorize?${r.toString()}`;
+  }
+  /**
+   * Exchange authorization code for tokens
+   */
+  async exchangeCode(e, t) {
+    const r = await this.tokenManager.consumeState();
+    if (!r || r !== t)
+      throw h.invalidState();
+    const n = await this.tokenManager.consumePKCE();
+    if (!n)
+      throw h.pkceVerificationFailed("Missing code verifier");
+    const a = await this.http.postForm(
+      "/oauth/token",
+      {
+        grant_type: "authorization_code",
+        code: e,
+        redirect_uri: this.config.redirectUri,
+        client_id: this.config.clientId,
+        client_secret: this.config.clientSecret,
+        code_verifier: n
+      }
+    ), l = this.mapTokenResponse(a);
+    return await this.tokenManager.setTokens(l), l;
+  }
+  /**
+   * Refresh access token using refresh token
+   */
+  async refreshToken() {
+    const e = await this.tokenManager.getTokens();
+    if (!e?.refreshToken)
+      throw h.invalidGrant("No refresh token available");
+    const t = await this.http.postForm(
+      "/oauth/token",
+      {
+        grant_type: "refresh_token",
+        refresh_token: e.refreshToken,
+        client_id: this.config.clientId,
+        client_secret: this.config.clientSecret
+      }
+    ), r = this.mapTokenResponse(t);
+    return await this.tokenManager.setTokens(r), r;
+  }
+  /**
+   * Revoke current tokens
+   */
+  async revokeToken() {
+    const e = await this.tokenManager.getTokens();
+    if (e)
+      try {
+        await this.http.postForm("/oauth/revoke", {
+          token: e.accessToken,
+          client_id: this.config.clientId,
+          client_secret: this.config.clientSecret
+        });
+      } finally {
+        await this.tokenManager.clearTokens();
+      }
+  }
+  /**
+   * Map OAuth token response to TokenSet
+   */
+  mapTokenResponse(e) {
+    return {
+      accessToken: e.access_token,
+      refreshToken: e.refresh_token,
+      tokenType: e.token_type,
+      expiresIn: e.expires_in,
+      issuedAt: Date.now(),
+      scope: e.scope
+    };
+  }
+}
+class x {
+  store = /* @__PURE__ */ new Map();
+  async get(e) {
+    return this.store.get(e) ?? null;
+  }
+  async set(e, t) {
+    this.store.set(e, t);
+  }
+  async remove(e) {
+    this.store.delete(e);
+  }
+  async clear() {
+    this.store.clear();
+  }
+}
+class S {
+  prefix;
+  constructor(e = "genation") {
+    this.prefix = e;
+  }
+  getKey(e) {
+    return `${this.prefix}:${e}`;
+  }
+  async get(e) {
+    return typeof window > "u" ? null : localStorage.getItem(this.getKey(e));
+  }
+  async set(e, t) {
+    typeof window > "u" || localStorage.setItem(this.getKey(e), t);
+  }
+  async remove(e) {
+    typeof window > "u" || localStorage.removeItem(this.getKey(e));
+  }
+  async clear() {
+    if (typeof window > "u") return;
+    Object.keys(localStorage).filter(
+      (t) => t.startsWith(`${this.prefix}:`)
+    ).forEach((t) => localStorage.removeItem(t));
+  }
+}
+class E {
+  prefix;
+  constructor(e = "genation") {
+    this.prefix = e;
+  }
+  getKey(e) {
+    return `${this.prefix}:${e}`;
+  }
+  async get(e) {
+    return typeof window > "u" ? null : sessionStorage.getItem(this.getKey(e));
+  }
+  async set(e, t) {
+    typeof window > "u" || sessionStorage.setItem(this.getKey(e), t);
+  }
+  async remove(e) {
+    typeof window > "u" || sessionStorage.removeItem(this.getKey(e));
+  }
+  async clear() {
+    if (typeof window > "u") return;
+    Object.keys(sessionStorage).filter(
+      (t) => t.startsWith(`${this.prefix}:`)
+    ).forEach((t) => sessionStorage.removeItem(t));
+  }
+}
+function A(s = "localStorage") {
+  switch (s) {
+    case "memory":
+      return new x();
+    case "localStorage":
+      return new S();
+    case "sessionStorage":
+      return new E();
+    default:
+      return new S();
+  }
+}
+class M {
+  oauth;
+  tokenManager;
+  http;
+  httpServer;
+  listeners = /* @__PURE__ */ new Set();
+  initialized = !1;
+  constructor(e) {
+    this.validateConfig(e);
+    const t = typeof e.storage == "object" ? e.storage : A(e.storage);
+    this.tokenManager = new C(t), this.oauth = new U(e, this.tokenManager), this.http = new p({
+      baseUrl: e.authUrl ?? "https://mnnoheowoowbtpuoguul.supabase.co/auth/v1"
+    }), this.httpServer = new p({
+      baseUrl: "https://ff-api.genation.ai/api/v2/client"
+    });
+  }
+  validateConfig(e) {
+    if (!e.clientId) throw u.missingField("clientId");
+    if (!e.clientSecret)
+      throw u.missingField("clientSecret");
+    if (!e.redirectUri) throw u.missingField("redirectUri");
+  }
+  /**
+   * Emit auth state change event to all listeners
+   */
+  async emitAuthStateChange(e) {
+    const t = await this.getSession();
+    this.listeners.forEach((r) => {
+      try {
+        r(e, t);
+      } catch (n) {
+        console.error("Error in auth state change callback:", n);
+      }
+    });
+  }
+  /**
+   * Listen to authentication state changes
+   *
+   * Register a callback that fires when:
+   * - `INITIAL_SESSION`: On first subscription, with current session state
+   * - `SIGNED_IN`: User successfully authenticated
+   * - `SIGNED_OUT`: User logged out or session expired
+   * - `TOKEN_REFRESHED`: Access token was automatically refreshed
+   *
+   * @param callback - Function called on each auth state change
+   * @returns Object containing subscription with `unsubscribe()` method
+   *
+   * @example
+   * ```typescript
+   * const { subscription } = client.onAuthStateChange((event, session) => {
+   *   console.log('Auth event:', event);
+   *
+   *   if (event === 'INITIAL_SESSION') {
+   *     // Check if user was previously logged in
+   *     if (session) {
+   *       console.log('Welcome back!', session.user);
+   *     }
+   *   } else if (event === 'SIGNED_IN') {
+   *     // User just signed in
+   *     console.log('Signed in:', session?.user);
+   *   } else if (event === 'SIGNED_OUT') {
+   *     // Clear app state, redirect to login
+   *     console.log('Signed out');
+   *   }
+   * });
+   *
+   * // Cleanup when component unmounts
+   * subscription.unsubscribe();
+   * ```
+   */
+  onAuthStateChange(e) {
+    return this.listeners.add(e), this.initialized ? setTimeout(() => {
+      this.emitAuthStateChange("INITIAL_SESSION");
+    }, 0) : (this.initialized = !0, setTimeout(() => {
+      this.emitAuthStateChange("INITIAL_SESSION");
+    }, 0)), {
+      subscription: {
+        unsubscribe: () => {
+          this.listeners.delete(e);
+        }
+      }
+    };
+  }
+  /**
+   * Start OAuth sign-in flow
+   *
+   * Generates authorization URL with PKCE challenge.
+   * Redirect user to this URL to start authentication.
+   *
+   * @returns Authorization URL to redirect user to
+   *
+   * @example
+   * ```typescript
+   * async function handleLogin() {
+   *   const url = await client.signIn();
+   *   window.location.href = url;
+   * }
+   * ```
+   */
+  async signIn() {
+    return this.oauth.getAuthorizationUrl();
+  }
+  /**
+   * Handle OAuth callback after user authentication
+   *
+   * Call this on your redirect URI page to exchange
+   * the authorization code for access tokens.
+   * Triggers `SIGNED_IN` event on success.
+   *
+   * @param code - Authorization code from URL query params
+   * @param state - State parameter for CSRF validation
+   * @returns Token set with access and refresh tokens
+   * @throws {AuthError} If state mismatch or code exchange fails
+   *
+   * @example
+   * ```typescript
+   * // On your /callback page
+   * async function handleCallback() {
+   *   const params = new URLSearchParams(window.location.search);
+   *   const code = params.get('code');
+   *   const state = params.get('state');
+   *
+   *   if (code && state) {
+   *     await client.handleCallback(code, state);
+   *     // onAuthStateChange will fire with SIGNED_IN event
+   *   }
+   * }
+   * ```
+   */
+  async handleCallback(e, t) {
+    const r = await this.oauth.exchangeCode(e, t);
+    try {
+      const n = await this.fetchUser(r.accessToken);
+      console.log("Debug: handleCallback fetched user:", n);
+    } catch (n) {
+      console.error("Debug: handleCallback fetchUser failed:", n);
+    }
+    return await this.emitAuthStateChange("SIGNED_IN"), r;
+  }
+  /**
+   * Sign out and revoke tokens
+   *
+   * Clears local session and revokes tokens on server.
+   * Triggers `SIGNED_OUT` event for all listeners.
+   *
+   * @example
+   * ```typescript
+   * async function handleLogout() {
+   *   await client.signOut();
+   *   // onAuthStateChange will fire with SIGNED_OUT event
+   * }
+   * ```
+   */
+  async signOut() {
+    await this.oauth.revokeToken(), await this.emitAuthStateChange("SIGNED_OUT");
+  }
+  /**
+   * Get current session
+   *
+   * Returns session with access token and user info.
+   * Automatically refreshes token if expired.
+   *
+   * @returns Current session or null if not authenticated
+   *
+   * @example
+   * ```typescript
+   * const session = await client.getSession();
+   * if (session) {
+   *   console.log('Logged in as:', session.user?.email);
+   *
+   *   // Use access token for API calls
+   *   fetch('/api/data', {
+   *     headers: { Authorization: `Bearer ${session.accessToken}` }
+   *   });
+   * }
+   * ```
+   */
+  async getSession() {
+    if (await this.tokenManager.isTokenExpired())
+      try {
+        await this.oauth.refreshToken();
+      } catch {
+        return null;
+      }
+    const t = await this.tokenManager.getTokens();
+    if (!t) return null;
+    const r = await this.fetchUser(t.accessToken);
+    return {
+      accessToken: t.accessToken,
+      refreshToken: t.refreshToken,
+      expiresIn: t.expiresIn,
+      expiresAt: t.issuedAt + t.expiresIn * 1e3,
+      user: r
+    };
+  }
+  /**
+   * Get licenses
+   * @param accessToken - The access token to use for the request
+   * @param options - The options for the request
+   * @param options.expiresAfter - Query licenses that are expired after the given date, default set to today to get all valid licenses (unexpired licenses)
+   * @returns The licenses
+   */
+  async getLicenses(e = {}) {
+    const t = await this.getSession();
+    if (!t)
+      return null;
+    const r = t.accessToken, { expiresAfter: n = /* @__PURE__ */ new Date() } = e, a = await this.httpServer.request("/licenses", {
+      headers: { Authorization: `Bearer ${r}` },
+      params: { expiresAfter: n.toISOString() }
+    });
+    return a.ok ? a.data : (console.error("GenationClient: Error fetching licenses:", a.error), null);
+  }
+  /**
+   * Fetch user info from auth server
+   */
+  async fetchUser(e) {
+    try {
+      const t = await this.http.request("/oauth/userinfo", {
+        headers: { Authorization: `Bearer ${e}` }
+      });
+      return {
+        sub: t.sub,
+        name: t.name,
+        picture: t.picture,
+        email: t.email,
+        email_verified: t.email_verified,
+        phone_number: t.phone_number,
+        phone_number_verified: t.phone_number_verified
+      };
+    } catch (t) {
+      return console.error("GenationClient: Error fetching user:", t), null;
+    }
+  }
+}
+function K(s) {
+  return new M(s);
+}
+export {
+  h as AuthError,
+  u as ConfigError,
+  M as GenationClient,
+  w as GenationError,
+  S as LocalStorage,
+  x as MemoryStorage,
+  c as NetworkError,
+  E as SessionStorage,
+  K as createClient,
+  A as createStorage
+};
+//# sourceMappingURL=genation.es.js.map