@deflectbot/deflect-sdk 1.4.4 → 1.4.6

package/dist/index.esm.js

@@ -0,0 +1,692 @@
+import PulseReporter from "./pulse";
+import { fetchScript } from "./scriptClient";
+import { createBlobUrl, loadModuleScript, waitForGlobalFunction, getTokenFromGlobal, cleanup } from "./scriptRunner";
+const ERROR_COOLDOWN_MS = 2e3;
+const MAX_CONSECUTIVE_ERRORS = 5;
+const MAX_FETCHES_PER_WINDOW = 15;
+const FETCH_WINDOW_MS = 6e4;
+class DeflectClient {
+  constructor(config, pulseReporter) {
+    this.scriptCache = null;
+    this.isWarmupInProgress = false;
+    this.hasWarmupError = false;
+    this.warmupPromise = null;
+    this.scriptFetchPromise = null;
+    // Guards against infinite loading
+    this.getTokenPromise = null;
+    this.lastErrorTime = 0;
+    this.consecutiveErrorCount = 0;
+    this.fetchCountInWindow = 0;
+    this.fetchWindowStart = 0;
+    if (!config.actionId?.trim()) {
+      throw new Error("actionId is required and cannot be empty");
+    }
+    this.validateActionId(config.actionId);
+    this.config = { prefetch: true, ...config };
+    this.pulseReporter = pulseReporter || new PulseReporter(DeflectClient.resolvePulseConfig());
+    if (this.config.prefetch !== false && !this.isTestMode()) {
+      this.scheduleWarmup();
+    }
+  }
+  /** Get the actionId this client is configured for */
+  getActionId() {
+    return this.config.actionId;
+  }
+  scheduleWarmup() {
+    if (typeof window === "undefined") return;
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => this.tryWarmup(), { once: true });
+    } else {
+      setTimeout(() => this.tryWarmup(), 100);
+    }
+  }
+  static resolvePulseConfig() {
+    const runtimeConfig = typeof window !== "undefined" && typeof window.Deflect === "object" && window.Deflect?.pulseConfig && typeof window.Deflect.pulseConfig === "object" ? window.Deflect.pulseConfig : {};
+    return {
+      ...runtimeConfig,
+      environment: runtimeConfig.environment || (typeof window !== "undefined" ? window.location.hostname : void 0)
+    };
+  }
+  reportError(error, tags, context) {
+    this.pulseReporter.captureException(error, { tags, context });
+  }
+  isInErrorCooldown() {
+    if (this.consecutiveErrorCount === 0) return false;
+    const backoffMs = Math.min(
+      ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+      3e4
+    );
+    return Date.now() - this.lastErrorTime < backoffMs;
+  }
+  isRateLimited() {
+    const now = Date.now();
+    if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+      this.fetchCountInWindow = 0;
+      this.fetchWindowStart = now;
+      return false;
+    }
+    return this.fetchCountInWindow >= MAX_FETCHES_PER_WINDOW;
+  }
+  hasExceededMaxErrors() {
+    return this.consecutiveErrorCount >= MAX_CONSECUTIVE_ERRORS;
+  }
+  recordFetchSuccess() {
+    this.consecutiveErrorCount = 0;
+    this.lastErrorTime = 0;
+  }
+  recordFetchError() {
+    this.consecutiveErrorCount++;
+    this.lastErrorTime = Date.now();
+  }
+  incrementFetchCount() {
+    const now = Date.now();
+    if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+      this.fetchCountInWindow = 0;
+      this.fetchWindowStart = now;
+    }
+    this.fetchCountInWindow++;
+  }
+  async tryWarmup() {
+    if (this.config.prefetch === false || this.isWarmupInProgress || this.scriptCache || this.hasWarmupError) {
+      return;
+    }
+    if (this.isRateLimited() || this.isInErrorCooldown() || this.hasExceededMaxErrors()) {
+      return;
+    }
+    this.isWarmupInProgress = true;
+    const fetchPromise = this.fetchScriptOnce();
+    this.warmupPromise = (async () => {
+      try {
+        const script = await fetchPromise;
+        this.scriptCache = script;
+        this.hasWarmupError = false;
+        this.recordFetchSuccess();
+      } catch {
+        this.hasWarmupError = true;
+        this.recordFetchError();
+      } finally {
+        this.isWarmupInProgress = false;
+      }
+    })();
+    await this.warmupPromise.catch(() => {
+    });
+  }
+  validateActionId(actionId) {
+    const sanitized = actionId.trim();
+    const validPattern = /^[a-zA-Z0-9/_-]+$/;
+    if (!validPattern.test(sanitized)) {
+      throw new Error("Invalid actionId format: contains disallowed characters");
+    }
+    return encodeURIComponent(sanitized);
+  }
+  prefetchNextScript() {
+    if (!this.hasWarmupError && this.config.prefetch !== false) {
+      this.tryWarmup().catch(() => {
+      });
+    }
+  }
+  fetchScriptOnce() {
+    if (!this.scriptFetchPromise) {
+      this.incrementFetchCount();
+      this.scriptFetchPromise = fetchScript(
+        this.config.actionId,
+        this.config.scriptUrl,
+        this.config.extraArgs
+      ).then((script) => {
+        this.scriptFetchPromise = null;
+        return script;
+      }).catch((error) => {
+        this.scriptFetchPromise = null;
+        throw error;
+      });
+    }
+    return this.scriptFetchPromise;
+  }
+  isTestMode() {
+    if (this.config.actionId === "PULSE_TEST" || this.config.actionId === "SENTRY_TEST") {
+      throw new Error("PULSE_TEST: This is a test error to verify Pulse integration is working");
+    }
+    return this.config.actionId === "t/FFFFFFFFFFFFF/111111111" || this.config.actionId === "t/FFFFFFFFFFFFF/000000000";
+  }
+  /** Get a challenge token for this client's actionId */
+  async getToken() {
+    if (this.getTokenPromise) {
+      return this.getTokenPromise;
+    }
+    this.getTokenPromise = this.getTokenInternal();
+    try {
+      return await this.getTokenPromise;
+    } finally {
+      this.getTokenPromise = null;
+    }
+  }
+  async getTokenInternal() {
+    try {
+      if (this.isTestMode()) {
+        return "TESTTOKEN";
+      }
+      if (this.hasExceededMaxErrors()) {
+        throw new Error(
+          `Too many consecutive errors (${this.consecutiveErrorCount}). Create a new client or wait before retrying.`
+        );
+      }
+      if (this.isRateLimited()) {
+        throw new Error(
+          `Rate limit exceeded: ${MAX_FETCHES_PER_WINDOW} requests per minute. Please wait before retrying.`
+        );
+      }
+      if (this.isInErrorCooldown()) {
+        const backoffMs = Math.min(
+          ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+          3e4
+        );
+        const remainingMs = backoffMs - (Date.now() - this.lastErrorTime);
+        throw new Error(
+          `In error cooldown. Please wait ${Math.ceil(remainingMs / 1e3)} seconds before retrying.`
+        );
+      }
+      let script;
+      if (this.warmupPromise) {
+        await this.warmupPromise.catch(() => {
+        });
+      }
+      if (this.scriptCache && !this.isWarmupInProgress) {
+        script = this.scriptCache;
+        this.scriptCache = null;
+      } else {
+        script = await this.fetchScriptOnce();
+      }
+      return this.executeScript(script);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "";
+      const isGuardError = errorMessage.includes("cooldown") || errorMessage.includes("Rate limit") || errorMessage.includes("Too many consecutive");
+      if (!isGuardError) {
+        this.recordFetchError();
+      }
+      const isUserError = error && typeof error === "object" && "isUserError" in error && error.isUserError === true;
+      this.reportError(
+        error,
+        {
+          deflect_sdk_error: "true",
+          deflect_user_error: isUserError ? "true" : "false",
+          method: "getToken",
+          action_id: this.config.actionId,
+          has_cache: this.scriptCache !== null ? "true" : "false",
+          has_warmup_error: this.hasWarmupError ? "true" : "false",
+          consecutive_errors: this.consecutiveErrorCount.toString(),
+          stage: "call"
+        },
+        {
+          actionId: this.config.actionId,
+          hasCache: this.scriptCache !== null,
+          hasWarmupError: this.hasWarmupError,
+          consecutiveErrorCount: this.consecutiveErrorCount,
+          fetchCountInWindow: this.fetchCountInWindow
+        }
+      );
+      throw error;
+    }
+  }
+  async executeScript(script) {
+    if (script.sessionId && typeof window !== "undefined") {
+      window.Deflect = window.Deflect || {};
+      window.Deflect.sessionId = script.sessionId;
+    }
+    const blobUrl = createBlobUrl(script.content);
+    let scriptElement = null;
+    try {
+      scriptElement = await loadModuleScript(blobUrl);
+      await waitForGlobalFunction("getChallengeToken");
+      const token = await getTokenFromGlobal("getChallengeToken");
+      this.recordFetchSuccess();
+      this.prefetchNextScript();
+      return token;
+    } catch (error) {
+      this.reportError(
+        error,
+        {
+          deflect_sdk_error: "true",
+          method: "executeScript",
+          stage: "load_or_execute",
+          action_id: this.config.actionId
+        },
+        {
+          hasCache: this.scriptCache !== null,
+          hasWarmupError: this.hasWarmupError
+        }
+      );
+      throw error;
+    } finally {
+      if (scriptElement) {
+        cleanup(blobUrl, scriptElement, "getChallengeToken");
+      } else {
+        URL.revokeObjectURL(blobUrl);
+      }
+    }
+  }
+  /** Manually trigger warmup/prefetch */
+  async warmup() {
+    try {
+      if (this.config.prefetch === false) {
+        return false;
+      }
+      await this.tryWarmup();
+      return this.scriptCache !== null;
+    } catch {
+      return false;
+    }
+  }
+  /** Clear the cached script */
+  clearCache() {
+    this.scriptCache = null;
+  }
+  /** Reset error state to allow retries */
+  resetErrorState() {
+    this.hasWarmupError = false;
+    this.consecutiveErrorCount = 0;
+    this.lastErrorTime = 0;
+    this.getTokenPromise = null;
+  }
+  /** Get current rate limit and error status for debugging */
+  getStatus() {
+    return {
+      actionId: this.config.actionId,
+      isRateLimited: this.isRateLimited(),
+      isInCooldown: this.isInErrorCooldown(),
+      consecutiveErrors: this.consecutiveErrorCount,
+      fetchesInWindow: this.fetchCountInWindow,
+      canFetch: !this.isRateLimited() && !this.isInErrorCooldown() && !this.hasExceededMaxErrors()
+    };
+  }
+  /** Inject token into a form and submit */
+  async injectToken(event) {
+    if (!event || !event.target || !(event.target instanceof HTMLFormElement)) {
+      throw new Error("injectToken: must be called from a form submit event");
+    }
+    event.preventDefault();
+    const form = event.target;
+    const token = await this.getToken();
+    Array.from(form.querySelectorAll('input[name="deflect_token"]')).forEach(
+      (el) => el.remove()
+    );
+    const hidden = document.createElement("input");
+    hidden.type = "hidden";
+    hidden.name = "deflect_token";
+    hidden.value = token;
+    form.appendChild(hidden);
+    form.submit();
+  }
+}
+class Deflect {
+  constructor() {
+    this.config = null;
+    this.scriptCache = null;
+    this.isWarmupInProgress = false;
+    this.hasWarmupError = false;
+    this.warmupPromise = null;
+    // Guards against infinite loading
+    this.getTokenPromise = null;
+    this.lastErrorTime = 0;
+    this.consecutiveErrorCount = 0;
+    this.fetchCountInWindow = 0;
+    this.fetchWindowStart = 0;
+    this.initializeGlobalState();
+    this.pulseReporter = new PulseReporter(this.resolvePulseConfig());
+    this.setupAutomaticWarmup();
+  }
+  initializeGlobalState() {
+    if (typeof window === "undefined") return;
+    window.Deflect = window.Deflect || {};
+  }
+  setupAutomaticWarmup() {
+    if (typeof window === "undefined") return;
+    if (document.readyState === "loading") {
+      document.addEventListener("DOMContentLoaded", () => this.tryWarmup());
+    } else {
+      setTimeout(() => this.tryWarmup(), 100);
+    }
+  }
+  resolvePulseConfig() {
+    const runtimeConfig = typeof window !== "undefined" && typeof window.Deflect === "object" && window.Deflect?.pulseConfig && typeof window.Deflect.pulseConfig === "object" ? window.Deflect.pulseConfig : {};
+    return {
+      ...runtimeConfig,
+      environment: runtimeConfig.environment || (typeof window !== "undefined" ? window.location.hostname : void 0)
+    };
+  }
+  reportError(error, tags, context) {
+    this.pulseReporter.captureException(error, { tags, context });
+  }
+  /** Check if we're in error cooldown period */
+  isInErrorCooldown() {
+    if (this.consecutiveErrorCount === 0) return false;
+    const backoffMs = Math.min(
+      ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+      3e4
+      // Max 30 second backoff
+    );
+    return Date.now() - this.lastErrorTime < backoffMs;
+  }
+  /** Check if we've exceeded the rate limit */
+  isRateLimited() {
+    const now = Date.now();
+    if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+      this.fetchCountInWindow = 0;
+      this.fetchWindowStart = now;
+      return false;
+    }
+    return this.fetchCountInWindow >= MAX_FETCHES_PER_WINDOW;
+  }
+  /** Check if we've hit max consecutive errors */
+  hasExceededMaxErrors() {
+    return this.consecutiveErrorCount >= MAX_CONSECUTIVE_ERRORS;
+  }
+  /** Record a successful fetch - resets error state */
+  recordFetchSuccess() {
+    this.consecutiveErrorCount = 0;
+    this.lastErrorTime = 0;
+  }
+  /** Record a failed fetch - increments error tracking */
+  recordFetchError() {
+    this.consecutiveErrorCount++;
+    this.lastErrorTime = Date.now();
+  }
+  /** Increment fetch counter for rate limiting */
+  incrementFetchCount() {
+    const now = Date.now();
+    if (now - this.fetchWindowStart > FETCH_WINDOW_MS) {
+      this.fetchCountInWindow = 0;
+      this.fetchWindowStart = now;
+    }
+    this.fetchCountInWindow++;
+  }
+  async tryWarmup() {
+    if (!this.config?.actionId || this.config.prefetch === false || this.isWarmupInProgress || this.scriptCache || this.hasWarmupError) {
+      return;
+    }
+    if (this.isRateLimited() || this.isInErrorCooldown() || this.hasExceededMaxErrors()) {
+      return;
+    }
+    this.validateActionId(this.config.actionId);
+    this.isWarmupInProgress = true;
+    this.incrementFetchCount();
+    this.warmupPromise = (async () => {
+      try {
+        this.scriptCache = await fetchScript(
+          this.config.actionId,
+          this.config.scriptUrl,
+          this.config.extraArgs
+        );
+        this.hasWarmupError = false;
+        this.recordFetchSuccess();
+      } catch {
+        this.hasWarmupError = true;
+        this.recordFetchError();
+      } finally {
+        this.isWarmupInProgress = false;
+      }
+    })();
+    await this.warmupPromise.catch(() => {
+    });
+  }
+  validateActionId(actionId) {
+    const sanitized = actionId.trim();
+    const validPattern = /^[a-zA-Z0-9/_-]+$/;
+    if (!validPattern.test(sanitized)) {
+      throw new Error("Invalid actionId format: contains disallowed characters");
+    }
+    return encodeURIComponent(sanitized);
+  }
+  prefetchNextScript() {
+    if (!this.hasWarmupError && this.config?.prefetch !== false) {
+      this.tryWarmup().catch(() => {
+      });
+    }
+  }
+  isTestMode() {
+    if (this.config?.actionId === "PULSE_TEST" || this.config?.actionId === "SENTRY_TEST") {
+      throw new Error("PULSE_TEST: This is a test error to verify Pulse integration is working");
+    }
+    return this.config?.actionId === "t/FFFFFFFFFFFFF/111111111" || this.config?.actionId === "t/FFFFFFFFFFFFF/000000000";
+  }
+  configure(params) {
+    try {
+      if (!params.actionId?.trim()) {
+        throw new Error("actionId is required and cannot be empty");
+      }
+      this.validateActionId(params.actionId);
+      if (this.config?.actionId === params.actionId && this.config.prefetch === params.prefetch && this.config.scriptUrl === params.scriptUrl) {
+        return;
+      }
+      const actionIdChanged = this.config?.actionId !== params.actionId;
+      if (actionIdChanged) {
+        this.hasWarmupError = false;
+        this.consecutiveErrorCount = 0;
+        this.lastErrorTime = 0;
+      }
+      this.scriptCache = null;
+      this.getTokenPromise = null;
+      this.config = { prefetch: true, ...params };
+      if (typeof window !== "undefined") {
+        window.Deflect.actionId = params.actionId;
+      }
+      if (!this.isTestMode() && this.config.prefetch !== false) {
+        this.tryWarmup();
+      }
+    } catch (error) {
+      const isUserError = error && typeof error === "object" && "isUserError" in error && error.isUserError === true;
+      this.reportError(
+        error,
+        {
+          deflect_sdk_error: "true",
+          deflect_user_error: isUserError ? "true" : "false",
+          method: "configure",
+          action_id: params?.actionId || "unknown"
+        },
+        {
+          actionId: params?.actionId,
+          hasCache: this.scriptCache !== null,
+          hasWarmupError: this.hasWarmupError
+        }
+      );
+      throw error;
+    }
+  }
+  async getToken() {
+    if (this.getTokenPromise) {
+      return this.getTokenPromise;
+    }
+    this.getTokenPromise = this.getTokenInternal();
+    try {
+      return await this.getTokenPromise;
+    } finally {
+      this.getTokenPromise = null;
+    }
+  }
+  async getTokenInternal() {
+    try {
+      if (!this.config?.actionId) {
+        throw new Error("Must call configure() before getToken()");
+      }
+      this.validateActionId(this.config.actionId);
+      if (this.isTestMode()) {
+        return "TESTTOKEN";
+      }
+      if (this.hasExceededMaxErrors()) {
+        throw new Error(
+          `Too many consecutive errors (${this.consecutiveErrorCount}). Call configure() with a new actionId or wait before retrying.`
+        );
+      }
+      if (this.isRateLimited()) {
+        throw new Error(
+          `Rate limit exceeded: ${MAX_FETCHES_PER_WINDOW} requests per minute. Please wait before retrying.`
+        );
+      }
+      if (this.isInErrorCooldown()) {
+        const backoffMs = Math.min(
+          ERROR_COOLDOWN_MS * Math.pow(2, this.consecutiveErrorCount - 1),
+          3e4
+        );
+        const remainingMs = backoffMs - (Date.now() - this.lastErrorTime);
+        throw new Error(
+          `In error cooldown. Please wait ${Math.ceil(remainingMs / 1e3)} seconds before retrying.`
+        );
+      }
+      let script;
+      if (this.warmupPromise) {
+        await this.warmupPromise.catch(() => {
+        });
+      }
+      if (this.scriptCache && !this.isWarmupInProgress) {
+        script = this.scriptCache;
+        this.scriptCache = null;
+      } else {
+        this.incrementFetchCount();
+        script = await fetchScript(
+          this.config.actionId,
+          this.config.scriptUrl,
+          this.config.extraArgs
+        );
+      }
+      return this.executeScript(script);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "";
+      const isGuardError = errorMessage.includes("cooldown") || errorMessage.includes("Rate limit") || errorMessage.includes("Too many consecutive");
+      if (!isGuardError) {
+        this.recordFetchError();
+      }
+      const isUserError = error && typeof error === "object" && "isUserError" in error && error.isUserError === true;
+      this.reportError(
+        error,
+        {
+          deflect_sdk_error: "true",
+          deflect_user_error: isUserError ? "true" : "false",
+          method: "getToken",
+          action_id: this.config?.actionId || "unknown",
+          has_cache: this.scriptCache !== null ? "true" : "false",
+          has_warmup_error: this.hasWarmupError ? "true" : "false",
+          consecutive_errors: this.consecutiveErrorCount.toString(),
+          stage: "call"
+        },
+        {
+          actionId: this.config?.actionId,
+          hasCache: this.scriptCache !== null,
+          hasWarmupError: this.hasWarmupError,
+          consecutiveErrorCount: this.consecutiveErrorCount,
+          fetchCountInWindow: this.fetchCountInWindow
+        }
+      );
+      throw error;
+    }
+  }
+  async executeScript(script) {
+    if (script.sessionId && typeof window !== "undefined") {
+      window.Deflect.sessionId = script.sessionId;
+    }
+    const blobUrl = createBlobUrl(script.content);
+    let scriptElement = null;
+    try {
+      scriptElement = await loadModuleScript(blobUrl);
+      await waitForGlobalFunction("getChallengeToken");
+      const token = await getTokenFromGlobal("getChallengeToken");
+      this.recordFetchSuccess();
+      this.prefetchNextScript();
+      return token;
+    } catch (error) {
+      this.reportError(
+        error,
+        {
+          deflect_sdk_error: "true",
+          method: "executeScript",
+          stage: "load_or_execute",
+          action_id: this.config?.actionId || "unknown"
+        },
+        {
+          hasCache: this.scriptCache !== null,
+          hasWarmupError: this.hasWarmupError
+        }
+      );
+      throw error;
+    } finally {
+      if (scriptElement) {
+        cleanup(blobUrl, scriptElement, "getChallengeToken");
+      } else {
+        URL.revokeObjectURL(blobUrl);
+      }
+    }
+  }
+  async warmup() {
+    if (!this.config?.actionId) {
+      return false;
+    }
+    try {
+      if (this.config.prefetch === false) {
+        return false;
+      }
+      await this.tryWarmup();
+      return this.scriptCache !== null;
+    } catch {
+      return false;
+    }
+  }
+  clearCache() {
+    this.scriptCache = null;
+  }
+  /** Reset error state to allow retries. Use after fixing configuration issues. */
+  resetErrorState() {
+    this.hasWarmupError = false;
+    this.consecutiveErrorCount = 0;
+    this.lastErrorTime = 0;
+    this.getTokenPromise = null;
+  }
+  /** Get current rate limit and error status for debugging */
+  getStatus() {
+    return {
+      isRateLimited: this.isRateLimited(),
+      isInCooldown: this.isInErrorCooldown(),
+      consecutiveErrors: this.consecutiveErrorCount,
+      fetchesInWindow: this.fetchCountInWindow,
+      canFetch: !this.isRateLimited() && !this.isInErrorCooldown() && !this.hasExceededMaxErrors()
+    };
+  }
+  async injectToken(event) {
+    if (!event || !event.target || !(event.target instanceof HTMLFormElement)) {
+      throw new Error("injectToken: must be called from a form submit event");
+    }
+    event.preventDefault();
+    const form = event.target;
+    const token = await this.getToken();
+    Array.from(form.querySelectorAll('input[name="deflect_token"]')).forEach(
+      (el) => el.remove()
+    );
+    const hidden = document.createElement("input");
+    hidden.type = "hidden";
+    hidden.name = "deflect_token";
+    hidden.value = token;
+    form.appendChild(hidden);
+    form.submit();
+  }
+  /**
+   * Create a new Deflect client instance with its own configuration.
+   * Use this when you need multiple actionIds on the same page.
+   * 
+   * @example
+   * const loginClient = Deflect.createClient({ actionId: 'login-form' });
+   * const signupClient = Deflect.createClient({ actionId: 'signup-form' });
+   * 
+   * // Each client manages its own state
+   * const loginToken = await loginClient.getToken();
+   * const signupToken = await signupClient.getToken();
+   */
+  createClient(config) {
+    return new DeflectClient(config, this.pulseReporter);
+  }
+}
+const DeflectInstance = new Deflect();
+if (typeof window !== "undefined") {
+  window.Deflect = DeflectInstance;
+}
+var src_default = DeflectInstance;
+export {
+  DeflectClient,
+  src_default as default
+};