@torqlab/strava-api 1.0.0

package/dist/fetch-activities/fetch-activities.d.ts

@@ -0,0 +1,39 @@
+import type { StravaApiConfig, StravaActivity } from '../types';
+/**
+ * Fetches a list of activities from Strava API for the authenticated athlete.
+ *
+ * Main entry point for fetching activities list. Orchestrates the complete flow:
+ * fetches data from Strava API with retry logic, handles rate limiting and token
+ * refresh, and returns the raw Strava API response format.
+ *
+ * This function is typically called to retrieve a list of activities for display
+ * or processing purposes.
+ *
+ * The function implements the following flow:
+ * 1. Fetches from API with automatic retry on retryable errors
+ * 2. Handles rate limiting by waiting before retry
+ * 3. Attempts token refresh on 401 errors (if refresh token available)
+ * 4. Returns raw API response array
+ *
+ * @param {StravaApiConfig} config - Strava API configuration including OAuth tokens.
+ * @returns {Promise<StravaActivityApiResponse[]>} Promise resolving to array of activities in raw Strava API format.
+ * @throws {Error} Throws an error with StravaActivityError structure for various failure scenarios:
+ *   - 'UNAUTHORIZED' (not retryable): Authentication failed (after refresh attempt if applicable)
+ *   - 'FORBIDDEN' (not retryable): Insufficient permissions
+ *   - 'RATE_LIMITED' (retryable): Rate limit exceeded (handled with retry)
+ *   - 'SERVER_ERROR' (retryable): Strava API server error (handled with retry)
+ *   - 'NETWORK_ERROR' (retryable): Network connection failure (handled with retry)
+ *   - 'MALFORMED_RESPONSE' (not retryable): Invalid API response format
+ *
+ * @see {@link https://developers.strava.com/docs/reference/#api-Activities-getLoggedInAthleteActivities | Strava Get Activities API}
+ *
+ * @example
+ * ```typescript
+ * const activities = await fetchActivities({
+ *   accessToken: 'abc123',
+ * });
+ * ```
+ */
+declare const fetchActivities: (config: StravaApiConfig) => Promise<StravaActivity[]>;
+export default fetchActivities;
+//# sourceMappingURL=fetch-activities.d.ts.map

package/dist/fetch-activities/fetch-activities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-activities.d.ts","sourceRoot":"","sources":["../../fetch-activities/fetch-activities.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,QAAA,MAAM,eAAe,GAAU,QAAQ,eAAe,KAAG,OAAO,CAAC,cAAc,EAAE,CAa7E,CAAC;AAEL,eAAe,eAAe,CAAC"}

package/dist/fetch-activities/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './fetch-activities';
+//# sourceMappingURL=index.d.ts.map

package/dist/fetch-activities/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../fetch-activities/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC"}

package/dist/fetch-activity/fetch-activity.d.ts

@@ -0,0 +1,49 @@
+import type { StravaApiConfig, StravaActivity } from '../types';
+/**
+ * Fetches and validates a Strava activity by ID.
+ *
+ * Main entry point for the Activity module. Orchestrates the complete flow:
+ * validates activity ID, fetches data from Strava API with retry logic,
+ * handles rate limiting and token refresh, transforms the response to internal
+ * format, and validates through Activity Guardrails if provided.
+ *
+ * This function is typically called when a Strava webhook notification is
+ * received containing an activity ID, initiating the activity processing pipeline.
+ *
+ * The function implements the following flow:
+ * 1. Validates activity ID format
+ * 2. Fetches from API with automatic retry on retryable errors
+ * 3. Handles rate limiting by waiting before retry
+ * 4. Attempts token refresh on 401 errors (if refresh token available)
+ * 5. Transforms API response to internal format
+ * 6. Validates through Activity Guardrails (if provided)
+ * 7. Returns validated activity
+ *
+ * @param {string} activityId - Activity ID from Strava (typically received via webhook)
+ * @param {ActivityConfig} config - Activity module configuration including OAuth tokens and optional guardrails
+ * @returns {Promise<Activity>} Promise resolving to validated Activity object in internal format
+ * @throws {Error} Throws an error with ActivityError structure for various failure scenarios:
+ *   - 'INVALID_ID' (not retryable): Invalid activity ID format
+ *   - 'NOT_FOUND' (not retryable): Activity doesn't exist
+ *   - 'UNAUTHORIZED' (not retryable): Authentication failed (after refresh attempt if applicable)
+ *   - 'FORBIDDEN' (not retryable): Insufficient permissions
+ *   - 'RATE_LIMITED' (retryable): Rate limit exceeded (handled with retry)
+ *   - 'SERVER_ERROR' (retryable): Strava API server error (handled with retry)
+ *   - 'NETWORK_ERROR' (retryable): Network connection failure (handled with retry)
+ *   - 'VALIDATION_FAILED' (not retryable): Activity Guardrails validation failed
+ *   - 'MALFORMED_RESPONSE' (not retryable): Invalid API response format
+ *
+ * @see {@link https://developers.strava.com/docs/reference/#api-Activities-getActivityById | Strava Get Activity API}
+ * @see {@link https://developers.strava.com/docs/webhooks/ | Strava Webhooks}
+ *
+ * @example
+ * ```typescript
+ * const activity = await fetchActivity('123456789', {
+ *   accessToken: 'abc123',
+ *   guardrails: activityGuardrailsInstance
+ * });
+ * ```
+ */
+declare const fetchActivity: (activityId: string, config: StravaApiConfig) => Promise<StravaActivity | null>;
+export default fetchActivity;
+//# sourceMappingURL=fetch-activity.d.ts.map

