@buoy-gg/impersonate 1.0.3-beta.0

package/lib/commonjs/impersonate/hooks/useImpersonate.js

@@ -0,0 +1,215 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useImpersonate = useImpersonate;
+var _react = require("react");
+var _impersonateStore = require("../utils/impersonateStore");
+var _impersonateListener = require("../utils/impersonateListener");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); } /**
+ * useImpersonate Hook
+ *
+ * Main hook for managing impersonation state and actions.
+ * Provides all the controls needed to search users, start/stop
+ * impersonation, and manage settings.
+ */
+/**
+ * Hook for managing impersonation
+ *
+ * @example
+ * ```tsx
+ * function ImpersonatePanel() {
+ *   const {
+ *     isActive,
+ *     currentUser,
+ *     searchUsers,
+ *     searchResults,
+ *     startImpersonation,
+ *     stopImpersonation,
+ *   } = useImpersonate({
+ *     onSearchUsers: async (query) => api.searchUsers(query),
+ *     onClearReactQuery: () => queryClient.clear(),
+ *   });
+ *
+ *   return (
+ *     <View>
+ *       {isActive ? (
+ *         <Text>Impersonating: {currentUser?.email}</Text>
+ *       ) : (
+ *         <Text>Not impersonating</Text>
+ *       )}
+ *     </View>
+ *   );
+ * }
+ * ```
+ */
+function useImpersonate(options = {}) {
+  const [searchQuery, setSearchQuery] = (0, _react.useState)("");
+  const [searchResults, setSearchResults] = (0, _react.useState)([]);
+  const [isSearching, setIsSearching] = (0, _react.useState)(false);
+  const [searchError, setSearchError] = (0, _react.useState)(null);
+
+  // Subscribe to store state using useSyncExternalStore
+  const state = (0, _react.useSyncExternalStore)(_impersonateStore.impersonateStore.subscribe, _impersonateStore.impersonateStore.getSnapshot, _impersonateStore.impersonateStore.getSnapshot // Server snapshot (same for SSR)
+  );
+
+  // Register nuke callbacks when they change
+  (0, _react.useEffect)(() => {
+    _impersonateStore.impersonateStore.registerNukeCallbacks({
+      reactQuery: options.onClearReactQuery,
+      redux: options.onClearRedux,
+      asyncStorage: options.onClearAsyncStorage,
+      mmkv: options.onClearMMKV
+    });
+  }, [options.onClearReactQuery, options.onClearRedux, options.onClearAsyncStorage, options.onClearMMKV]);
+
+  // Set up AsyncStorage reference immediately for writes, then load persisted state
+  (0, _react.useEffect)(() => {
+    let isMounted = true;
+    const setupAsyncStorage = async () => {
+      try {
+        // Dynamically import AsyncStorage
+        const AsyncStorage = await Promise.resolve().then(() => _interopRequireWildcard(require("@react-native-async-storage/async-storage"))).then(m => m.default);
+        const storageAdapter = {
+          getItem: key => AsyncStorage.getItem(key),
+          setItem: (key, value) => AsyncStorage.setItem(key, value)
+        };
+
+        // Set storage reference FIRST so writes work immediately
+        _impersonateStore.impersonateStore.setAsyncStorage(storageAdapter);
+
+        // Then load persisted state
+        if (isMounted) {
+          await _impersonateStore.impersonateStore.initializeAsync(storageAdapter);
+        }
+      } catch {
+        // AsyncStorage not available - using localStorage fallback (web)
+      }
+    };
+    setupAsyncStorage();
+
+    // Start listener
+    if (!(0, _impersonateListener.impersonateListener)().isListening) {
+      (0, _impersonateListener.impersonateListener)().startListening();
+    }
+    return () => {
+      isMounted = false;
+    };
+    // Don't stop listener on unmount - headers should keep being injected
+  }, []);
+
+  // Search users
+  const searchUsers = (0, _react.useCallback)(async query => {
+    setSearchQuery(query);
+    setSearchError(null);
+    if (!query.trim()) {
+      setSearchResults([]);
+      return;
+    }
+    if (!options.onSearchUsers) {
+      setSearchError("Search not configured");
+      setSearchResults([]);
+      return;
+    }
+    setIsSearching(true);
+    try {
+      const results = await options.onSearchUsers(query);
+      setSearchResults(results);
+    } catch (error) {
+      setSearchError(error instanceof Error ? error.message : "Search failed");
+      setSearchResults([]);
+    } finally {
+      setIsSearching(false);
+    }
+  }, [options.onSearchUsers]);
+
+  // Clear search
+  const clearSearch = (0, _react.useCallback)(() => {
+    setSearchQuery("");
+    setSearchResults([]);
+    setSearchError(null);
+  }, []);
+
+  // Start impersonation
+  const startImpersonation = (0, _react.useCallback)(async user => {
+    await _impersonateStore.impersonateStore.startImpersonation(user);
+  }, []);
+
+  // Stop impersonation
+  const stopImpersonation = (0, _react.useCallback)(async () => {
+    await _impersonateStore.impersonateStore.stopImpersonation();
+  }, []);
+
+  // Quick switch
+  const quickSwitch = (0, _react.useCallback)(async user => {
+    await _impersonateStore.impersonateStore.quickSwitch(user);
+  }, []);
+
+  // Update header key
+  const updateHeaderKey = (0, _react.useCallback)(async key => {
+    await _impersonateStore.impersonateStore.updateSettings({
+      headerKey: key
+    });
+  }, []);
+
+  // Update ignore patterns
+  const updateIgnorePatterns = (0, _react.useCallback)(async patterns => {
+    await _impersonateStore.impersonateStore.updateSettings({
+      ignorePatterns: patterns
+    });
+  }, []);
+
+  // Update data nuke settings
+  const updateDataNukeSettings = (0, _react.useCallback)(async settings => {
+    await _impersonateStore.impersonateStore.updateSettings({
+      dataNukeSettings: settings
+    });
+  }, []);
+
+  // Update show banner
+  const updateShowBanner = (0, _react.useCallback)(async show => {
+    await _impersonateStore.impersonateStore.updateSettings({
+      showBanner: show
+    });
+  }, []);
+
+  // Remove from history
+  const removeFromHistory = (0, _react.useCallback)(async userId => {
+    await _impersonateStore.impersonateStore.removeFromHistory(userId);
+  }, []);
+
+  // Clear history
+  const clearHistory = (0, _react.useCallback)(async () => {
+    await _impersonateStore.impersonateStore.clearHistory();
+  }, []);
+  return {
+    // State
+    isActive: state.isActive,
+    currentUser: state.currentUser,
+    headerKey: state.headerKey,
+    ignorePatterns: state.ignorePatterns,
+    dataNukeSettings: state.dataNukeSettings,
+    showBanner: state.showBanner,
+    history: state.history,
+    // Search
+    searchQuery,
+    searchResults,
+    isSearching,
+    searchError,
+    searchUsers,
+    clearSearch,
+    // Actions
+    startImpersonation,
+    stopImpersonation,
+    quickSwitch,
+    // Settings
+    updateHeaderKey,
+    updateIgnorePatterns,
+    updateDataNukeSettings,
+    updateShowBanner,
+    // History
+    removeFromHistory,
+    clearHistory
+  };
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useImpersonateHistory = useImpersonateHistory;
+var _react = require("react");
+var _impersonateStore = require("../utils/impersonateStore");
+/**
+ * useImpersonateHistory Hook
+ *
+ * Specialized hook for working with impersonation history.
+ * Use this when you only need history functionality.
+ */
+
+/**
+ * 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>
+ *       )}
+ *     />
+ *   );
+ * }
+ * ```
+ */
+function useImpersonateHistory() {
+  const state = (0, _react.useSyncExternalStore)(_impersonateStore.impersonateStore.subscribe, _impersonateStore.impersonateStore.getSnapshot, _impersonateStore.impersonateStore.getSnapshot);
+  const quickSwitch = (0, _react.useCallback)(async user => {
+    await _impersonateStore.impersonateStore.quickSwitch(user);
+  }, []);
+  const removeFromHistory = (0, _react.useCallback)(async userId => {
+    await _impersonateStore.impersonateStore.removeFromHistory(userId);
+  }, []);
+  const clearHistory = (0, _react.useCallback)(async () => {
+    await _impersonateStore.impersonateStore.clearHistory();
+  }, []);
+  return {
+    history: state.history,
+    currentUserId: state.currentUser?.id ?? null,
+    quickSwitch,
+    removeFromHistory,
+    clearHistory
+  };
+}

package/lib/commonjs/impersonate/index.js

@@ -0,0 +1,49 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+var _utils = require("./utils");
+Object.keys(_utils).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _utils[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _utils[key];
+    }
+  });
+});
+var _hooks = require("./hooks");
+Object.keys(_hooks).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _hooks[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _hooks[key];
+    }
+  });
+});
+var _components = require("./components");
+Object.keys(_components).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _components[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _components[key];
+    }
+  });
+});

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

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});

