@symbo.ls/sdk 2.34.35 → 3.1.2

package/dist/esm/services/IntegrationService.js

@@ -1,1319 +0,0 @@
-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/config/environment.js
-import { isDevelopment } from "@domql/utils";
-var CONFIG = {
-  // Common defaults for all environments
-  common: {
-    // NOTE: Google client id for google auth, need to configure URLs for each environment in Google console
-    googleClientId: "686286207466-bvd2fqs31rlm64fgich7rtpnc8ns2tqg.apps.googleusercontent.com",
-    // Feature toggles that apply across all environments by default
-    features: {
-      newUserOnboarding: true,
-      betaFeatures: false,
-      // Tracking is enabled by default unless overridden per environment
-      trackingEnabled: true
-    }
-  },
-  // Environment-specific configurations
-  local: {
-    // local
-    socketUrl: "http://localhost:8080",
-    // For socket api
-    apiUrl: "http://localhost:8080",
-    // For server api
-    basedEnv: "development",
-    // For based api
-    basedProject: "platform-v2-sm",
-    // For based api
-    basedOrg: "symbols",
-    // For based api
-    githubClientId: "Ov23liAFrsR0StbAO6PO",
-    // For github api
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Localhost",
-    // Environment-specific feature toggles (override common)
-    features: {
-      // Disable tracking by default on localhost/dev machines
-      trackingEnabled: false,
-      // Enable beta features in local dev
-      betaFeatures: true,
-      // Preserve common defaults explicitly for local
-      newUserOnboarding: true
-    },
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "vZya3L2zpq8L6iI5WWMUZJZABvT63VDb",
-    typesenseHost: "localhost",
-    typesensePort: "8108",
-    typesenseProtocol: "http"
-  },
-  development: {
-    socketUrl: "https://dev.api.symbols.app",
-    apiUrl: "https://dev.api.symbols.app",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/7a3ba473cee2025c68513667024316b8",
-    // For grafana tracing
-    grafanaAppName: "Symbols Dev",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  testing: {
-    socketUrl: "https://test.api.symbols.app",
-    apiUrl: "https://test.api.symbols.app",
-    basedEnv: "testing",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23liHxyWFBxS8f1gnF",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Test",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  upcoming: {
-    socketUrl: "https://upcoming.api.symbols.app",
-    apiUrl: "https://upcoming.api.symbols.app",
-    githubClientId: "Ov23liWF7NvdZ056RV5J",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Upcoming",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  staging: {
-    socketUrl: "https://staging.api.symbols.app",
-    apiUrl: "https://staging.api.symbols.app",
-    basedEnv: "staging",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23ligwZDQVD0VfuWNa",
-    grafanaUrl: "",
-    // For grafana tracing
-    grafanaAppName: "Symbols Staging",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  preview: {
-    socketUrl: "https://api.symbols.app",
-    apiUrl: "https://api.symbols.app",
-    basedEnv: "production",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae",
-    // For grafana tracing
-    grafanaAppName: "Symbols Preview",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  },
-  production: {
-    socketUrl: "https://api.symbols.app",
-    apiUrl: "https://api.symbols.app",
-    basedEnv: "production",
-    basedProject: "platform-v2-sm",
-    basedOrg: "symbols",
-    githubClientId: "Ov23liFAlOEIXtX3dBtR",
-    grafanaUrl: "https://faro-collector-prod-us-east-0.grafana.net/collect/5c1089f3c3eea4ec5658e05c3f53baae",
-    // For grafana tracing
-    grafanaAppName: "Symbols",
-    typesenseCollectionName: "docs",
-    typesenseApiKey: "awmcVpbWqZi9IUgmvslp1C5LKDU8tMjA",
-    typesenseHost: "tl2qpnwxev4cjm36p-1.a1.typesense.net",
-    typesensePort: "443",
-    typesenseProtocol: "https"
-  }
-};
-var getEnvironment = () => {
-  const env = process.env.SYMBOLS_APP_ENV || process.env.NODE_ENV;
-  if (!CONFIG[env]) {
-    throw new Error(`Unknown environment "${env}"`);
-  }
-  return env;
-};
-var getConfig = () => {
-  try {
-    const env = getEnvironment();
-    const envConfig = { ...CONFIG.common, ...CONFIG[env] };
-    const finalConfig = {
-      ...envConfig,
-      // Deep-merge feature flags so env-specific overrides don't drop common defaults
-      features: {
-        ...CONFIG.common.features || {},
-        ...CONFIG[env] && CONFIG[env].features || {}
-      },
-      socketUrl: process.env.SYMBOLS_APP_SOCKET_URL || envConfig.socketUrl,
-      apiUrl: process.env.SYMBOLS_APP_API_URL || envConfig.apiUrl,
-      basedEnv: process.env.SYMBOLS_APP_BASED_ENV || envConfig.basedEnv,
-      basedProject: process.env.SYMBOLS_APP_BASED_PROJECT || envConfig.basedProject,
-      basedOrg: process.env.SYMBOLS_APP_BASED_ORG || envConfig.basedOrg,
-      githubClientId: process.env.SYMBOLS_APP_GITHUB_CLIENT_ID || envConfig.githubClientId,
-      grafanaUrl: process.env.SYMBOLS_APP_GRAFANA_URL || envConfig.grafanaUrl,
-      typesenseCollectionName: process.env.TYPESENSE_COLLECTION_NAME || envConfig.typesenseCollectionName,
-      typesenseApiKey: process.env.TYPESENSE_API_KEY || envConfig.typesenseApiKey,
-      typesenseHost: process.env.TYPESENSE_HOST || envConfig.typesenseHost,
-      typesensePort: process.env.TYPESENSE_PORT || envConfig.typesensePort,
-      typesenseProtocol: process.env.TYPESENSE_PROTOCOL || envConfig.typesenseProtocol,
-      isDevelopment: isDevelopment(env),
-      isTesting: env === "testing",
-      isStaging: env === "staging",
-      isPreview: env === "preview",
-      isProduction: env === "production"
-      // Store all environment variables for potential future use
-    };
-    const requiredFields = [
-      "socketUrl",
-      "apiUrl",
-      "githubClientId",
-      "googleClientId"
-    ];
-    const missingFields = requiredFields.filter((field) => !finalConfig[field]);
-    if (missingFields.length > 0) {
-      console.error(
-        `Missing required configuration: ${missingFields.join(", ")}`
-      );
-    }
-    if (finalConfig.isDevelopment) {
-      console.warn(
-        "environment in SDK:",
-        env || process.env.NODE_ENV || process.env.NODE_ENV
-      );
-      console.log(finalConfig);
-    } else if (global.window) {
-      global.window.finalConfig = finalConfig;
-    }
-    return finalConfig;
-  } catch (error) {
-    console.error("Failed to load environment configuration:", error);
-    return {
-      ...CONFIG.development
-    };
-  }
-};
-var environment_default = getConfig();
-
-// src/utils/TokenManager.js
-var TokenManager = class {
-  constructor(options = {}) {
-    /**
-     * Memory storage fallback for server-side rendering
-     */
-    __publicField(this, "_memoryStorage", {
-      _data: {},
-      getItem: (key) => this._memoryStorage._data[key] || null,
-      setItem: (key, value) => {
-        this._memoryStorage._data[key] = value;
-      },
-      removeItem: (key) => {
-        delete this._memoryStorage._data[key];
-      },
-      clear: () => {
-        this._memoryStorage._data = {};
-      }
-    });
-    this.config = {
-      storagePrefix: "symbols_",
-      storageType: typeof window === "undefined" || process.env.NODE_ENV === "test" || process.env.NODE_ENV === "testing" ? "memory" : "localStorage",
-      // 'localStorage' | 'sessionStorage' | 'memory'
-      refreshBuffer: 60 * 1e3,
-      // Refresh 1 minute before expiry
-      maxRetries: 3,
-      apiUrl: options.apiUrl || "/api",
-      onTokenRefresh: options.onTokenRefresh || null,
-      onTokenExpired: options.onTokenExpired || null,
-      onTokenError: options.onTokenError || null,
-      ...options
-    };
-    this.tokens = {
-      accessToken: null,
-      refreshToken: null,
-      expiresAt: null,
-      expiresIn: null
-    };
-    this.refreshPromise = null;
-    this.refreshTimeout = null;
-    this.retryCount = 0;
-    this.loadTokens();
-  }
-  /**
-   * Storage keys
-   */
-  get storageKeys() {
-    return {
-      accessToken: `${this.config.storagePrefix}access_token`,
-      refreshToken: `${this.config.storagePrefix}refresh_token`,
-      expiresAt: `${this.config.storagePrefix}expires_at`,
-      expiresIn: `${this.config.storagePrefix}expires_in`
-    };
-  }
-  /**
-   * Get storage instance based on configuration
-   */
-  get storage() {
-    if (typeof window === "undefined") {
-      return this._memoryStorage;
-    }
-    const safeGetStorage = (provider) => {
-      try {
-        const storage = provider();
-        const testKey = `${this.config.storagePrefix}__tm_test__`;
-        storage.setItem(testKey, "1");
-        storage.removeItem(testKey);
-        return storage;
-      } catch {
-        return null;
-      }
-    };
-    const localStorageInstance = safeGetStorage(() => window.localStorage);
-    const sessionStorageInstance = safeGetStorage(() => window.sessionStorage);
-    switch (this.config.storageType) {
-      case "sessionStorage":
-        return sessionStorageInstance || this._memoryStorage;
-      case "memory":
-        return this._memoryStorage;
-      default:
-        return localStorageInstance || this._memoryStorage;
-    }
-  }
-  /**
-   * Set tokens and persist to storage
-   */
-  setTokens(tokenData) {
-    const {
-      access_token: accessToken,
-      refresh_token: refreshToken,
-      expires_in: expiresIn,
-      token_type: tokenType = "Bearer"
-    } = tokenData;
-    if (!accessToken) {
-      throw new Error("Access token is required");
-    }
-    const now = Date.now();
-    const expiresAt = expiresIn ? now + expiresIn * 1e3 : null;
-    this.tokens = {
-      accessToken,
-      refreshToken: refreshToken || this.tokens.refreshToken,
-      expiresAt,
-      expiresIn,
-      tokenType
-    };
-    this.saveTokens();
-    this.scheduleRefresh();
-    if (this.config.onTokenRefresh) {
-      this.config.onTokenRefresh(this.tokens);
-    }
-    return this.tokens;
-  }
-  /**
-   * Get current access token
-   */
-  getAccessToken() {
-    return this.tokens.accessToken;
-  }
-  /**
-   * Get current refresh token
-   */
-  getRefreshToken() {
-    return this.tokens.refreshToken;
-  }
-  /**
-   * Get authorization header value
-   */
-  getAuthHeader() {
-    const token = this.getAccessToken();
-    if (!token) {
-      return null;
-    }
-    return `${this.tokens.tokenType || "Bearer"} ${token}`;
-  }
-  /**
-   * Check if access token is valid and not expired
-   */
-  isAccessTokenValid() {
-    if (!this.tokens.accessToken) {
-      return false;
-    }
-    if (!this.tokens.expiresAt) {
-      return true;
-    }
-    const now = Date.now();
-    const isValid = now < this.tokens.expiresAt - this.config.refreshBuffer;
-    if (!isValid) {
-      console.log("[TokenManager] Access token is expired or near expiry:", {
-        now: new Date(now).toISOString(),
-        expiresAt: new Date(this.tokens.expiresAt).toISOString(),
-        refreshBuffer: this.config.refreshBuffer
-      });
-    }
-    return isValid;
-  }
-  /**
-   * Check if access token exists and is not expired (without refresh buffer)
-   */
-  isAccessTokenActuallyValid() {
-    if (!this.tokens.accessToken) {
-      return false;
-    }
-    if (!this.tokens.expiresAt) {
-      return true;
-    }
-    const now = Date.now();
-    return now < this.tokens.expiresAt;
-  }
-  /**
-   * Check if tokens exist (regardless of expiry)
-   */
-  hasTokens() {
-    return Boolean(this.tokens.accessToken);
-  }
-  /**
-   * Check if refresh token exists
-   */
-  hasRefreshToken() {
-    return Boolean(this.tokens.refreshToken);
-  }
-  /**
-   * Automatically refresh tokens if needed
-   */
-  async ensureValidToken() {
-    if (!this.hasTokens()) {
-      return null;
-    }
-    if (this.isAccessTokenValid()) {
-      return this.getAccessToken();
-    }
-    if (!this.hasRefreshToken()) {
-      this.clearTokens();
-      if (this.config.onTokenExpired) {
-        this.config.onTokenExpired();
-      }
-      return null;
-    }
-    try {
-      await this.refreshTokens();
-      return this.getAccessToken();
-    } catch (error) {
-      this.clearTokens();
-      if (this.config.onTokenError) {
-        this.config.onTokenError(error);
-      }
-      throw error;
-    }
-  }
-  /**
-   * Refresh access token using refresh token
-   */
-  async refreshTokens() {
-    if (this.refreshPromise) {
-      return this.refreshPromise;
-    }
-    if (!this.hasRefreshToken()) {
-      throw new Error("No refresh token available");
-    }
-    if (this.retryCount >= this.config.maxRetries) {
-      throw new Error("Max refresh retries exceeded");
-    }
-    this.refreshPromise = this._performRefresh();
-    try {
-      const result = await this.refreshPromise;
-      this.retryCount = 0;
-      return result;
-    } catch (error) {
-      this.retryCount++;
-      throw error;
-    } finally {
-      this.refreshPromise = null;
-    }
-  }
-  /**
-   * Perform the actual token refresh request
-   */
-  async _performRefresh() {
-    var _a;
-    const refreshToken = this.getRefreshToken();
-    const response = await fetch(`${this.config.apiUrl}/core/auth/refresh`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({ refreshToken })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      throw new Error(errorData.message || `Token refresh failed: ${response.status}`);
-    }
-    const responseData = await response.json();
-    if (responseData.success && responseData.data && responseData.data.tokens) {
-      const { tokens } = responseData.data;
-      const tokenData = {
-        access_token: tokens.accessToken,
-        refresh_token: tokens.refreshToken,
-        expires_in: (_a = tokens.accessTokenExp) == null ? void 0 : _a.expiresIn,
-        token_type: "Bearer"
-      };
-      return this.setTokens(tokenData);
-    }
-    return this.setTokens(responseData);
-  }
-  /**
-   * Schedule automatic token refresh
-   */
-  scheduleRefresh() {
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    if (!this.tokens.expiresAt || !this.hasRefreshToken()) {
-      return;
-    }
-    const now = Date.now();
-    const refreshTime = this.tokens.expiresAt - this.config.refreshBuffer;
-    const delay = Math.max(0, refreshTime - now);
-    this.refreshTimeout = setTimeout(async () => {
-      try {
-        await this.refreshTokens();
-      } catch (error) {
-        console.error("Automatic token refresh failed:", error);
-        if (this.config.onTokenError) {
-          this.config.onTokenError(error);
-        }
-      }
-    }, delay);
-  }
-  /**
-   * Save tokens to storage
-   */
-  saveTokens() {
-    try {
-      const { storage } = this;
-      const keys = this.storageKeys;
-      if (this.tokens.accessToken) {
-        storage.setItem(keys.accessToken, this.tokens.accessToken);
-      }
-      if (this.tokens.refreshToken) {
-        storage.setItem(keys.refreshToken, this.tokens.refreshToken);
-      }
-      if (this.tokens.expiresAt) {
-        storage.setItem(keys.expiresAt, this.tokens.expiresAt.toString());
-      }
-      if (this.tokens.expiresIn) {
-        storage.setItem(keys.expiresIn, this.tokens.expiresIn.toString());
-      }
-    } catch (error) {
-      console.error("[TokenManager] Error saving tokens to storage:", error);
-    }
-  }
-  /**
-   * Load tokens from storage
-   */
-  loadTokens() {
-    try {
-      const { storage } = this;
-      const keys = this.storageKeys;
-      const accessToken = storage.getItem(keys.accessToken);
-      const refreshToken = storage.getItem(keys.refreshToken);
-      const expiresAt = storage.getItem(keys.expiresAt);
-      const expiresIn = storage.getItem(keys.expiresIn);
-      if (accessToken) {
-        this.tokens = {
-          accessToken,
-          refreshToken,
-          expiresAt: expiresAt ? parseInt(expiresAt, 10) : null,
-          expiresIn: expiresIn ? parseInt(expiresIn, 10) : null,
-          tokenType: "Bearer"
-        };
-        this.scheduleRefresh();
-      }
-    } catch (error) {
-      console.error("[TokenManager] Error loading tokens from storage:", error);
-      this.tokens = {
-        accessToken: null,
-        refreshToken: null,
-        expiresAt: null,
-        expiresIn: null
-      };
-    }
-  }
-  /**
-   * Clear all tokens
-   */
-  clearTokens() {
-    this.tokens = {
-      accessToken: null,
-      refreshToken: null,
-      expiresAt: null,
-      expiresIn: null
-    };
-    const { storage } = this;
-    const keys = this.storageKeys;
-    Object.values(keys).forEach((key) => {
-      storage.removeItem(key);
-    });
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    this.retryCount = 0;
-  }
-  /**
-   * Get token status information
-   */
-  getTokenStatus() {
-    const hasTokens = this.hasTokens();
-    const isValid = this.isAccessTokenValid();
-    const { expiresAt } = this.tokens;
-    const timeToExpiry = expiresAt ? expiresAt - Date.now() : null;
-    return {
-      hasTokens,
-      isValid,
-      hasRefreshToken: this.hasRefreshToken(),
-      expiresAt,
-      timeToExpiry,
-      willExpireSoon: timeToExpiry ? timeToExpiry < this.config.refreshBuffer : false
-    };
-  }
-  /**
-   * Cleanup resources
-   */
-  destroy() {
-    if (this.refreshTimeout) {
-      clearTimeout(this.refreshTimeout);
-      this.refreshTimeout = null;
-    }
-    this.refreshPromise = null;
-  }
-};
-var defaultTokenManager = null;
-var getTokenManager = (options) => {
-  if (!defaultTokenManager) {
-    defaultTokenManager = new TokenManager(options);
-  }
-  return defaultTokenManager;
-};
-
-// src/services/BaseService.js
-var BaseService = class {
-  constructor({ context, options } = {}) {
-    this._context = context || {};
-    this._options = options || {};
-    this._ready = false;
-    this._error = null;
-    this._apiUrl = null;
-    this._tokenManager = null;
-  }
-  // Initialize service
-  init({ context }) {
-    try {
-      const { apiUrl } = context || this._context;
-      this._apiUrl = apiUrl || environment_default.apiUrl;
-      if (!this._apiUrl) {
-        throw new Error("Service base URL not configured");
-      }
-      this._tokenManager = getTokenManager({
-        apiUrl: this._apiUrl,
-        onTokenError: (error) => {
-          console.error("Token management error:", error);
-        }
-      });
-      this._setReady();
-    } catch (error) {
-      this._setError(error);
-      throw error;
-    }
-  }
-  // Update context
-  updateContext(context) {
-    if (context && typeof context === "object") {
-      Object.assign(this._context, context);
-    }
-  }
-  // Get service status
-  getStatus() {
-    return {
-      ready: this._ready,
-      error: this._error,
-      context: { ...this._context }
-    };
-  }
-  // Check if service is ready
-  isReady() {
-    return this._ready;
-  }
-  // Protected helper methods
-  _setReady(ready = true) {
-    this._ready = ready;
-    this._error = null;
-  }
-  _setError(error) {
-    this._ready = false;
-    this._error = error;
-  }
-  _getTrackingService() {
-    var _a;
-    const services = (_a = this._context) == null ? void 0 : _a.services;
-    const tracking = services == null ? void 0 : services.tracking;
-    if (!tracking || typeof tracking.trackError !== "function") {
-      return null;
-    }
-    return tracking;
-  }
-  _shouldTrackErrors() {
-    var _a;
-    const name = (_a = this == null ? void 0 : this.constructor) == null ? void 0 : _a.name;
-    return name !== "TrackingService";
-  }
-  _trackServiceError(error, details = {}) {
-    var _a;
-    if (!this._shouldTrackErrors()) {
-      return;
-    }
-    try {
-      const tracking = this._getTrackingService();
-      if (!tracking) {
-        return;
-      }
-      const context = {
-        service: ((_a = this == null ? void 0 : this.constructor) == null ? void 0 : _a.name) || "UnknownService",
-        apiUrl: this._apiUrl || null,
-        ...details
-      };
-      tracking.trackError(error instanceof Error ? error : new Error(String(error)), context);
-    } catch {
-    }
-  }
-  _requireAuth() {
-    if (!this.getAuthToken()) {
-      throw new Error("Authentication required");
-    }
-  }
-  _requireReady(methodName = "unknown") {
-    if (!this.isReady()) {
-      throw new Error(`Service not initialized for method: ${methodName}`);
-    }
-  }
-  // Shared HTTP request method
-  async _request(endpoint, options = {}) {
-    const url = `${this._apiUrl}/core${endpoint}`;
-    const defaultHeaders = {};
-    if (!(options.body instanceof FormData)) {
-      defaultHeaders["Content-Type"] = "application/json";
-    }
-    if (this._requiresInit(options.methodName) && this._tokenManager) {
-      try {
-        const validToken = await this._tokenManager.ensureValidToken();
-        if (validToken) {
-          const authHeader = this._tokenManager.getAuthHeader();
-          if (authHeader) {
-            defaultHeaders.Authorization = authHeader;
-          }
-        }
-      } catch (error) {
-        console.warn(
-          "Token management failed, proceeding without authentication:",
-          error
-        );
-      }
-    }
-    try {
-      const response = await fetch(url, {
-        ...options,
-        headers: {
-          ...defaultHeaders,
-          ...options.headers
-        }
-      });
-      if (!response.ok) {
-        let error = {
-          message: `HTTP ${response.status}: ${response.statusText}`
-        };
-        try {
-          error = await response.json();
-        } catch {
-        }
-        this._trackServiceError(
-          new Error(error.message || error.error || `HTTP ${response.status}: ${response.statusText}`),
-          {
-            endpoint,
-            methodName: options.methodName,
-            status: response.status,
-            statusText: response.statusText
-          }
-        );
-        throw new Error(error.message || error.error || "Request failed", { cause: error });
-      }
-      return response.status === 204 ? null : response.json();
-    } catch (error) {
-      this._trackServiceError(error, {
-        endpoint,
-        methodName: options.methodName
-      });
-      throw new Error(`Request failed: ${error.message}`, { cause: error });
-    }
-  }
-  // Helper method to determine if a method requires initialization
-  _requiresInit(methodName) {
-    const noInitMethods = /* @__PURE__ */ new Set([
-      "register",
-      "login",
-      "googleAuth",
-      "googleAuthCallback",
-      "githubAuth",
-      "requestPasswordReset",
-      "confirmPasswordReset",
-      "confirmRegistration",
-      "verifyEmail",
-      "getPlans",
-      "getPlan",
-      "listPublicProjects",
-      "getPublicProject"
-    ]);
-    return !noInitMethods.has(methodName);
-  }
-  // Cleanup method
-  destroy() {
-    if (this._tokenManager) {
-      this._tokenManager.destroy();
-      this._tokenManager = null;
-    }
-    this._ready = false;
-    this._setReady(false);
-  }
-};
-
-// src/services/IntegrationService.js
-var IntegrationService = class extends BaseService {
-  // ==================== INTEGRATION METHODS ====================
-  /**
-   * Programmatic auth sanity check (API key based).
-   *
-   * Mirrors: GET /integrations/whoami (requireApiKey)
-   *
-   * Assumption: backend reads API key from `x-api-key` header.
-   * You can override via `options.headers`.
-   */
-  async integrationWhoami(apiKey, options = {}) {
-    this._requireReady("integrationWhoami");
-    if (!apiKey) {
-      throw new Error("API key is required");
-    }
-    const headers = {
-      "x-api-key": apiKey,
-      ...options.headers || {}
-    };
-    try {
-      const response = await this._request("/integrations/whoami", {
-        method: "GET",
-        headers,
-        methodName: "integrationWhoami"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to validate integration API key: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * List integrations visible to the user.
-   *
-   * Mirrors: GET /integrations?orgId=&projectId=
-   */
-  async listIntegrations(options = {}) {
-    this._requireReady("listIntegrations");
-    const { orgId, projectId } = options || {};
-    const queryParams = new URLSearchParams();
-    if (orgId != null) {
-      queryParams.append("orgId", String(orgId));
-    }
-    if (projectId != null) {
-      queryParams.append("projectId", String(projectId));
-    }
-    const queryString = queryParams.toString();
-    const url = `/integrations${queryString ? `?${queryString}` : ""}`;
-    try {
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "listIntegrations"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list integrations: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Create an integration.
-   *
-   * Mirrors: POST /integrations
-   */
-  async createIntegration(data = {}) {
-    this._requireReady("createIntegration");
-    if (!data || typeof data !== "object") {
-      throw new Error("Integration payload is required");
-    }
-    if (!data.name) {
-      throw new Error("Integration name is required");
-    }
-    if (!data.ownerType) {
-      throw new Error("ownerType is required");
-    }
-    try {
-      const response = await this._request("/integrations", {
-        method: "POST",
-        body: JSON.stringify(data),
-        methodName: "createIntegration"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create integration: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Update an integration.
-   *
-   * Mirrors: PATCH /integrations/:integrationId
-   */
-  async updateIntegration(integrationId, update = {}) {
-    this._requireReady("updateIntegration");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!update || typeof update !== "object") {
-      throw new Error("Update payload is required");
-    }
-    try {
-      const response = await this._request(`/integrations/${integrationId}`, {
-        method: "PATCH",
-        body: JSON.stringify(update),
-        methodName: "updateIntegration"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update integration: ${error.message}`, { cause: error });
-    }
-  }
-  // ==================== INTEGRATION API KEY METHODS ====================
-  /**
-   * Create a new API key for an integration.
-   *
-   * Mirrors: POST /integrations/:integrationId/api-keys
-   */
-  async createIntegrationApiKey(integrationId, data = {}) {
-    this._requireReady("createIntegrationApiKey");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!data || typeof data !== "object") {
-      throw new Error("API key payload is required");
-    }
-    try {
-      const response = await this._request(`/integrations/${integrationId}/api-keys`, {
-        method: "POST",
-        body: JSON.stringify(data),
-        methodName: "createIntegrationApiKey"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create integration API key: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * List API keys for an integration.
-   *
-   * Mirrors: GET /integrations/:integrationId/api-keys
-   */
-  async listIntegrationApiKeys(integrationId) {
-    this._requireReady("listIntegrationApiKeys");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    try {
-      const response = await this._request(`/integrations/${integrationId}/api-keys`, {
-        method: "GET",
-        methodName: "listIntegrationApiKeys"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list integration API keys: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Revoke an API key for an integration.
-   *
-   * Mirrors: POST /integrations/:integrationId/api-keys/:keyId/revoke
-   */
-  async revokeIntegrationApiKey(integrationId, keyId) {
-    this._requireReady("revokeIntegrationApiKey");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!keyId) {
-      throw new Error("API key ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/integrations/${integrationId}/api-keys/${keyId}/revoke`,
-        {
-          method: "POST",
-          methodName: "revokeIntegrationApiKey"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to revoke integration API key: ${error.message}`, { cause: error });
-    }
-  }
-  // ==================== WEBHOOK METHODS ====================
-  /**
-   * Create a webhook endpoint for an integration.
-   *
-   * Mirrors: POST /integrations/:integrationId/webhooks
-   */
-  async createIntegrationWebhook(integrationId, data = {}) {
-    this._requireReady("createIntegrationWebhook");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!data || typeof data !== "object") {
-      throw new Error("Webhook payload is required");
-    }
-    try {
-      const response = await this._request(`/integrations/${integrationId}/webhooks`, {
-        method: "POST",
-        body: JSON.stringify(data),
-        methodName: "createIntegrationWebhook"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create integration webhook: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * List webhook endpoints for an integration.
-   *
-   * Mirrors: GET /integrations/:integrationId/webhooks
-   */
-  async listIntegrationWebhooks(integrationId) {
-    this._requireReady("listIntegrationWebhooks");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    try {
-      const response = await this._request(`/integrations/${integrationId}/webhooks`, {
-        method: "GET",
-        methodName: "listIntegrationWebhooks"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list integration webhooks: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Update a webhook endpoint for an integration.
-   *
-   * Mirrors: PATCH /integrations/:integrationId/webhooks/:webhookId
-   */
-  async updateIntegrationWebhook(integrationId, webhookId, update = {}) {
-    this._requireReady("updateIntegrationWebhook");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!webhookId) {
-      throw new Error("Webhook ID is required");
-    }
-    if (!update || typeof update !== "object") {
-      throw new Error("Update payload is required");
-    }
-    try {
-      const response = await this._request(
-        `/integrations/${integrationId}/webhooks/${webhookId}`,
-        {
-          method: "PATCH",
-          body: JSON.stringify(update),
-          methodName: "updateIntegrationWebhook"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update integration webhook: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Delete a webhook endpoint for an integration.
-   *
-   * Mirrors: DELETE /integrations/:integrationId/webhooks/:webhookId
-   */
-  async deleteIntegrationWebhook(integrationId, webhookId) {
-    this._requireReady("deleteIntegrationWebhook");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!webhookId) {
-      throw new Error("Webhook ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/integrations/${integrationId}/webhooks/${webhookId}`,
-        {
-          method: "DELETE",
-          methodName: "deleteIntegrationWebhook"
-        }
-      );
-      if (response && response.success) {
-        return response.data;
-      }
-      if (response == null) {
-        return null;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to delete integration webhook: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * List webhook deliveries for an integration webhook.
-   *
-   * Mirrors: GET /integrations/:integrationId/webhooks/:webhookId/deliveries
-   */
-  async listIntegrationWebhookDeliveries(integrationId, webhookId, options = {}) {
-    this._requireReady("listIntegrationWebhookDeliveries");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!webhookId) {
-      throw new Error("Webhook ID is required");
-    }
-    const { page, limit, status, includePayload } = options || {};
-    const queryParams = new URLSearchParams();
-    if (page != null) {
-      queryParams.append("page", String(page));
-    }
-    if (limit != null) {
-      queryParams.append("limit", String(limit));
-    }
-    if (status != null) {
-      queryParams.append("status", String(status));
-    }
-    if (includePayload != null) {
-      queryParams.append("includePayload", String(includePayload));
-    }
-    const queryString = queryParams.toString();
-    const url = `/integrations/${integrationId}/webhooks/${webhookId}/deliveries${queryString ? `?${queryString}` : ""}`;
-    try {
-      const response = await this._request(url, {
-        method: "GET",
-        methodName: "listIntegrationWebhookDeliveries"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list webhook deliveries: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Replay a webhook delivery.
-   *
-   * Mirrors: POST /integrations/:integrationId/webhooks/:webhookId/replay
-   * Body: { deliveryId }
-   */
-  async replayIntegrationWebhookDelivery(integrationId, webhookId, deliveryId) {
-    this._requireReady("replayIntegrationWebhookDelivery");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!webhookId) {
-      throw new Error("Webhook ID is required");
-    }
-    if (!deliveryId) {
-      throw new Error("deliveryId is required");
-    }
-    try {
-      const response = await this._request(
-        `/integrations/${integrationId}/webhooks/${webhookId}/replay`,
-        {
-          method: "POST",
-          body: JSON.stringify({ deliveryId }),
-          methodName: "replayIntegrationWebhookDelivery"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to replay webhook delivery: ${error.message}`, { cause: error });
-    }
-  }
-  // ==================== CONNECTOR METHODS (GITHUB) ====================
-  /**
-   * List GitHub connectors for an integration.
-   *
-   * Mirrors: GET /integrations/:integrationId/connectors/github
-   */
-  async listGitHubConnectors(integrationId) {
-    this._requireReady("listGitHubConnectors");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    try {
-      const response = await this._request(`/integrations/${integrationId}/connectors/github`, {
-        method: "GET",
-        methodName: "listGitHubConnectors"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to list GitHub connectors: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Create a GitHub connector for an integration.
-   *
-   * Mirrors: POST /integrations/:integrationId/connectors/github
-   */
-  async createGitHubConnector(integrationId, data = {}) {
-    this._requireReady("createGitHubConnector");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!data || typeof data !== "object") {
-      throw new Error("Connector payload is required");
-    }
-    if (!data.projectId) {
-      throw new Error("projectId is required");
-    }
-    if (!data.repository) {
-      throw new Error("repository is required");
-    }
-    try {
-      const response = await this._request(`/integrations/${integrationId}/connectors/github`, {
-        method: "POST",
-        body: JSON.stringify(data),
-        methodName: "createGitHubConnector"
-      });
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to create GitHub connector: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Update a GitHub connector.
-   *
-   * Mirrors: PATCH /integrations/:integrationId/connectors/github/:connectorId
-   */
-  async updateGitHubConnector(integrationId, connectorId, update = {}) {
-    this._requireReady("updateGitHubConnector");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!connectorId) {
-      throw new Error("Connector ID is required");
-    }
-    if (!update || typeof update !== "object") {
-      throw new Error("Update payload is required");
-    }
-    try {
-      const response = await this._request(
-        `/integrations/${integrationId}/connectors/github/${connectorId}`,
-        {
-          method: "PATCH",
-          body: JSON.stringify(update),
-          methodName: "updateGitHubConnector"
-        }
-      );
-      if (response.success) {
-        return response.data;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to update GitHub connector: ${error.message}`, { cause: error });
-    }
-  }
-  /**
-   * Delete a GitHub connector.
-   *
-   * Mirrors: DELETE /integrations/:integrationId/connectors/github/:connectorId
-   */
-  async deleteGitHubConnector(integrationId, connectorId) {
-    this._requireReady("deleteGitHubConnector");
-    if (!integrationId) {
-      throw new Error("Integration ID is required");
-    }
-    if (!connectorId) {
-      throw new Error("Connector ID is required");
-    }
-    try {
-      const response = await this._request(
-        `/integrations/${integrationId}/connectors/github/${connectorId}`,
-        {
-          method: "DELETE",
-          methodName: "deleteGitHubConnector"
-        }
-      );
-      if (response && response.success) {
-        return response.data;
-      }
-      if (response == null) {
-        return null;
-      }
-      throw new Error(response.message);
-    } catch (error) {
-      throw new Error(`Failed to delete GitHub connector: ${error.message}`, { cause: error });
-    }
-  }
-};
-export {
-  IntegrationService
-};
-// @preserve-env