@felixgeelhaar/jira-sdk 0.2.0 → 1.0.0

package/dist/transport/index.cjs

@@ -0,0 +1,1016 @@
+'use strict';
+
+// src/logging/noop-logger.ts
+var NoopLogger = class {
+  debug(_message, _fields) {
+  }
+  info(_message, _fields) {
+  }
+  warn(_message, _fields) {
+  }
+  error(_message, _fields) {
+  }
+  child(_fields) {
+    return this;
+  }
+};
+
+// src/utils/runtime.ts
+function runtime() {
+  return globalThis;
+}
+function processEnv() {
+  return runtime().process?.env ?? {};
+}
+function readEnvVar(name) {
+  return processEnv()[name];
+}
+function warn(message) {
+  runtime().console?.warn?.(message);
+}
+function randomId() {
+  const uuid = runtime().crypto?.randomUUID?.();
+  if (uuid !== void 0) {
+    return uuid;
+  }
+  return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 11)}`;
+}
+function captureStackTrace(target, constructor) {
+  const capture = Error.captureStackTrace;
+  capture?.(target, constructor);
+}
+
+// src/errors/base.error.ts
+var JiraSdkError = class extends Error {
+  /** HTTP status code if applicable */
+  statusCode;
+  /** Original cause of the error */
+  cause;
+  /** Additional context/metadata */
+  context;
+  constructor(message, options) {
+    super(message, options?.cause !== void 0 ? { cause: options.cause } : void 0);
+    this.name = this.constructor.name;
+    if (options?.cause !== void 0) {
+      this.cause = options.cause;
+    }
+    if (options?.statusCode !== void 0) {
+      this.statusCode = options.statusCode;
+    }
+    if (options?.context !== void 0) {
+      this.context = options.context;
+    }
+    captureStackTrace(this, this.constructor);
+  }
+  /**
+   * Returns a JSON representation of the error
+   */
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      statusCode: this.statusCode,
+      context: this.context,
+      cause: this.cause?.message,
+      stack: this.stack
+    };
+  }
+};
+
+// src/errors/network.error.ts
+var NetworkError = class extends JiraSdkError {
+  code = "NETWORK_ERROR";
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+  }
+  /**
+   * Check if this error indicates a connection failure
+   */
+  isConnectionError() {
+    const msg = this.message.toLowerCase();
+    return msg.includes("econnrefused") || msg.includes("econnreset") || msg.includes("enotfound") || msg.includes("fetch failed");
+  }
+  /**
+   * Check if this error might be retryable
+   */
+  isRetryable() {
+    const msg = this.message.toLowerCase();
+    return msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("temporary");
+  }
+};
+var TimeoutError = class extends JiraSdkError {
+  code = "TIMEOUT_ERROR";
+  /** The timeout duration in milliseconds */
+  timeoutMs;
+  constructor(message, options) {
+    super(message, { cause: options?.cause });
+    this.timeoutMs = options?.timeoutMs;
+  }
+};
+var AbortError = class extends JiraSdkError {
+  code = "ABORT_ERROR";
+  constructor(message = "Request was aborted", options) {
+    super(message, { cause: options?.cause });
+  }
+};
+
+// src/errors/api.error.ts
+var ApiError = class extends JiraSdkError {
+  code = "JIRA_API_ERROR";
+  /** Parsed error details from Jira response */
+  details;
+  /** Raw response body */
+  responseBody;
+  constructor(message, statusCode, responseBody) {
+    const details = parseErrorBody(responseBody);
+    const finalMessage = details ? buildErrorMessage(message, details) : message;
+    super(finalMessage, { statusCode, context: { responseBody } });
+    this.details = details;
+    this.responseBody = responseBody;
+  }
+  /**
+   * Returns all error messages as a single array
+   */
+  getAllMessages() {
+    const messages = [];
+    if (this.details?.errorMessages) {
+      messages.push(...this.details.errorMessages);
+    }
+    if (this.details?.errors) {
+      for (const [field, msg] of Object.entries(this.details.errors)) {
+        messages.push(`${field}: ${msg}`);
+      }
+    }
+    if (messages.length === 0) {
+      messages.push(this.message);
+    }
+    return messages;
+  }
+};
+var UnauthorizedError = class extends ApiError {
+  code = "JIRA_UNAUTHORIZED";
+  constructor(message = "Authentication required", responseBody) {
+    super(message, 401, responseBody);
+  }
+};
+var ForbiddenError = class extends ApiError {
+  code = "JIRA_FORBIDDEN";
+  constructor(message = "Permission denied", responseBody) {
+    super(message, 403, responseBody);
+  }
+};
+var NotFoundError = class extends ApiError {
+  code = "JIRA_NOT_FOUND";
+  constructor(message = "Resource not found", responseBody) {
+    super(message, 404, responseBody);
+  }
+};
+var RateLimitError = class extends ApiError {
+  code = "JIRA_RATE_LIMITED";
+  /** When to retry (in milliseconds) */
+  retryAfter;
+  constructor(message = "Rate limit exceeded", responseBody, options) {
+    super(message, 429, responseBody);
+    this.retryAfter = options?.retryAfter;
+  }
+};
+var ServerError = class extends ApiError {
+  code = "JIRA_SERVER_ERROR";
+  constructor(message = "Internal server error", responseBody, statusCode = 500) {
+    super(message, statusCode, responseBody);
+  }
+};
+function parseErrorBody(body) {
+  if (!body || typeof body !== "object") {
+    return void 0;
+  }
+  const obj = body;
+  return {
+    errorMessages: Array.isArray(obj["errorMessages"]) ? obj["errorMessages"] : void 0,
+    errors: typeof obj["errors"] === "object" && obj["errors"] !== null ? obj["errors"] : void 0,
+    warningMessages: Array.isArray(obj["warningMessages"]) ? obj["warningMessages"] : void 0
+  };
+}
+function buildErrorMessage(baseMessage, details) {
+  if (details.errorMessages?.length) {
+    return details.errorMessages.join("; ");
+  }
+  if (details.errors && Object.keys(details.errors).length > 0) {
+    const fieldErrors = Object.entries(details.errors).map(([field, msg]) => `${field}: ${msg}`).join("; ");
+    return `${baseMessage}: ${fieldErrors}`;
+  }
+  return baseMessage;
+}
+
+// src/utils/index.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function buildQueryString(params) {
+  const filtered = Object.entries(params).filter(
+    ([, value]) => value !== void 0 && value !== null && value !== ""
+  );
+  if (filtered.length === 0) {
+    return "";
+  }
+  const searchParams = new URLSearchParams();
+  for (const [key, value] of filtered) {
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        searchParams.append(key, String(item));
+      }
+    } else {
+      searchParams.set(key, String(value));
+    }
+  }
+  return searchParams.toString();
+}
+function joinPath(...segments) {
+  return segments.map(String).map((s) => s.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+}
+function exponentialBackoff(attempt, baseDelay, maxDelay, multiplier = 2, jitter = true) {
+  const delay = Math.min(baseDelay * Math.pow(multiplier, attempt), maxDelay);
+  if (jitter) {
+    const jitterAmount = delay * 0.25;
+    return delay + (Math.random() * 2 - 1) * jitterAmount;
+  }
+  return delay;
+}
+
+// src/transport/http-client.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+function validateSecureUrl(url, allowInsecure) {
+  const isHttps = url.startsWith("https://");
+  const isLocalhost = url.includes("localhost") || url.includes("127.0.0.1");
+  const isProduction = readEnvVar("NODE_ENV") === "production";
+  if (!isHttps && !isLocalhost && !allowInsecure) {
+    if (isProduction) {
+      throw new Error(
+        `Security Error: HTTPS is required for production environments. URL "${url}" uses HTTP. Use HTTPS or set allowInsecureHttp: true for testing.`
+      );
+    }
+    warn(
+      `[SDK Warning] Using insecure HTTP connection to "${url}". HTTPS is strongly recommended for production use.`
+    );
+  }
+}
+var HttpClient = class {
+  baseUrl;
+  auth;
+  logger;
+  timeout;
+  defaultHeaders;
+  middleware;
+  fetchFn;
+  middlewareChain;
+  constructor(config) {
+    validateSecureUrl(config.baseUrl, config.allowInsecureHttp);
+    this.baseUrl = config.baseUrl.replace(/\/$/, "");
+    this.auth = config.auth;
+    this.logger = config.logger ?? new NoopLogger();
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT_MS;
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      ...config.defaultHeaders
+    };
+    this.middleware = config.middleware ?? [];
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+    this.middlewareChain = this.buildMiddlewareChain();
+  }
+  /**
+   * Make a GET request
+   */
+  async get(path, params, options) {
+    return this.request({
+      ...options,
+      method: "GET",
+      url: path,
+      // Merge rather than let one clobber the other: callers may pass params
+      // positionally and additionally supply some via options.
+      params: { ...params, ...options?.params }
+    });
+  }
+  /**
+   * Make a POST request
+   */
+  async post(path, body, options) {
+    return this.request({
+      method: "POST",
+      url: path,
+      body,
+      ...options
+    });
+  }
+  /**
+   * Make a PUT request
+   */
+  async put(path, body, options) {
+    return this.request({
+      method: "PUT",
+      url: path,
+      body,
+      ...options
+    });
+  }
+  /**
+   * Make a PATCH request
+   */
+  async patch(path, body, options) {
+    return this.request({
+      method: "PATCH",
+      url: path,
+      body,
+      ...options
+    });
+  }
+  /**
+   * Make a DELETE request
+   */
+  async delete(path, options) {
+    return this.request({
+      method: "DELETE",
+      url: path,
+      ...options
+    });
+  }
+  /**
+   * Make a request with full control over the configuration
+   */
+  async request(requestConfig) {
+    const {
+      method = "GET",
+      url,
+      headers,
+      body,
+      params,
+      timeout,
+      signal,
+      metadata,
+      skipAuth
+    } = requestConfig;
+    const httpRequest = {
+      method,
+      url,
+      headers: { ...this.defaultHeaders, ...headers },
+      body,
+      params,
+      timeout: timeout ?? this.timeout,
+      signal,
+      metadata
+    };
+    const context = {
+      request: httpRequest,
+      auth: skipAuth ? void 0 : this.auth,
+      logger: this.logger,
+      retryCount: 0
+    };
+    const chain = this.middlewareChain ?? this.buildMiddlewareChain();
+    return chain(context);
+  }
+  /**
+   * Build the middleware chain with the final request handler
+   */
+  buildMiddlewareChain() {
+    const finalHandler = async (context) => {
+      return this.executeRequest(context);
+    };
+    return this.middleware.reduceRight((next, middleware) => {
+      return async (ctx) => middleware(ctx, next);
+    }, finalHandler);
+  }
+  /**
+   * Execute the actual HTTP request
+   */
+  async executeRequest(context) {
+    const { request, auth } = context;
+    const startTime = Date.now();
+    let fullUrl = request.url.startsWith("http") ? request.url : joinPath(this.baseUrl, request.url);
+    if (request.params) {
+      const queryString = buildQueryString(request.params);
+      if (queryString) {
+        fullUrl += (fullUrl.includes("?") ? "&" : "?") + queryString;
+      }
+    }
+    const headers = new Headers(request.headers);
+    if (auth) {
+      const authHeaders = await auth.getAuthHeaders();
+      for (const [key, value] of Object.entries(authHeaders)) {
+        headers.set(key, value);
+      }
+    }
+    let bodyContent;
+    if (request.body !== void 0) {
+      if (request.body instanceof FormData || request.body instanceof Blob) {
+        bodyContent = request.body;
+        headers.delete("Content-Type");
+      } else if (typeof request.body === "string") {
+        bodyContent = request.body;
+      } else {
+        bodyContent = JSON.stringify(request.body);
+      }
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+      controller.abort();
+    }, request.timeout ?? this.timeout);
+    const combinedSignal = request.signal ? this.combineSignals(request.signal, controller.signal) : controller.signal;
+    try {
+      const response = await this.fetchFn(fullUrl, {
+        method: request.method,
+        headers,
+        ...bodyContent !== void 0 && { body: bodyContent },
+        signal: combinedSignal
+      });
+      clearTimeout(timeoutId);
+      const responseTime = Date.now() - startTime;
+      const contentType = response.headers.get("content-type");
+      let data;
+      const wantBlob = request.metadata?.["rawResponse"] === true;
+      if (wantBlob) {
+        data = await response.blob();
+      } else if (contentType?.includes("application/json")) {
+        const text = await response.text();
+        data = text ? JSON.parse(text) : null;
+      } else {
+        data = await response.text();
+      }
+      if (!response.ok) {
+        this.handleErrorResponse(response, data);
+      }
+      return {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        data,
+        request,
+        responseTime
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof ApiError) {
+        throw error;
+      }
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          if (request.signal?.aborted) {
+            throw new AbortError("Request was aborted", { cause: error });
+          }
+          throw new TimeoutError(`Request timed out after ${request.timeout ?? this.timeout}ms`, {
+            cause: error
+          });
+        }
+        throw new NetworkError(`Network error: ${error.message}`, {
+          cause: error
+        });
+      }
+      throw new NetworkError("Unknown network error", { cause: error });
+    }
+  }
+  /**
+   * Handle error responses and throw appropriate errors
+   */
+  handleErrorResponse(response, data) {
+    const status = response.status;
+    switch (status) {
+      case 401:
+        throw new UnauthorizedError("Authentication required", data);
+      case 403:
+        throw new ForbiddenError("Access denied", data);
+      case 404:
+        throw new NotFoundError("Resource not found", data);
+      case 429: {
+        const retryAfter = this.parseRetryAfter(response.headers);
+        throw new RateLimitError(
+          "Rate limit exceeded",
+          data,
+          retryAfter !== void 0 ? { retryAfter } : void 0
+        );
+      }
+      default:
+        if (status >= 500) {
+          throw new ServerError(`Server error: ${response.statusText}`, data, status);
+        }
+        throw new ApiError(`API error: ${response.statusText}`, status, data);
+    }
+  }
+  /**
+   * Parse Retry-After header
+   */
+  parseRetryAfter(headers) {
+    const retryAfter = headers.get("retry-after");
+    if (!retryAfter) return void 0;
+    const seconds = parseInt(retryAfter, 10);
+    if (!isNaN(seconds)) {
+      return seconds * 1e3;
+    }
+    const date = Date.parse(retryAfter);
+    if (!isNaN(date)) {
+      return Math.max(0, date - Date.now());
+    }
+    return void 0;
+  }
+  /**
+   * Combine multiple AbortSignals
+   */
+  combineSignals(signal1, signal2) {
+    const controller = new AbortController();
+    const abort = () => {
+      controller.abort();
+    };
+    if (signal1.aborted || signal2.aborted) {
+      controller.abort();
+      return controller.signal;
+    }
+    signal1.addEventListener("abort", abort);
+    signal2.addEventListener("abort", abort);
+    return controller.signal;
+  }
+  /**
+   * Add middleware to the chain
+   * Note: This rebuilds the middleware chain for the new configuration
+   */
+  use(middleware) {
+    this.middleware.push(middleware);
+    this.middlewareChain = this.buildMiddlewareChain();
+    return this;
+  }
+  /**
+   * Get the base URL
+   */
+  getBaseUrl() {
+    return this.baseUrl;
+  }
+  /**
+   * Get the auth provider
+   */
+  getAuth() {
+    return this.auth;
+  }
+};
+function createHttpClient(config) {
+  return new HttpClient(config);
+}
+
+// src/transport/middleware.ts
+function createLoggingMiddleware(config = {}) {
+  const {
+    logRequests = true,
+    logResponses = true,
+    logErrors = true,
+    redactHeaders = ["authorization", "x-api-key"]
+  } = config;
+  const redactHeadersLower = redactHeaders.map((h) => h.toLowerCase());
+  return async (context, next) => {
+    const { request, logger } = context;
+    if (logRequests) {
+      const headers = { ...request.headers };
+      for (const key of Object.keys(headers)) {
+        if (redactHeadersLower.includes(key.toLowerCase())) {
+          headers[key] = "[REDACTED]";
+        }
+      }
+      logger.debug("HTTP Request", {
+        method: request.method,
+        url: request.url,
+        headers,
+        params: request.params
+      });
+    }
+    try {
+      const response = await next(context);
+      if (logResponses) {
+        logger.debug("HTTP Response", {
+          status: response.status,
+          statusText: response.statusText,
+          responseTime: response.responseTime
+        });
+      }
+      return response;
+    } catch (error) {
+      if (logErrors) {
+        logger.error("HTTP Error", {
+          method: request.method,
+          url: request.url,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+      throw error;
+    }
+  };
+}
+function defaultShouldRetry(error) {
+  if (error instanceof RateLimitError) {
+    return true;
+  }
+  if (error instanceof ServerError) {
+    return true;
+  }
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof ApiError) {
+    return false;
+  }
+  return false;
+}
+function createRetryMiddleware(config = {}) {
+  const {
+    maxRetries = 3,
+    initialDelayMs = 1e3,
+    maxDelayMs = 3e4,
+    multiplier = 2,
+    jitter = true,
+    shouldRetry = defaultShouldRetry
+  } = config;
+  return async (context, next) => {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        context.retryCount = attempt;
+        return await next(context);
+      } catch (error) {
+        lastError = error;
+        if (attempt >= maxRetries || !shouldRetry(error, context)) {
+          throw error;
+        }
+        let delayMs;
+        if (error instanceof RateLimitError && error.retryAfter) {
+          delayMs = error.retryAfter;
+        } else {
+          delayMs = exponentialBackoff(attempt, initialDelayMs, maxDelayMs, multiplier, jitter);
+        }
+        context.logger.debug("Retrying request", {
+          attempt: attempt + 1,
+          maxRetries,
+          delayMs,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        await sleep(delayMs);
+      }
+    }
+    throw lastError;
+  };
+}
+function createRateLimitMiddleware(config) {
+  const { maxRequests, windowMs, waitForSlot = true } = config;
+  const timestamps = [];
+  return async (context, next) => {
+    const now = Date.now();
+    const cutoff = now - windowMs;
+    for (let oldest = timestamps[0]; oldest !== void 0 && oldest < cutoff; oldest = timestamps[0]) {
+      timestamps.shift();
+    }
+    if (timestamps.length >= maxRequests) {
+      if (waitForSlot) {
+        const oldestTimestamp = timestamps[0] ?? now;
+        const waitTime = oldestTimestamp + windowMs - now;
+        if (waitTime > 0) {
+          context.logger.debug("Rate limit reached, waiting", { waitTime });
+          await sleep(waitTime);
+        }
+        timestamps.shift();
+      } else {
+        throw new RateLimitError("Client-side rate limit exceeded", void 0, {
+          retryAfter: (timestamps[0] ?? now) + windowMs - now
+        });
+      }
+    }
+    timestamps.push(now);
+    return next(context);
+  };
+}
+function createRequestIdMiddleware(headerName = "X-Request-ID") {
+  return async (context, next) => {
+    const requestId = generateRequestId();
+    context.request.headers = {
+      ...context.request.headers,
+      [headerName]: requestId
+    };
+    context.requestId = requestId;
+    return next(context);
+  };
+}
+function generateRequestId() {
+  return randomId();
+}
+function createUserAgentMiddleware(config) {
+  const { sdkName, sdkVersion, suffix } = config;
+  let userAgent = `${sdkName}/${sdkVersion}`;
+  if (typeof process !== "undefined" && process.version) {
+    userAgent += ` Node.js/${process.version.slice(1)}`;
+  } else if (typeof navigator !== "undefined") {
+    userAgent += " Browser";
+  }
+  if (suffix) {
+    userAgent += ` ${suffix}`;
+  }
+  return async (context, next) => {
+    context.request.headers = {
+      ...context.request.headers,
+      "User-Agent": userAgent
+    };
+    return next(context);
+  };
+}
+function composeMiddleware(...middlewares) {
+  return async (context, next) => {
+    const chain = middlewares.reduceRight((nextFn, middleware) => {
+      return async (ctx) => middleware(ctx, nextFn);
+    }, next);
+    return chain(context);
+  };
+}
+
+// src/transport/circuit-breaker.ts
+var CircuitState = /* @__PURE__ */ ((CircuitState2) => {
+  CircuitState2["CLOSED"] = "CLOSED";
+  CircuitState2["OPEN"] = "OPEN";
+  CircuitState2["HALF_OPEN"] = "HALF_OPEN";
+  return CircuitState2;
+})(CircuitState || {});
+var CircuitBreakerOpenError = class extends Error {
+  code = "CIRCUIT_BREAKER_OPEN";
+  remainingMs;
+  constructor(message, remainingMs) {
+    super(message);
+    this.name = "CircuitBreakerOpenError";
+    this.remainingMs = remainingMs;
+  }
+};
+var CircuitBreaker = class {
+  state = "CLOSED" /* CLOSED */;
+  failures = [];
+  lastFailureTime = 0;
+  successCount = 0;
+  failureThreshold;
+  resetTimeoutMs;
+  failureWindowMs;
+  successThreshold;
+  isFailure;
+  onStateChange;
+  constructor(config = {}) {
+    this.failureThreshold = config.failureThreshold ?? 5;
+    this.resetTimeoutMs = config.resetTimeoutMs ?? 3e4;
+    this.failureWindowMs = config.failureWindowMs ?? 6e4;
+    this.successThreshold = config.successThreshold ?? 1;
+    this.isFailure = config.isFailure ?? defaultIsFailure;
+    this.onStateChange = config.onStateChange;
+  }
+  /**
+   * Get current circuit state
+   */
+  getState() {
+    this.updateState();
+    return this.state;
+  }
+  /**
+   * Check if request is allowed
+   */
+  canExecute() {
+    this.updateState();
+    return this.state !== "OPEN" /* OPEN */;
+  }
+  /**
+   * Record a successful request
+   */
+  recordSuccess() {
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.successCount++;
+      if (this.successCount >= this.successThreshold) {
+        this.transitionTo("CLOSED" /* CLOSED */);
+        this.reset();
+      }
+    } else if (this.state === "CLOSED" /* CLOSED */) {
+      this.cleanupFailures();
+    }
+  }
+  /**
+   * Record a failed request
+   */
+  recordFailure(error) {
+    if (!this.isFailure(error)) {
+      return;
+    }
+    const now = Date.now();
+    this.failures.push(now);
+    this.lastFailureTime = now;
+    this.cleanupFailures();
+    if (this.state === "HALF_OPEN" /* HALF_OPEN */) {
+      this.transitionTo("OPEN" /* OPEN */);
+      this.successCount = 0;
+    } else if (this.state === "CLOSED" /* CLOSED */) {
+      if (this.failures.length >= this.failureThreshold) {
+        this.transitionTo("OPEN" /* OPEN */);
+      }
+    }
+  }
+  /**
+   * Get remaining time until circuit can transition to half-open
+   */
+  getRemainingOpenTime() {
+    if (this.state !== "OPEN" /* OPEN */) {
+      return 0;
+    }
+    const elapsed = Date.now() - this.lastFailureTime;
+    return Math.max(0, this.resetTimeoutMs - elapsed);
+  }
+  /**
+   * Force reset the circuit breaker
+   */
+  reset() {
+    this.failures = [];
+    this.successCount = 0;
+    this.lastFailureTime = 0;
+    if (this.state !== "CLOSED" /* CLOSED */) {
+      this.transitionTo("CLOSED" /* CLOSED */);
+    }
+  }
+  /**
+   * Get circuit breaker statistics
+   */
+  getStats() {
+    this.cleanupFailures();
+    return {
+      state: this.getState(),
+      failureCount: this.failures.length,
+      successCount: this.successCount,
+      remainingOpenTimeMs: this.getRemainingOpenTime()
+    };
+  }
+  updateState() {
+    if (this.state === "OPEN" /* OPEN */) {
+      const elapsed = Date.now() - this.lastFailureTime;
+      if (elapsed >= this.resetTimeoutMs) {
+        this.transitionTo("HALF_OPEN" /* HALF_OPEN */);
+        this.successCount = 0;
+      }
+    }
+  }
+  transitionTo(newState) {
+    if (this.state !== newState) {
+      const oldState = this.state;
+      this.state = newState;
+      this.onStateChange?.(oldState, newState);
+    }
+  }
+  cleanupFailures() {
+    const cutoff = Date.now() - this.failureWindowMs;
+    this.failures = this.failures.filter((t) => t > cutoff);
+  }
+};
+function defaultIsFailure(error) {
+  if (error instanceof NetworkError) {
+    return true;
+  }
+  if (error instanceof ServerError) {
+    return true;
+  }
+  if (error instanceof RateLimitError) {
+    return true;
+  }
+  if (error instanceof ApiError && error.statusCode !== void 0) {
+    return error.statusCode >= 500;
+  }
+  return false;
+}
+function createCircuitBreakerMiddleware(circuitBreaker) {
+  return async (context, next) => {
+    if (!circuitBreaker.canExecute()) {
+      const remainingMs = circuitBreaker.getRemainingOpenTime();
+      context.logger.warn("Circuit breaker open, rejecting request", {
+        remainingMs,
+        url: context.request.url
+      });
+      throw new CircuitBreakerOpenError(
+        `Circuit breaker is open. Retry after ${remainingMs}ms`,
+        remainingMs
+      );
+    }
+    try {
+      const response = await next(context);
+      circuitBreaker.recordSuccess();
+      return response;
+    } catch (error) {
+      circuitBreaker.recordFailure(error);
+      throw error;
+    }
+  };
+}
+function createDefaultCircuitBreaker(config) {
+  return new CircuitBreaker(config);
+}
+
+// src/transport/rate-limit-headers.ts
+function parseBetaRateLimitPolicy(header) {
+  if (header === null || header === void 0 || header === "") {
+    return void 0;
+  }
+  const parts = header.split(";");
+  const rawLimit = parts[0]?.trim();
+  if (rawLimit === void 0 || rawLimit === "") {
+    return void 0;
+  }
+  const limit = Number.parseInt(rawLimit, 10);
+  if (!Number.isFinite(limit)) {
+    return void 0;
+  }
+  let windowSeconds = 0;
+  for (const part of parts.slice(1)) {
+    const [key, value] = part.trim().split("=", 2);
+    if (key === "w" && value !== void 0) {
+      const parsed = Number.parseInt(value, 10);
+      if (Number.isFinite(parsed)) {
+        windowSeconds = parsed;
+      }
+    }
+  }
+  return { limit, windowSeconds };
+}
+function parseBetaRateLimit(header) {
+  if (header === null || header === void 0 || header === "") {
+    return void 0;
+  }
+  for (const part of header.split(";")) {
+    const [key, value] = part.trim().split("=", 2);
+    if (key === "r" && value !== void 0) {
+      const remaining = Number.parseInt(value, 10);
+      if (Number.isFinite(remaining)) {
+        return remaining;
+      }
+    }
+  }
+  return void 0;
+}
+function parseRetryAfterSeconds(header, now = Date.now()) {
+  if (header === null || header === void 0 || header === "") {
+    return void 0;
+  }
+  const seconds = Number.parseInt(header.trim(), 10);
+  if (Number.isFinite(seconds) && String(seconds) === header.trim()) {
+    return Math.max(0, seconds);
+  }
+  const date = Date.parse(header);
+  if (Number.isFinite(date)) {
+    return Math.max(0, Math.ceil((date - now) / 1e3));
+  }
+  return void 0;
+}
+function readRateLimitHeaders(headers) {
+  const snapshot = {};
+  const remaining = headers.get("x-ratelimit-remaining");
+  if (remaining !== null) {
+    const parsed = Number.parseInt(remaining, 10);
+    if (Number.isFinite(parsed)) {
+      snapshot.remainingRequests = parsed;
+    }
+  }
+  const retryAfter = parseRetryAfterSeconds(headers.get("retry-after"));
+  if (retryAfter !== void 0) {
+    snapshot.retryAfterSeconds = retryAfter;
+  }
+  const policy = parseBetaRateLimitPolicy(headers.get("beta-ratelimit-policy"));
+  if (policy !== void 0) {
+    snapshot.policy = policy;
+  }
+  const points = parseBetaRateLimit(headers.get("beta-ratelimit"));
+  if (points !== void 0) {
+    snapshot.remainingPoints = points;
+  }
+  return snapshot;
+}
+function createRateLimitHeaderMiddleware(config) {
+  return async (ctx, next) => {
+    const response = await next(ctx);
+    const snapshot = readRateLimitHeaders(response.headers);
+    if (Object.keys(snapshot).length > 0) {
+      try {
+        config.onRateLimit(snapshot);
+      } catch {
+      }
+    }
+    return response;
+  };
+}
+
+exports.CircuitBreaker = CircuitBreaker;
+exports.CircuitBreakerOpenError = CircuitBreakerOpenError;
+exports.CircuitState = CircuitState;
+exports.HttpClient = HttpClient;
+exports.composeMiddleware = composeMiddleware;
+exports.createCircuitBreakerMiddleware = createCircuitBreakerMiddleware;
+exports.createDefaultCircuitBreaker = createDefaultCircuitBreaker;
+exports.createHttpClient = createHttpClient;
+exports.createLoggingMiddleware = createLoggingMiddleware;
+exports.createRateLimitHeaderMiddleware = createRateLimitHeaderMiddleware;
+exports.createRateLimitMiddleware = createRateLimitMiddleware;
+exports.createRequestIdMiddleware = createRequestIdMiddleware;
+exports.createRetryMiddleware = createRetryMiddleware;
+exports.createUserAgentMiddleware = createUserAgentMiddleware;
+exports.parseBetaRateLimit = parseBetaRateLimit;
+exports.parseBetaRateLimitPolicy = parseBetaRateLimitPolicy;
+exports.parseRetryAfterSeconds = parseRetryAfterSeconds;
+exports.readRateLimitHeaders = readRateLimitHeaders;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map