package/lib/commonjs/impersonate/types/types.js

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

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

@@ -0,0 +1,280 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getImpersonatedUserId = getImpersonatedUserId;
+exports.impersonateListener = impersonateListener;
+exports.isImpersonating = isImpersonating;
+exports.setImpersonateConfig = setImpersonateConfig;
+exports.startImpersonateListener = startImpersonateListener;
+exports.stopImpersonateListener = stopImpersonateListener;
+/**
+ * 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
+ */
+function impersonateListener() {
+  if (!_instance) {
+    _instance = new ImpersonateListener();
+  }
+  return _instance;
+}
+
+/**
+ * Convenience function to start the listener
+ */
+function startImpersonateListener() {
+  impersonateListener().startListening();
+}
+
+/**
+ * Convenience function to stop the listener
+ */
+function stopImpersonateListener() {
+  impersonateListener().stopListening();
+}
+
+/**
+ * Convenience function to update config
+ */
+function setImpersonateConfig(config) {
+  impersonateListener().setConfig(config);
+}
+
+/**
+ * Convenience function to check if impersonating
+ */
+function isImpersonating() {
+  return _instance?.isImpersonating ?? false;
+}
+
+/**
+ * Convenience function to get impersonated user ID
+ */
+function getImpersonatedUserId() {
+  return _instance?.getConfig().userId ?? null;
+}