package/dist/fetch-activity/fetch-activity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-activity.d.ts","sourceRoot":"","sources":["../../fetch-activity/fetch-activity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAsChE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,QAAA,MAAM,aAAa,GACjB,YAAY,MAAM,EAClB,QAAQ,eAAe,KACtB,OAAO,CAAC,cAAc,GAAG,IAAI,CAa/B,CAAC;AAEF,eAAe,aAAa,CAAC"}

package/dist/fetch-activity/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './fetch-activity';
+//# sourceMappingURL=index.d.ts.map

package/dist/fetch-activity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../fetch-activity/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/get-auth-url/get-auth-url.d.ts

@@ -0,0 +1,30 @@
+import type { StravaAuthConfig } from '../types';
+/**
+ * Creates the Strava OAuth2 authorization URL.
+ *
+ * Creates a URL that users can visit to authorize the application and grant
+ * access to their Strava data. After authorization, Strava redirects to the
+ * configured redirect URI with an authorization code that can be exchanged for tokens.
+ *
+ * @param {StravaAuthConfig} config - OAuth2 configuration including client ID, redirect URI, and optional scope.
+ * @returns {string} Complete authorization URL ready to be opened in a browser.
+ *
+ * @throws {Error} Throws an error if configuration is invalid:
+ *   - 'INVALID_CONFIG': Missing required configuration (`clientId` or `redirectUri`).
+ *
+ * @see {@link https://developers.strava.com/docs/authentication/ | Strava API Authentication}
+ *
+ * @example
+ * ```typescript
+ * const url = getAuthUrl({
+ *   clientId: '12345',
+ *   clientSecret: 'secret',
+ *   redirectUri: 'http://localhost',
+ *   scope: 'activity:read'
+ * });
+ * // Returns: https://www.strava.com/oauth/authorize?client_id=12345&...
+ * ```
+ */
+declare const getAuthUrl: (config: StravaAuthConfig) => string;
+export default getAuthUrl;
+//# sourceMappingURL=get-auth-url.d.ts.map

package/dist/get-auth-url/get-auth-url.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-auth-url.d.ts","sourceRoot":"","sources":["../../get-auth-url/get-auth-url.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAIjD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,QAAA,MAAM,UAAU,GAAI,QAAQ,gBAAgB,KAAG,MAiB9C,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/get-auth-url/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './get-auth-url';
+//# sourceMappingURL=index.d.ts.map

package/dist/get-auth-url/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../get-auth-url/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.cjs

