@symbo.ls/sdk 3.1.2 → 3.2.6

package/dist/esm/services/PullRequestService.js

@@ -0,0 +1,1284 @@
+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/PullRequestService.js
+var PullRequestService = class extends BaseService {
+  // ==================== PULL REQUEST METHODS ====================
+  /**
+   * Create a new pull request
+   */
+  async createPullRequest(projectId, pullRequestData) {
+    this._requireReady("createPullRequest");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!pullRequestData.source || !pullRequestData.target || !pullRequestData.title) {
+      throw new Error("Source branch, target branch, and title are required");
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests`,
+        {
+          method: "POST",
+          body: JSON.stringify(pullRequestData),
+          methodName: "createPullRequest"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to create pull request: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * List pull requests for a project with filtering options
+   */
+  async listPullRequests(projectId, options = {}) {
+    this._requireReady("listPullRequests");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    const { status = "open", source, target, page = 1, limit = 20 } = options;
+    const queryParams = new URLSearchParams({
+      status,
+      page: page.toString(),
+      limit: limit.toString()
+    });
+    if (source) {
+      queryParams.append("source", source);
+    }
+    if (target) {
+      queryParams.append("target", target);
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests?${queryParams.toString()}`,
+        {
+          method: "GET",
+          methodName: "listPullRequests"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to list pull requests: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Get detailed information about a specific pull request
+   */
+  async getPullRequest(projectId, prId) {
+    this._requireReady("getPullRequest");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!prId) {
+      throw new Error("Pull request ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests/${prId}`,
+        {
+          method: "GET",
+          methodName: "getPullRequest"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get pull request: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Submit a review for a pull request
+   */
+  async reviewPullRequest(projectId, prId, reviewData) {
+    this._requireReady("reviewPullRequest");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!prId) {
+      throw new Error("Pull request ID is required");
+    }
+    const validStatuses = ["approved", "requested_changes", "feedback"];
+    if (reviewData.status && !validStatuses.includes(reviewData.status)) {
+      throw new Error(
+        `Invalid review status. Must be one of: ${validStatuses.join(", ")}`
+      );
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests/${prId}/review`,
+        {
+          method: "POST",
+          body: JSON.stringify(reviewData),
+          methodName: "reviewPullRequest"
+        }
+      );
+      if (response.success) {
+        return response;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to review pull request: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Add a comment to an existing review thread
+   */
+  async addPullRequestComment(projectId, prId, commentData) {
+    this._requireReady("addPullRequestComment");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!prId) {
+      throw new Error("Pull request ID is required");
+    }
+    if (!commentData.value) {
+      throw new Error("Comment value is required");
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests/${prId}/comment`,
+        {
+          method: "POST",
+          body: JSON.stringify(commentData),
+          methodName: "addPullRequestComment"
+        }
+      );
+      if (response.success) {
+        return response;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to add pull request comment: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Merge an approved pull request
+   */
+  async mergePullRequest(projectId, prId) {
+    this._requireReady("mergePullRequest");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!prId) {
+      throw new Error("Pull request ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests/${prId}/merge`,
+        {
+          method: "POST",
+          methodName: "mergePullRequest"
+        }
+      );
+      if (response.success) {
+        return response;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      if (error.message.includes("conflicts") || error.message.includes("409")) {
+        throw new Error(`Pull request has merge conflicts: ${error.message}`, { cause: error });
+      }
+      throw new Error(`Failed to merge pull request: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Get the diff/changes for a pull request
+   */
+  async getPullRequestDiff(projectId, prId) {
+    this._requireReady("getPullRequestDiff");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!prId) {
+      throw new Error("Pull request ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests/${prId}/diff`,
+        {
+          method: "GET",
+          methodName: "getPullRequestDiff"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to get pull request diff: ${error.message}`, { cause: error });
+    }
+  }
+  // ==================== PULL REQUEST HELPER METHODS ====================
+  /**
+   * Helper method to create a pull request with validation
+   */
+  async createPullRequestWithValidation(projectId, data) {
+    const { source, target, title, description, changes } = data;
+    if (source === target) {
+      throw new Error("Source and target branches cannot be the same");
+    }
+    if (!title || title.trim().length === 0) {
+      throw new Error("Pull request title cannot be empty");
+    }
+    if (title.length > 200) {
+      throw new Error("Pull request title cannot exceed 200 characters");
+    }
+    const pullRequestData = {
+      source: source.trim(),
+      target: target.trim(),
+      title: title.trim(),
+      ...description && { description: description.trim() },
+      ...changes && { changes }
+    };
+    return await this.createPullRequest(projectId, pullRequestData);
+  }
+  /**
+   * Helper method to approve a pull request
+   */
+  async approvePullRequest(projectId, prId, comment = "") {
+    const reviewData = {
+      status: "approved",
+      ...comment && {
+        threads: [
+          {
+            comment,
+            type: "praise"
+          }
+        ]
+      }
+    };
+    return await this.reviewPullRequest(projectId, prId, reviewData);
+  }
+  /**
+   * Helper method to request changes on a pull request
+   */
+  async requestPullRequestChanges(projectId, prId, threads = []) {
+    if (!threads || threads.length === 0) {
+      throw new Error("Must provide specific feedback when requesting changes");
+    }
+    const reviewData = {
+      status: "requested_changes",
+      threads
+    };
+    return await this.reviewPullRequest(projectId, prId, reviewData);
+  }
+  /**
+   * Helper method to get pull requests by status
+   */
+  async getOpenPullRequests(projectId, options = {}) {
+    return await this.listPullRequests(projectId, {
+      ...options,
+      status: "open"
+    });
+  }
+  async getClosedPullRequests(projectId, options = {}) {
+    return await this.listPullRequests(projectId, {
+      ...options,
+      status: "closed"
+    });
+  }
+  async getMergedPullRequests(projectId, options = {}) {
+    return await this.listPullRequests(projectId, {
+      ...options,
+      status: "merged"
+    });
+  }
+  /**
+   * Helper method to check if a pull request is canMerge
+   */
+  async isPullRequestMergeable(projectId, prId) {
+    var _a;
+    try {
+      const prData = await this.getPullRequest(projectId, prId);
+      return ((_a = prData == null ? void 0 : prData.data) == null ? void 0 : _a.canMerge) || false;
+    } catch (error) {
+      throw new Error(
+        `Failed to check pull request mergeability: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Helper method to get pull request status summary
+   */
+  async getPullRequestStatusSummary(projectId, prId) {
+    var _a, _b, _c;
+    try {
+      const prData = await this.getPullRequest(projectId, prId);
+      const pr = prData == null ? void 0 : prData.data;
+      if (!pr) {
+        throw new Error("Pull request not found");
+      }
+      return {
+        status: pr.status,
+        reviewStatus: pr.reviewStatus,
+        canMerge: pr.canMerge,
+        hasConflicts: !pr.canMerge,
+        reviewCount: ((_a = pr.reviews) == null ? void 0 : _a.length) || 0,
+        approvedReviews: ((_b = pr.reviews) == null ? void 0 : _b.filter((r) => r.status === "approved").length) || 0,
+        changesRequested: ((_c = pr.reviews) == null ? void 0 : _c.filter((r) => r.status === "requested_changes").length) || 0
+      };
+    } catch (error) {
+      throw new Error(
+        `Failed to get pull request status summary: ${error.message}`,
+        { cause: error }
+      );
+    }
+  }
+  /**
+   * Helper method to validate pull request data
+   */
+  validatePullRequestData(data) {
+    const errors = [];
+    if (!data.source || typeof data.source !== "string") {
+      errors.push("Source branch is required and must be a string");
+    }
+    if (!data.target || typeof data.target !== "string") {
+      errors.push("Target branch is required and must be a string");
+    }
+    if (data.source === data.target) {
+      errors.push("Source and target branches cannot be the same");
+    }
+    if (!data.title || typeof data.title !== "string") {
+      errors.push("Title is required and must be a string");
+    } else if (data.title.trim().length === 0) {
+      errors.push("Title cannot be empty");
+    } else if (data.title.length > 200) {
+      errors.push("Title cannot exceed 200 characters");
+    }
+    if (data.description && typeof data.description !== "string") {
+      errors.push("Description must be a string");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Helper method to validate review data
+   */
+  validateReviewData(reviewData) {
+    const errors = [];
+    const validStatuses = ["approved", "requested_changes", "feedback"];
+    if (reviewData.status && !validStatuses.includes(reviewData.status)) {
+      errors.push(`Invalid review status. Must be one of: ${validStatuses.join(", ")}`);
+    }
+    if (reviewData.threads && !Array.isArray(reviewData.threads)) {
+      errors.push("Threads must be an array");
+    }
+    if (reviewData.threads) {
+      reviewData.threads.forEach((thread, index) => {
+        if (!thread.comment || typeof thread.comment !== "string") {
+          errors.push(`Thread ${index + 1}: Comment is required and must be a string`);
+        }
+        if (thread.type && !["praise", "issue", "suggestion"].includes(thread.type)) {
+          errors.push(`Thread ${index + 1}: Invalid thread type`);
+        }
+      });
+    }
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+  /**
+   * Helper method to get pull request statistics
+   */
+  async getPullRequestStats(projectId, options = {}) {
+    try {
+      const { status = "open" } = options;
+      const pullRequests = await this.listPullRequests(projectId, { status });
+      const stats = {
+        total: pullRequests.length,
+        open: 0,
+        closed: 0,
+        merged: 0,
+        withConflicts: 0,
+        readyToMerge: 0
+      };
+      pullRequests.forEach((pr) => {
+        if (pr.status === "open") {
+          stats.open++;
+        }
+        if (pr.status === "closed") {
+          stats.closed++;
+        }
+        if (pr.status === "merged") {
+          stats.merged++;
+        }
+        if (pr.hasConflicts) {
+          stats.withConflicts++;
+        }
+        if (pr.canMerge) {
+          stats.readyToMerge++;
+        }
+      });
+      return stats;
+    } catch (error) {
+      throw new Error(`Failed to get pull request stats: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Helper method to close a pull request
+   */
+  async closePullRequest(projectId, prId) {
+    this._requireReady("closePullRequest");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!prId) {
+      throw new Error("Pull request ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests/${prId}/close`,
+        {
+          method: "POST",
+          methodName: "closePullRequest"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to close pull request: ${error.message}`, { cause: error });
+    }
+  }
+  /**
+   * Helper method to reopen a closed pull request
+   */
+  async reopenPullRequest(projectId, prId) {
+    this._requireReady("reopenPullRequest");
+    if (!projectId) {
+      throw new Error("Project ID is required");
+    }
+    if (!prId) {
+      throw new Error("Pull request ID is required");
+    }
+    try {
+      const response = await this._request(
+        `/projects/${projectId}/pull-requests/${prId}/reopen`,
+        {
+          method: "POST",
+          methodName: "reopenPullRequest"
+        }
+      );
+      if (response.success) {
+        return response.data;
+      }
+      throw new Error(response.message);
+    } catch (error) {
+      throw new Error(`Failed to reopen pull request: ${error.message}`, { cause: error });
+    }
+  }
+};
+export {
+  PullRequestService
+};
+// @preserve-env