@broadcastingplatforms/sdk 0.0.0-dev.52fbff9

package/dist/auth.d.mts

@@ -0,0 +1 @@
+export { A as AuthClient, b as AuthClientOptions, c as AuthStateChangeCallback, d as AuthStateChangeEvent, e as SignInPayload, f as SignInWithTokenOptions } from './auth-CSkJb9Wc.mjs';

package/dist/auth.d.ts

@@ -0,0 +1 @@
+export { A as AuthClient, b as AuthClientOptions, c as AuthStateChangeCallback, d as AuthStateChangeEvent, e as SignInPayload, f as SignInWithTokenOptions } from './auth-CSkJb9Wc.js';

package/dist/auth.js

@@ -0,0 +1,456 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+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);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/auth.ts
+var auth_exports = {};
+__export(auth_exports, {
+  AuthClient: () => AuthClient
+});
+module.exports = __toCommonJS(auth_exports);
+var import_jwt_decode = require("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 = (0, import_jwt_decode.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");
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthClient
+});
+//# sourceMappingURL=auth.js.map