@broadcastingplatforms/sdk 0.0.0-dev.9cfcfc6

package/dist/auth.mjs

@@ -0,0 +1,433 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/auth.ts
+import { jwtDecode } from "jwt-decode";
+
+// src/errors.ts
+var SDKError = class extends Error {
+  /**
+   * Construct an SDKError. Signature is compatible with Error.
+   * You can pass in a message or an options object, as with the Error constructor.
+   * Additional fields (code, etc) may be added via the second argument.
+   */
+  constructor(message, details = {}) {
+    const resolvedMessage = message ?? (typeof details.message === "string" ? details.message : "Unknown error");
+    super(resolvedMessage);
+    /**
+     * Canonical SDK error code.
+     */
+    __publicField(this, "code");
+    /**
+     * HTTP status code if available.
+     */
+    __publicField(this, "statusCode");
+    /**
+     * End-user safe message.
+     */
+    __publicField(this, "userMessage");
+    /**
+     * Optional request metadata (null when unavailable).
+     */
+    __publicField(this, "request");
+    /**
+     * Optional response metadata (null when unavailable).
+     */
+    __publicField(this, "response");
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (details && typeof details === "object") {
+      for (const [key, value] of Object.entries(details)) {
+        if (!["name", "message", "stack"].includes(key)) {
+          this[key] = value;
+        }
+      }
+    }
+    this.name = "SDKError";
+    this.code = details.code ?? "unknown_error";
+    this.statusCode = typeof details.statusCode === "number" ? details.statusCode : void 0;
+    this.userMessage = typeof details.userMessage === "string" ? details.userMessage : this.message;
+    this.request = details.request ?? null;
+    this.response = details.response ?? null;
+  }
+  /**
+   * Serialize the error into a plain object, preserving extra fields.
+   */
+  toJSON() {
+    const extras = { ...this };
+    delete extras.code;
+    delete extras.statusCode;
+    delete extras.message;
+    delete extras.userMessage;
+    delete extras.request;
+    delete extras.response;
+    delete extras.form;
+    delete extras.cause;
+    return {
+      ...extras,
+      code: this.code,
+      statusCode: this.statusCode,
+      message: this.message,
+      userMessage: this.userMessage,
+      request: this.request,
+      response: this.response
+    };
+  }
+};
+var STATUS_CODE_DEFAULTS = {
+  401: {
+    code: "authentication_required",
+    message: "Authentication required",
+    userMessage: "Please log in to continue. Your session may have expired."
+  },
+  403: {
+    code: "permission_denied",
+    message: "Permission denied",
+    userMessage: "You do not have permission to perform this action."
+  },
+  404: {
+    code: "not_found",
+    message: "Resource not found",
+    userMessage: "The requested resource was not found."
+  },
+  422: {
+    code: "validation_failed",
+    message: "Validation failed",
+    userMessage: "The provided information is invalid. Please check your input and try again."
+  },
+  429: {
+    code: "rate_limited",
+    message: "Rate limit exceeded",
+    userMessage: "Too many requests. Please wait a moment and try again."
+  },
+  500: {
+    code: "server_error",
+    message: "Internal server error",
+    userMessage: "Something went wrong on our end. Please try again later."
+  }
+};
+var DEFAULT_ERROR = {
+  code: "unknown_error",
+  userMessage: "An unexpected error occurred. Please try again."
+};
+function createSdkError(message, details = {}) {
+  const statusCode = details.response?.status;
+  const statusValues = statusCode && STATUS_CODE_DEFAULTS[statusCode] ? STATUS_CODE_DEFAULTS[statusCode] : DEFAULT_ERROR;
+  const enrichedDetails = {
+    ...details,
+    statusCode,
+    code: details.code ?? statusValues.code,
+    userMessage: details.userMessage ?? statusValues.userMessage,
+    request: details.request ?? null,
+    response: details.response ?? null
+  };
+  return new SDKError(message, enrichedDetails);
+}
+
+// src/storage.ts
+var DEFAULT_AUTH_COOKIE_NAME = "auth_token";
+var NoopStorageAdapter = class {
+  /**
+   * Read a stored value (always null).
+   */
+  get() {
+    return null;
+  }
+  /**
+   * Persist a stored value (no-op).
+   */
+  set() {
+  }
+  /**
+   * Delete a stored value (no-op).
+   */
+  delete() {
+  }
+};
+
+// src/auth.ts
+var DEFAULT_REFRESH_THRESHOLD_SECONDS = 60;
+var getTokenExpiry = (token) => {
+  try {
+    const payload = jwtDecode(token);
+    const exp = payload?.exp;
+    return typeof exp === "number" ? exp : null;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to decode token";
+    throw createSdkError(message);
+  }
+};
+var AuthClient = class {
+  /**
+   * Create a new auth client instance.
+   */
+  constructor(http, options = {}) {
+    __publicField(this, "http");
+    __publicField(this, "storage");
+    __publicField(this, "storageKey");
+    __publicField(this, "refreshEnabled");
+    __publicField(this, "refreshThresholdSeconds");
+    __publicField(this, "serviceKey");
+    __publicField(this, "currentSession", null);
+    __publicField(this, "stateListeners", /* @__PURE__ */ new Set());
+    __publicField(this, "restorePromise", null);
+    /**
+     * Track whether storage restoration has already been attempted.
+     */
+    __publicField(this, "restoreAttempted", false);
+    this.http = http;
+    this.storage = options.storage ?? new NoopStorageAdapter();
+    this.storageKey = options.storageKey ?? DEFAULT_AUTH_COOKIE_NAME;
+    this.refreshEnabled = options.autoRefresh ?? false;
+    this.refreshThresholdSeconds = options.refreshThresholdSeconds ?? DEFAULT_REFRESH_THRESHOLD_SECONDS;
+    this.serviceKey = options.serviceKey ?? null;
+    this.registerAuthHook();
+  }
+  /**
+   * Set the current bearer token, or clear it when null.
+   */
+  async setToken(token) {
+    if (!token) {
+      await this.storage.delete(this.storageKey);
+      this.currentSession = null;
+      this.emitState("SIGNED_OUT", null);
+      return null;
+    }
+    return this.applyToken(token, "SIGNED_IN");
+  }
+  /**
+   * Get the currently configured token (if any).
+   */
+  getToken() {
+    return this.currentSession ?? this.serviceKey ?? null;
+  }
+  /**
+   * Clear the current token and session.
+   */
+  async clearToken() {
+    await this.setToken(null);
+  }
+  /**
+   * Sign in using a JWT token.
+   */
+  async signInWithToken(token, options = {}) {
+    if (options.verifySession) {
+      this.assertTokenNotExpired(token);
+    }
+    return this.applyToken(token, "SIGNED_IN");
+  }
+  /**
+   * Sign in using email/password credentials.
+   */
+  async signIn(payload) {
+    const { data, request, response } = await this.http.requestWithMetadata(
+      "/v2/auth/login",
+      {
+        method: "POST",
+        body: JSON.stringify(payload)
+      }
+    );
+    const token = this.resolveTokenFromResponse(data, { request, response });
+    return this.applyToken(token, "SIGNED_IN");
+  }
+  /**
+   * Sign out the current user.
+   */
+  async signOut() {
+    try {
+      await this.http.request("/v2/auth/logout", { method: "POST" });
+    } finally {
+      await this.clearToken();
+    }
+  }
+  /**
+   * Get the current session, restoring from storage if needed.
+   */
+  async getSession() {
+    if (this.currentSession) {
+      return this.currentSession;
+    }
+    await this.restoreFromStorage();
+    return this.currentSession;
+  }
+  /**
+   * Refresh the current session token.
+   * Manual refresh is always available; automatic refresh is controlled
+   * by the `autoRefresh` option.
+   */
+  async refreshToken() {
+    if (this.isUsingServiceKey()) {
+      throw createSdkError("Token refresh is unavailable when using a service key");
+    }
+    try {
+      const { data, request, response } = await this.http.requestWithMetadata(
+        "/v2/auth/refresh",
+        { method: "POST" }
+      );
+      const token = this.resolveTokenFromResponse(data, { request, response });
+      return await this.applyToken(token, "TOKEN_REFRESHED");
+    } catch (error) {
+      await this.clearToken();
+      throw error;
+    }
+  }
+  /**
+   * Subscribe to auth state changes.
+   */
+  onAuthStateChange(callback) {
+    this.stateListeners.add(callback);
+    return () => {
+      this.stateListeners.delete(callback);
+    };
+  }
+  emitState(event, token) {
+    for (const listener of this.stateListeners) {
+      listener(event, token);
+    }
+  }
+  /**
+   * Register the auth header hook for outgoing HTTP requests.
+   */
+  registerAuthHook() {
+    this.http.onBeforeRequest(async (request) => {
+      if (!this.http.isSameOrigin(request.url)) {
+        return;
+      }
+      const token = await this.resolveRequestToken();
+      if (!token) {
+        return;
+      }
+      const headers = {
+        ...request.init.headers ?? {}
+      };
+      if (headers.Authorization || headers.authorization) {
+        return;
+      }
+      return {
+        ...request,
+        init: {
+          ...request.init,
+          headers: {
+            ...headers,
+            Authorization: `Bearer ${token}`
+          }
+        }
+      };
+    });
+  }
+  /**
+   * Resolve the bearer token to use for outgoing requests.
+   */
+  async resolveRequestToken() {
+    if (this.currentSession) {
+      return this.currentSession;
+    }
+    if (this.serviceKey) {
+      return this.serviceKey;
+    }
+    return await this.getSession();
+  }
+  /**
+   * Persist a token update and notify listeners.
+   */
+  async applyToken(token, event) {
+    await Promise.resolve(this.storage.set(this.storageKey, token));
+    this.currentSession = token;
+    this.emitState(event, token);
+    return token;
+  }
+  /**
+   * Restore a persisted token from storage when needed.
+   */
+  async restoreFromStorage() {
+    if (this.restorePromise) {
+      return this.restorePromise;
+    }
+    if (this.restoreAttempted) {
+      return;
+    }
+    if (this.serviceKey) {
+      this.restoreAttempted = true;
+      return;
+    }
+    this.restorePromise = (async () => {
+      const storedToken = await Promise.resolve(
+        this.storage.get(this.storageKey)
+      );
+      if (!storedToken) {
+        return;
+      }
+      let exp = null;
+      if (this.refreshEnabled) {
+        try {
+          exp = getTokenExpiry(storedToken);
+        } catch {
+          this.currentSession = null;
+          await Promise.resolve(this.storage.delete(this.storageKey));
+          return;
+        }
+      }
+      const hadSession = this.currentSession !== null;
+      this.currentSession = storedToken;
+      if (!hadSession) {
+        this.emitState("SIGNED_IN", storedToken);
+      }
+      if (this.refreshEnabled && exp !== null) {
+        const now = Math.floor(Date.now() / 1e3);
+        if (exp - now <= this.refreshThresholdSeconds) {
+          try {
+            await this.refreshToken();
+          } catch {
+          }
+        }
+      }
+    })();
+    try {
+      await this.restorePromise;
+    } finally {
+      this.restorePromise = null;
+      this.restoreAttempted = true;
+    }
+  }
+  /**
+   * Determine if the client is currently using the service key.
+   */
+  isUsingServiceKey() {
+    return !!this.serviceKey && !this.currentSession;
+  }
+  /**
+   * Resolve the auth token from a response payload and request metadata.
+   */
+  resolveTokenFromResponse(response, metadata) {
+    if (response.error || response.error_description) {
+      const message = response.error_description ?? response.error ?? "Authentication failed";
+      throw createSdkError(message, {
+        request: metadata.request,
+        response: metadata.response,
+        userMessage: message
+      });
+    }
+    const token = response.access_token ?? response.token;
+    if (!token) {
+      throw createSdkError("Missing access token in response", {
+        request: metadata.request,
+        response: metadata.response
+      });
+    }
+    return token;
+  }
+  assertTokenNotExpired(token) {
+    const exp = getTokenExpiry(token);
+    if (exp === null) {
+      return;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    if (exp < now) {
+      throw createSdkError("Token has expired");
+    }
+  }
+};
+export {
+  AuthClient
+};
+//# sourceMappingURL=auth.mjs.map

package/dist/base-client-BmVTsKhL.d.mts

@@ -0,0 +1,70 @@
+import { h as SdkClient, A as AuthClient, a as HttpClient, S as StreamsClient, C as ChannelsClient, g as ChatClient, b as AuthClientOptions, _ as RealtimeClientOverrides, z as StorageAdapter } from './auth-CRWthQ_B.mjs';
+
+/**
+ * Shared SDK client base class for browser and server implementations.
+ */
+
+/**
+ * Shared options for SDK client construction.
+ */
+interface BaseClientOptions {
+    /**
+     * Auth configuration overrides for the client.
+     */
+    auth?: AuthClientOptions;
+    /**
+     * Default headers to apply to each request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Fetch implementation override (primarily for tests).
+     */
+    fetch?: typeof fetch;
+    /**
+     * Realtime configuration for the client.
+     */
+    realtime?: RealtimeClientOverrides;
+    /**
+     * Storage adapter resolved by the runtime client.
+     */
+    storage: StorageAdapter;
+    /**
+     * Optional service key override.
+     */
+    serviceKey?: string | null;
+}
+/**
+ * Base SDK client wrapper exposing shared HTTP and auth helpers.
+ */
+declare abstract class BaseSdkClient implements SdkClient {
+    /**
+     * Auth client instance.
+     */
+    readonly auth: AuthClient;
+    /**
+     * HTTP client instance.
+     */
+    readonly http: HttpClient;
+    /**
+     * Realtime client instance.
+     */
+    readonly realtime: SdkClient["realtime"];
+    /**
+     * Streams namespace client.
+     */
+    readonly streams: StreamsClient;
+    /**
+     * Channels namespace client.
+     */
+    readonly channels: ChannelsClient;
+    /**
+     * Chat namespace client.
+     */
+    readonly chat: ChatClient;
+    /**
+     * Create a new SDK client base instance.
+     */
+    protected constructor(baseUrl: string, options: BaseClientOptions);
+}
+
+export { BaseSdkClient as B };

package/dist/base-client-Dk56EJj-.d.ts

@@ -0,0 +1,70 @@
+import { h as SdkClient, A as AuthClient, a as HttpClient, S as StreamsClient, C as ChannelsClient, g as ChatClient, b as AuthClientOptions, _ as RealtimeClientOverrides, z as StorageAdapter } from './auth-CRWthQ_B.js';
+
+/**
+ * Shared SDK client base class for browser and server implementations.
+ */
+
+/**
+ * Shared options for SDK client construction.
+ */
+interface BaseClientOptions {
+    /**
+     * Auth configuration overrides for the client.
+     */
+    auth?: AuthClientOptions;
+    /**
+     * Default headers to apply to each request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Fetch implementation override (primarily for tests).
+     */
+    fetch?: typeof fetch;
+    /**
+     * Realtime configuration for the client.
+     */
+    realtime?: RealtimeClientOverrides;
+    /**
+     * Storage adapter resolved by the runtime client.
+     */
+    storage: StorageAdapter;
+    /**
+     * Optional service key override.
+     */
+    serviceKey?: string | null;
+}
+/**
+ * Base SDK client wrapper exposing shared HTTP and auth helpers.
+ */
+declare abstract class BaseSdkClient implements SdkClient {
+    /**
+     * Auth client instance.
+     */
+    readonly auth: AuthClient;
+    /**
+     * HTTP client instance.
+     */
+    readonly http: HttpClient;
+    /**
+     * Realtime client instance.
+     */
+    readonly realtime: SdkClient["realtime"];
+    /**
+     * Streams namespace client.
+     */
+    readonly streams: StreamsClient;
+    /**
+     * Channels namespace client.
+     */
+    readonly channels: ChannelsClient;
+    /**
+     * Chat namespace client.
+     */
+    readonly chat: ChatClient;
+    /**
+     * Create a new SDK client base instance.
+     */
+    protected constructor(baseUrl: string, options: BaseClientOptions);
+}
+
+export { BaseSdkClient as B };

package/dist/browser-client.d.mts

@@ -0,0 +1,47 @@
+import { b as AuthClientOptions, _ as RealtimeClientOverrides, h as SdkClient } from './auth-CRWthQ_B.mjs';
+import { B as BaseSdkClient } from './base-client-BmVTsKhL.mjs';
+
+/**
+ * Browser client entrypoint for the SDK core package.
+ */
+
+/**
+ * Options for creating a browser SDK client instance.
+ */
+interface ClientFactoryOptions {
+    /**
+     * Auth configuration overrides for the client.
+     */
+    auth?: AuthClientOptions;
+    /**
+     * Default headers to apply to each request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Fetch implementation override (primarily for tests).
+     */
+    fetch?: typeof fetch;
+    /**
+     * Realtime configuration for the client (baseUrl/getToken are provided internally).
+     */
+    realtime?: RealtimeClientOverrides;
+}
+/**
+ * Browser SDK client wrapper exposing HTTP and auth helpers.
+ */
+declare class BrowserClient extends BaseSdkClient implements SdkClient {
+    /**
+     * Create a browser client instance.
+     */
+    constructor(baseUrl: string, keyOverride?: string | null, options?: ClientFactoryOptions);
+}
+/**
+ * Create a browser-oriented SDK client.
+ */
+declare const createBrowserClient: (baseUrl: string, keyOverride?: string | null, options?: ClientFactoryOptions) => SdkClient;
+/**
+ * Create a browser-oriented SDK client (alias for `createBrowserClient`).
+ */
+declare const createClient: (baseUrl: string, keyOverride?: string | null, options?: ClientFactoryOptions) => SdkClient;
+
+export { BrowserClient, type ClientFactoryOptions, createBrowserClient, createClient };

package/dist/browser-client.d.ts

@@ -0,0 +1,47 @@
+import { b as AuthClientOptions, _ as RealtimeClientOverrides, h as SdkClient } from './auth-CRWthQ_B.js';
+import { B as BaseSdkClient } from './base-client-Dk56EJj-.js';
+
+/**
+ * Browser client entrypoint for the SDK core package.
+ */
+
+/**
+ * Options for creating a browser SDK client instance.
+ */
+interface ClientFactoryOptions {
+    /**
+     * Auth configuration overrides for the client.
+     */
+    auth?: AuthClientOptions;
+    /**
+     * Default headers to apply to each request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Fetch implementation override (primarily for tests).
+     */
+    fetch?: typeof fetch;
+    /**
+     * Realtime configuration for the client (baseUrl/getToken are provided internally).
+     */
+    realtime?: RealtimeClientOverrides;
+}
+/**
+ * Browser SDK client wrapper exposing HTTP and auth helpers.
+ */
+declare class BrowserClient extends BaseSdkClient implements SdkClient {
+    /**
+     * Create a browser client instance.
+     */
+    constructor(baseUrl: string, keyOverride?: string | null, options?: ClientFactoryOptions);
+}
+/**
+ * Create a browser-oriented SDK client.
+ */
+declare const createBrowserClient: (baseUrl: string, keyOverride?: string | null, options?: ClientFactoryOptions) => SdkClient;
+/**
+ * Create a browser-oriented SDK client (alias for `createBrowserClient`).
+ */
+declare const createClient: (baseUrl: string, keyOverride?: string | null, options?: ClientFactoryOptions) => SdkClient;
+
+export { BrowserClient, type ClientFactoryOptions, createBrowserClient, createClient };