@buoy-gg/impersonate 1.0.3-beta.0

package/lib/module/impersonate/hooks/useImpersonateHistory.js

@@ -0,0 +1,52 @@
+"use strict";
+
+/**
+ * useImpersonateHistory Hook
+ *
+ * Specialized hook for working with impersonation history.
+ * Use this when you only need history functionality.
+ */
+
+import { useCallback, useSyncExternalStore } from "react";
+import { impersonateStore } from "../utils/impersonateStore";
+/**
+ * Hook for managing impersonation history
+ *
+ * @example
+ * ```tsx
+ * function HistoryList() {
+ *   const { history, currentUserId, quickSwitch } = useImpersonateHistory();
+ *
+ *   return (
+ *     <FlatList
+ *       data={history}
+ *       renderItem={({ item }) => (
+ *         <TouchableOpacity onPress={() => quickSwitch(item)}>
+ *           <Text>{item.email}</Text>
+ *           {currentUserId === item.id && <Badge>Active</Badge>}
+ *         </TouchableOpacity>
+ *       )}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+export function useImpersonateHistory() {
+  const state = useSyncExternalStore(impersonateStore.subscribe, impersonateStore.getSnapshot, impersonateStore.getSnapshot);
+  const quickSwitch = useCallback(async user => {
+    await impersonateStore.quickSwitch(user);
+  }, []);
+  const removeFromHistory = useCallback(async userId => {
+    await impersonateStore.removeFromHistory(userId);
+  }, []);
+  const clearHistory = useCallback(async () => {
+    await impersonateStore.clearHistory();
+  }, []);
+  return {
+    history: state.history,
+    currentUserId: state.currentUser?.id ?? null,
+    quickSwitch,
+    removeFromHistory,
+    clearHistory
+  };
+}

package/lib/module/impersonate/index.js

@@ -0,0 +1,13 @@
+"use strict";
+
+// Types
+export * from "./types";
+
+// Utils
+export * from "./utils";
+
+// Hooks
+export * from "./hooks";
+
+// Components
+export * from "./components";

package/lib/module/impersonate/types/index.js

@@ -0,0 +1,3 @@
+"use strict";
+
+export * from "./types";

package/lib/module/impersonate/types/types.js

@@ -0,0 +1 @@
+"use strict";

package/lib/module/impersonate/utils/impersonateListener.js

@@ -0,0 +1,271 @@
+"use strict";
+
+/**
+ * Impersonate Listener - Header Injection via Fetch/XHR Monkey-Patching
+ *
+ * This module intercepts all network requests and injects the impersonation
+ * header when impersonation is active. It follows the same singleton pattern
+ * as @buoy-gg/network's networkListener.
+ */
+
+// Extended XMLHttpRequest interface for tracking URL
+
+/**
+ * Default URL patterns to ignore (won't inject header)
+ * These are development-related URLs that shouldn't have impersonation
+ */
+const DEFAULT_IGNORE_PATTERNS = [/\/symbolicate$/, /\/logs$/, /\/debugger-proxy/, /\/reload$/, /\/launch-js-devtools/, /localhost:8081/, /100\.64\.\d+\.\d+:8081/,
+// iOS simulator Metro
+/10\.0\.\d+\.\d+:8081/,
+// Android emulator Metro
+/\.hot-update\./, /__metro/];
+
+/**
+ * Impersonation header injector for network requests
+ *
+ * This class monkey-patches fetch and XMLHttpRequest to inject the
+ * impersonation header on all outgoing requests when impersonation is active.
+ *
+ * @example
+ * ```typescript
+ * // Get the singleton instance
+ * const listener = impersonateListener();
+ *
+ * // Configure impersonation
+ * listener.setConfig({
+ *   headerKey: 'x-impersonate-user-id',
+ *   userId: '12345',
+ *   ignorePatterns: [/\/health/]
+ * });
+ *
+ * // Start injecting headers
+ * listener.startListening();
+ *
+ * // All fetch/XHR requests will now include the header
+ *
+ * // Stop injecting when done
+ * listener.stopListening();
+ * ```
+ */
+class ImpersonateListener {
+  isListeningFlag = false;
+
+  // Store original methods - MUST be captured before other tools patch
+
+  constructor() {
+    // Initialize with current fetch - will be re-captured in startListening
+    this.originalFetch = globalThis.fetch.bind(globalThis);
+    this.originalXHROpen = XMLHttpRequest.prototype.open;
+    this.originalXHRSend = XMLHttpRequest.prototype.send;
+    this.config = {
+      headerKey: "x-impersonate-user-id",
+      userId: null,
+      ignorePatterns: [...DEFAULT_IGNORE_PATTERNS]
+    };
+  }
+
+  /**
+   * Update impersonation config without restarting listener
+   *
+   * This is the primary way to activate/deactivate impersonation.
+   * Set userId to null to stop injecting headers.
+   */
+  setConfig(partial) {
+    this.config = {
+      ...this.config,
+      ...partial
+    };
+
+    // Merge ignore patterns if provided
+    if (partial.ignorePatterns) {
+      this.config.ignorePatterns = [...DEFAULT_IGNORE_PATTERNS, ...partial.ignorePatterns];
+    }
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig() {
+    return {
+      ...this.config
+    };
+  }
+
+  /**
+   * Check if URL should have header injected
+   *
+   * Returns false if:
+   * - No userId is set (not impersonating)
+   * - URL matches any ignore pattern
+   */
+  shouldInjectHeader(url) {
+    // Not impersonating
+    if (!this.config.userId) {
+      return false;
+    }
+
+    // Check ignore patterns
+    return !this.config.ignorePatterns.some(pattern => pattern.test(url));
+  }
+
+  /**
+   * Extract URL from various input types
+   */
+  extractUrl(input) {
+    if (typeof input === "string") {
+      return input;
+    }
+    if (input instanceof URL) {
+      return input.href;
+    }
+    // Request object
+    return input.url;
+  }
+
+  /**
+   * Start intercepting and injecting headers
+   *
+   * This patches globalThis.fetch and XMLHttpRequest.prototype methods
+   * to inject the impersonation header on all requests.
+   */
+  startListening() {
+    if (this.isListeningFlag) {
+      return;
+    }
+
+    // CRITICAL: Re-capture fetch/XHR NOW, not at construction time
+    // This ensures we patch OVER any existing interceptors (like @buoy-gg/network)
+    // so our modifications are visible to them
+    this.originalFetch = globalThis.fetch.bind(globalThis);
+    this.originalXHROpen = XMLHttpRequest.prototype.open;
+    this.originalXHRSend = XMLHttpRequest.prototype.send;
+    const self = this;
+
+    // =======================================================================
+    // PATCH FETCH
+    // =======================================================================
+    globalThis.fetch = async function (input, init) {
+      const url = self.extractUrl(input);
+      if (self.shouldInjectHeader(url)) {
+        // Create new headers with impersonation header added
+        const existingHeaders = init?.headers;
+        const headers = new Headers(existingHeaders);
+        headers.set(self.config.headerKey, self.config.userId);
+
+        // Call original fetch with modified init
+        return self.originalFetch(input, {
+          ...init,
+          headers
+        });
+      }
+
+      // Not injecting - call original fetch as-is
+      return self.originalFetch(input, init);
+    };
+
+    // =======================================================================
+    // PATCH XMLHttpRequest
+    // =======================================================================
+
+    // Patch open() to store the URL for later use in send()
+    XMLHttpRequest.prototype.open = function (method, url, async = true, username, password) {
+      const xhr = this;
+      xhr._impersonateUrl = typeof url === "string" ? url : url.href;
+      const urlStr = typeof url === "string" ? url : url.toString();
+      return self.originalXHROpen.call(this, method, urlStr, async, username, password);
+    };
+
+    // Patch send() to inject header before sending
+    XMLHttpRequest.prototype.send = function (body) {
+      const xhr = this;
+      if (xhr._impersonateUrl && self.shouldInjectHeader(xhr._impersonateUrl)) {
+        // Inject the impersonation header
+        this.setRequestHeader(self.config.headerKey, self.config.userId);
+      }
+      return self.originalXHRSend.call(this, body);
+    };
+    this.isListeningFlag = true;
+  }
+
+  /**
+   * Stop intercepting - restore original methods
+   *
+   * Note: This restores fetch/XHR to their state when ImpersonateListener
+   * was constructed. If other interceptors were installed after, this may
+   * break their functionality.
+   */
+  stopListening() {
+    if (!this.isListeningFlag) {
+      return;
+    }
+    globalThis.fetch = this.originalFetch;
+    XMLHttpRequest.prototype.open = this.originalXHROpen;
+    XMLHttpRequest.prototype.send = this.originalXHRSend;
+    this.isListeningFlag = false;
+  }
+
+  /**
+   * Check if listener is currently active
+   */
+  get isListening() {
+    return this.isListeningFlag;
+  }
+
+  /**
+   * Check if impersonation is currently active (has userId set)
+   */
+  get isImpersonating() {
+    return this.config.userId !== null;
+  }
+}
+
+// =============================================================================
+// SINGLETON PATTERN
+// =============================================================================
+
+let _instance = null;
+
+/**
+ * Get the singleton ImpersonateListener instance
+ */
+export function impersonateListener() {
+  if (!_instance) {
+    _instance = new ImpersonateListener();
+  }
+  return _instance;
+}
+
+/**
+ * Convenience function to start the listener
+ */
+export function startImpersonateListener() {
+  impersonateListener().startListening();
+}
+
+/**
+ * Convenience function to stop the listener
+ */
+export function stopImpersonateListener() {
+  impersonateListener().stopListening();
+}
+
+/**
+ * Convenience function to update config
+ */
+export function setImpersonateConfig(config) {
+  impersonateListener().setConfig(config);
+}
+
+/**
+ * Convenience function to check if impersonating
+ */
+export function isImpersonating() {
+  return _instance?.isImpersonating ?? false;
+}
+
+/**
+ * Convenience function to get impersonated user ID
+ */
+export function getImpersonatedUserId() {
+  return _instance?.getConfig().userId ?? null;
+}