@@ -0,0 +1,473 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// index.ts
+var exports_strava_api = {};
+__export(exports_strava_api, {
+  refreshStravaAuthToken: () => refresh_token_default,
+  getStravaAuthUrl: () => get_auth_url_default,
+  fetchStravaActivity: () => fetch_activity_default,
+  fetchStravaActivities: () => fetch_activities_default,
+  exchangeStravaAuthToken: () => exchange_token_default
+});
+module.exports = __toCommonJS(exports_strava_api);
+
+// constants.ts
+var STRAVA_API_INITIAL_BACKOFF_MS = 1000;
+var STRAVA_API_MAX_BACKOFF_MS = 16000;
+var STRAVA_API_MAX_RETRIES = 3;
+var STRAVA_AUTH_DEFAULT_SCOPE = "activity:read";
+var STRAVA_OAUTH_BASE_URL = "https://www.strava.com/oauth";
+var STRAVA_API_BASE_URL = "https://www.strava.com/api/v3";
+var STRAVA_API_ENDPOINTS = {
+  TOKEN: `${STRAVA_OAUTH_BASE_URL}/token`,
+  AUTH: `${STRAVA_OAUTH_BASE_URL}/authorize`,
+  ACTIVITIES: `${STRAVA_API_BASE_URL}/athlete/activities`,
+  ACTIVITY: `${STRAVA_API_BASE_URL}/activities`
+};
+var STRAVA_API_ERROR_CODES = {
+  UNAUTHORIZED: "UNAUTHORIZED",
+  FORBIDDEN: "FORBIDDEN",
+  RATE_LIMITED: "RATE_LIMITED",
+  SERVER_ERROR: "SERVER_ERROR",
+  MALFORMED_RESPONSE: "MALFORMED_RESPONSE",
+  INVALID_ID: "INVALID_ID",
+  NOT_FOUND: "NOT_FOUND",
+  NETWORK_ERROR: "NETWORK_ERROR",
+  VALIDATION_FAILED: "VALIDATION_FAILED",
+  INVALID_CONFIG: "INVALID_CONFIG",
+  INVALID_CODE: "INVALID_CODE"
+};
+var STRAVA_API_STATUS_CODES = {
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  RATE_LIMITED: 429,
+  SERVER_ERROR: 500
+};
+
+// validators/validate-activity-id/validate-activity-id.ts
+var validateActivityId = (activityId) => {
+  const trimmedActivityId = String(activityId).trim();
+  const numericActivityId = Number(trimmedActivityId);
+  const isValidNumericActivityId = !Number.isNaN(numericActivityId) && Number.isFinite(numericActivityId) && numericActivityId > 0;
+  if (!trimmedActivityId) {
+    const error = {
+      code: "INVALID_ID",
+      message: "Activity ID is required and cannot be empty",
+      retryable: false
+    };
+    throw new Error(JSON.stringify(error));
+  } else if (!isValidNumericActivityId) {
+    const error = {
+      code: "INVALID_ID",
+      message: "Activity ID must be a valid positive number",
+      retryable: false
+    };
+    throw new Error(JSON.stringify(error));
+  }
+};
+var validate_activity_id_default = validateActivityId;
+// client/get-auth-headers/get-auth-headers.ts
+var getAuthHeaders = (config) => {
+  const headers = {
+    Authorization: `Bearer ${config.accessToken}`
+  };
+  return headers;
+};
+var get_auth_headers_default = getAuthHeaders;
+// client/create-error/create-error.ts
+var createError = (code, message, retryable = false, response) => {
+  if (response) {
+    const error = {
+      code,
+      message,
+      retryable
+    };
+    return new Error(JSON.stringify({ ...error, response }));
+  } else {
+    const error = {
+      code,
+      message,
+      retryable
+    };
+    return new Error(JSON.stringify(error));
+  }
+};
+var create_error_default = createError;
+// client/handle-rate-limit/constants.ts
+var DEFAULT_WAIT_MS = 60 * 1000;
+var WINDOW_MS = 15 * 60 * 1000;
+
+// client/handle-rate-limit/handle-rate-limit.ts
+var handleRateLimit = async (response) => {
+  const retryAfterHeader = response.headers.get("Retry-After");
+  const retryAfterSeconds = retryAfterHeader ? Number.parseFloat(retryAfterHeader) : NaN;
+  const shouldWaitAndRetry = !Number.isNaN(retryAfterSeconds) && Number.isFinite(retryAfterSeconds) && retryAfterSeconds > 0;
+  if (shouldWaitAndRetry) {
+    const waitMs = Math.ceil(retryAfterSeconds * 1000);
+    await new Promise((resolve) => {
+      setTimeout(resolve, waitMs);
+    });
+  } else {
+    const rateLimitLimit = response.headers.get("X-RateLimit-Limit");
+    const rateLimitUsage = response.headers.get("X-RateLimit-Usage");
+    const limit = rateLimitLimit ? Number.parseInt(rateLimitLimit, 10) : NaN;
+    const usage = rateLimitUsage ? Number.parseInt(rateLimitUsage, 10) : NaN;
+    const shouldWaitInWindow = !Number.isNaN(limit) && !Number.isNaN(usage) && Number.isFinite(limit) && Number.isFinite(usage) && usage >= limit;
+    if (shouldWaitInWindow) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, WINDOW_MS);
+      });
+    } else {
+      await new Promise((resolve) => {
+        setTimeout(resolve, DEFAULT_WAIT_MS);
+      });
+    }
+  }
+};
+var handle_rate_limit_default = handleRateLimit;
+// client/parse-error/parse-error.ts
+var parseError = (error) => {
+  try {
+    return JSON.parse(error.message);
+  } catch {
+    return null;
+  }
+};
+var parse_error_default = parseError;
+
+// client/parse-error-code/parse-error-code.ts
+var parseErrorCode = (error) => {
+  try {
+    const errorParsed = parse_error_default(error);
+    return errorParsed?.code || null;
+  } catch {
+    return null;
+  }
+};
+var parse_error_code_default = parseErrorCode;
+// refresh-token/refresh-token.ts
+var createError2 = (code, message) => {
+  const error = {
+    retryable: false,
+    code,
+    message
+  };
+  return new Error(JSON.stringify(error));
+};
+var doRefreshToken = async (body) => {
+  try {
+    return await fetch(STRAVA_API_ENDPOINTS.TOKEN, {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+  } catch {
+    throw createError2("NETWORK_ERROR", "Failed to connect to Strava OAuth endpoint");
+  }
+};
+var parseApiResponse = async (response) => {
+  try {
+    return await response.json();
+  } catch {
+    throw createError2("MALFORMED_RESPONSE", "Invalid response format from token refresh endpoint");
+  }
+};
+var refreshToken = async (config) => {
+  if (!config.refreshToken) {
+    throw createError2("UNAUTHORIZED", "Refresh token is not available");
+  } else if (!config.clientId || !config.clientSecret) {
+    throw createError2("UNAUTHORIZED", "Client ID and client secret are required for token refresh");
+  } else {
+    const body = new URLSearchParams({
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      grant_type: "refresh_token",
+      refresh_token: config.refreshToken
+    });
+    const response = await doRefreshToken(body);
+    if (!response.ok) {
+      throw createError2("UNAUTHORIZED", "Token refresh failed");
+    } else {
+      const jsonData = await parseApiResponse(response.clone());
+      if (jsonData.access_token && jsonData.refresh_token) {
+        return {
+          access_token: jsonData.access_token,
+          refresh_token: jsonData.refresh_token
+        };
+      } else {
+        throw createError2("MALFORMED_RESPONSE", "Access token not found in refresh response");
+      }
+    }
+  }
+};
+var refresh_token_default = refreshToken;
+// client/handle-fetch-error/handle-fetch-error.ts
+var handleFetchError = async (fn, config, error) => {
+  const errorCode = parse_error_code_default(error);
+  const isRateLimitedError = errorCode === STRAVA_API_ERROR_CODES.RATE_LIMITED;
+  const isUnauthorizedError = errorCode === STRAVA_API_ERROR_CODES.UNAUTHORIZED;
+  if (isRateLimitedError) {
+    const errorWithResponse = error;
+    const rateLimitedResponse = errorWithResponse.response ?? new Response("Rate Limited", {
+      status: STRAVA_API_STATUS_CODES.RATE_LIMITED,
+      headers: { "Retry-After": "60" }
+    });
+    await handle_rate_limit_default(rateLimitedResponse);
+    throw error;
+  } else if (isUnauthorizedError) {
+    const canRefreshToken = Boolean(config.refreshToken) && Boolean(config.clientId) && Boolean(config.clientSecret);
+    if (canRefreshToken) {
+      try {
+        const { access_token } = await refresh_token_default(config);
+        const refreshedConfig = {
+          ...config,
+          accessToken: access_token
+        };
+        return await fn(refreshedConfig);
+      } catch {
+        throw error;
+      }
+    } else {
+      throw error;
+    }
+  } else {
+    throw error;
+  }
+};
+var handle_fetch_error_default = handleFetchError;
+// client/parse-response/parse-response.ts
+var parseApiResponse2 = async (response) => {
+  try {
+    const data = await response.json();
+    if (!data) {
+      throw create_error_default("MALFORMED_RESPONSE", "Expected non-empty response from Strava API", false);
+    } else {
+      return data;
+    }
+  } catch (error) {
+    const parsedError = parse_error_default(error);
+    if (parsedError) {
+      throw create_error_default("MALFORMED_RESPONSE", "Invalid response format from Strava API", false);
+    } else {
+      throw error;
+    }
+  }
+};
+var parseResponse = async (response) => {
+  const isUnauthorized = response.status === STRAVA_API_STATUS_CODES.UNAUTHORIZED;
+  const isForbidden = response.status === STRAVA_API_STATUS_CODES.FORBIDDEN;
+  const isRateLimited = response.status === STRAVA_API_STATUS_CODES.RATE_LIMITED;
+  const isServerError = response.status >= STRAVA_API_STATUS_CODES.SERVER_ERROR;
+  if (isUnauthorized) {
+    throw create_error_default("UNAUTHORIZED", "Authentication failed. Token may be expired or invalid.", false);
+  } else if (isForbidden) {
+    throw create_error_default("FORBIDDEN", "Insufficient permissions to access Strava API", false);
+  } else if (isRateLimited) {
+    throw create_error_default("RATE_LIMITED", "Rate limit exceeded. Please try again later.", true, response);
+  } else if (isServerError) {
+    throw create_error_default("SERVER_ERROR", "Strava API server error", true);
+  } else if (!response.ok) {
+    throw create_error_default("SERVER_ERROR", `Unexpected API error: ${response.status}`, false);
+  } else {
+    return parseApiResponse2(response);
+  }
+};
+var parse_response_default = parseResponse;
+// client/client.ts
+var doFetch = async (url, config) => {
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: get_auth_headers_default(config)
+    });
+    return parse_response_default(response);
+  } catch {
+    throw create_error_default("NETWORK_ERROR", "Failed to connect to Strava API", true);
+  }
+};
+var client = async (url, config) => {
+  try {
+    return await doFetch(url, config);
+  } catch (error) {
+    return await handle_fetch_error_default((newConfig) => doFetch(url, newConfig), config, error);
+  }
+};
+var client_default = client;
+// client/handle-retry/handle-retry.ts
+var parseError2 = (error) => {
+  try {
+    return JSON.parse(error.message);
+  } catch {
+    return null;
+  }
+};
+var attemptWithBackoff = async (fn, attemptIndex, maxRetries, currentBackoffMs, _previousError) => {
+  try {
+    return await fn();
+  } catch (error) {
+    const currentError = error;
+    const activityError = parseError2(currentError);
+    if (activityError !== null && activityError.retryable === false) {
+      throw currentError;
+    } else {
+      const isLastAttempt = attemptIndex >= maxRetries;
+      if (isLastAttempt) {
+        throw currentError;
+      } else {
+        const delayMs = Math.min(currentBackoffMs, STRAVA_API_MAX_BACKOFF_MS);
+        await new Promise((resolve) => {
+          setTimeout(resolve, delayMs);
+        });
+        const nextBackoffMs = currentBackoffMs * 2;
+        const nextAttemptIndex = attemptIndex + 1;
+        return attemptWithBackoff(fn, nextAttemptIndex, maxRetries, nextBackoffMs, currentError);
+      }
+    }
+  }
+};
+var handleRetry = async ({
+  fn,
+  maxRetries,
+  initialBackoffMs = STRAVA_API_INITIAL_BACKOFF_MS
+}) => attemptWithBackoff(fn, 0, maxRetries, initialBackoffMs, null);
+var handle_retry_default = handleRetry;
+// fetch-activity/fetch-activity.ts
+var fetchActivityWithValidation = async (config, activityId) => {
+  const activity = await client_default(`/activities/${activityId}`, config);
+  if (config.guardrails) {
+    const validationResult = activity ? config.guardrails.validate(activity) : { valid: false, errors: ["Activity is empty"] };
+    if (!validationResult.valid) {
+      const error = create_error_default("VALIDATION_FAILED", validationResult.errors?.join(", ") ?? "Activity validation failed", false);
+      throw new Error(JSON.stringify(error));
+    }
+  }
+  return activity;
+};
+var fetchActivity = async (activityId, config) => {
+  validate_activity_id_default(activityId);
+  return handle_retry_default({
+    maxRetries: STRAVA_API_MAX_RETRIES,
+    initialBackoffMs: STRAVA_API_INITIAL_BACKOFF_MS,
+    fn: async () => fetchActivityWithValidation(config, activityId)
+  });
+};
+var fetch_activity_default = fetchActivity;
+// fetch-activities/fetch-activities.ts
+var fetchActivities = async (config) => handle_retry_default({
+  maxRetries: STRAVA_API_MAX_RETRIES,
+  initialBackoffMs: STRAVA_API_INITIAL_BACKOFF_MS,
+  fn: () => client_default(STRAVA_API_ENDPOINTS.ACTIVITIES, config)
+});
+var fetch_activities_default = fetchActivities;
+// get-auth-url/get-auth-url.ts
+var getAuthUrl = (config) => {
+  if (!config.clientId) {
+    throw create_error_default("INVALID_CONFIG", "Client ID is required");
+  } else if (!config.redirectUri) {
+    throw create_error_default("INVALID_CONFIG", "Redirect URI is required");
+  } else {
+    const scope = config.scope ?? STRAVA_AUTH_DEFAULT_SCOPE;
+    const params = new URLSearchParams({
+      client_id: config.clientId,
+      response_type: "code",
+      redirect_uri: config.redirectUri,
+      scope,
+      approval_prompt: "force"
+    });
+    return `${STRAVA_API_ENDPOINTS.AUTH}?${params.toString()}`;
+  }
+};
+var get_auth_url_default = getAuthUrl;
+// exchange-token/exchange-token.ts
+var fetchTokenResponse = async (body) => {
+  try {
+    return await fetch(STRAVA_API_ENDPOINTS.TOKEN, {
+      method: "POST",
+      body: body.toString(),
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      }
+    });
+  } catch {
+    throw create_error_default("NETWORK_ERROR", "Failed to connect to Strava OAuth endpoint");
+  }
+};
+var parseTokenResponse = async (response) => {
+  try {
+    return await response.json();
+  } catch {
+    throw create_error_default("MALFORMED_RESPONSE", "Invalid response format from token endpoint");
+  }
+};
+var exchangeToken = async (authorizationCode, config) => {
+  if (!config.clientId || !config.clientSecret) {
+    throw create_error_default("INVALID_CONFIG", "Client ID and client secret are required");
+  } else if (!config.redirectUri) {
+    throw create_error_default("INVALID_CONFIG", "Redirect URI is required");
+  } else if (!authorizationCode) {
+    throw create_error_default("INVALID_CODE", "Authorization code is required");
+  } else {
+    const body = new URLSearchParams({
+      client_id: config.clientId,
+      client_secret: config.clientSecret,
+      code: authorizationCode,
+      grant_type: "authorization_code"
+    });
+    const response = await fetchTokenResponse(body);
+    if (response.ok) {
+      const tokenData = await parseTokenResponse(response.clone());
+      if (!tokenData.access_token) {
+        throw create_error_default("MALFORMED_RESPONSE", "Access token not found in response");
+      } else if (!tokenData.refresh_token) {
+        throw create_error_default("MALFORMED_RESPONSE", "Refresh token not found in response");
+      } else {
+        return tokenData;
+      }
+    } else {
+      if (response.status === 401 || response.status === 403) {
+        throw create_error_default("UNAUTHORIZED", "Invalid client credentials or authorization code");
+      } else {
+        throw create_error_default("UNAUTHORIZED", `Token exchange failed with status ${response.status}`);
+      }
+    }
+  }
+};
+var exchange_token_default = exchangeToken;

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { default as fetchStravaActivity } from './fetch-activity';
+export { default as fetchStravaActivities } from './fetch-activities';
+export { default as getStravaAuthUrl } from './get-auth-url';
+export { default as exchangeStravaAuthToken } from './exchange-token';
+export { default as refreshStravaAuthToken } from './refresh-token';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,IAAI,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAClE,OAAO,EAAE,OAAO,IAAI,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAC7D,OAAO,EAAE,OAAO,IAAI,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAE,OAAO,IAAI,sBAAsB,EAAE,MAAM,iBAAiB,CAAC"}