@pinta365/strava 0.0.1

package/script/src/resources/routes.js

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Routes resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RoutesResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+const pagination_js_1 = require("../utils/pagination.js");
+/**
+ * Resource for interacting with Strava routes
+ */
+class RoutesResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get route by ID
+     */
+    async getById(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/routes/${id}`,
+        });
+    }
+    /**
+     * List athlete routes
+     */
+    async list(options) {
+        return await this.client.request({
+            method: "GET",
+            path: "/athlete/routes",
+            query: (0, pagination_js_1.buildPaginationQuery)(options),
+        });
+    }
+    /**
+     * Download route as GPX
+     */
+    async downloadAsGPX(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        const response = await fetch(`https://www.strava.com/api/v3/routes/${id}/export_gpx`, {
+            headers: {
+                "Authorization": `Bearer ${await this.getAccessToken()}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download GPX: ${response.statusText}`);
+        }
+        return response.text();
+    }
+    /**
+     * Download route as TCX
+     */
+    async downloadAsTCX(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        const response = await fetch(`https://www.strava.com/api/v3/routes/${id}/export_tcx`, {
+            headers: {
+                "Authorization": `Bearer ${await this.getAccessToken()}`,
+            },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to download TCX: ${response.statusText}`);
+        }
+        return response.text();
+    }
+    async getAccessToken() {
+        return await this.client.getAccessToken();
+    }
+}
+exports.RoutesResource = RoutesResource;

package/script/src/resources/segment-efforts.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Segment efforts resource
+ */
+import type { StravaClient } from "../client.js";
+import type { DetailedSegmentEffort, SummarySegmentEffort } from "../types/api.js";
+/**
+ * Options for listing segment efforts
+ */
+export interface ListSegmentEffortsOptions {
+    /** Filter by segment ID */
+    segmentId?: number;
+    /** Filter by athlete ID */
+    athleteId?: number;
+    /** Start date in ISO 8601 format */
+    startDateLocal?: string;
+    /** End date in ISO 8601 format */
+    endDateLocal?: string;
+    /** Page number (default: 1) */
+    page?: number;
+    /** Number of items per page (default: 30, max: 200) */
+    perPage?: number;
+}
+/**
+ * Resource for interacting with Strava segment efforts
+ */
+export declare class SegmentEffortsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get segment effort by ID
+     */
+    getById(id: number): Promise<DetailedSegmentEffort>;
+    /**
+     * List segment efforts
+     */
+    list(options?: ListSegmentEffortsOptions): Promise<SummarySegmentEffort[]>;
+}
+//# sourceMappingURL=segment-efforts.d.ts.map

package/script/src/resources/segment-efforts.js

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Segment efforts resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentEffortsResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+const pagination_js_1 = require("../utils/pagination.js");
+/**
+ * Resource for interacting with Strava segment efforts
+ */
+class SegmentEffortsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get segment effort by ID
+     */
+    async getById(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/segment_efforts/${id}`,
+        });
+    }
+    /**
+     * List segment efforts
+     */
+    async list(options) {
+        const query = {
+            ...(0, pagination_js_1.buildPaginationQuery)(options),
+        };
+        if (options?.segmentId) {
+            query.segment_id = options.segmentId;
+        }
+        if (options?.athleteId) {
+            query.athlete_id = options.athleteId;
+        }
+        if (options?.startDateLocal) {
+            query.start_date_local = options.startDateLocal;
+        }
+        if (options?.endDateLocal) {
+            query.end_date_local = options.endDateLocal;
+        }
+        return await this.client.request({
+            method: "GET",
+            path: "/segment_efforts",
+            query,
+        });
+    }
+}
+exports.SegmentEffortsResource = SegmentEffortsResource;

package/script/src/resources/segments.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Segments resource
+ */
+import type { StravaClient } from "../client.js";
+import type { DetailedSegment, ExplorerResponse } from "../types/api.js";
+/**
+ * Options for exploring segments
+ */
+export interface ExploreSegmentsOptions {
+    /** Bounding box as [south, west, north, east] */
+    bounds: [number, number, number, number];
+    /** Activity type filter */
+    activityType?: "running" | "riding";
+    /** Minimum category */
+    minCat?: number;
+    /** Maximum category */
+    maxCat?: number;
+}
+/**
+ * Resource for interacting with Strava segments
+ */
+export declare class SegmentsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get segment by ID
+     */
+    getById(id: number): Promise<DetailedSegment>;
+    /**
+     * Explore segments
+     */
+    explore(options: ExploreSegmentsOptions): Promise<ExplorerResponse>;
+    /**
+     * Star segment
+     */
+    star(id: number, starred?: boolean): Promise<DetailedSegment>;
+    /**
+     * Unstar segment
+     */
+    unstar(id: number): Promise<DetailedSegment>;
+}
+//# sourceMappingURL=segments.d.ts.map

package/script/src/resources/segments.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Segments resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SegmentsResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+/**
+ * Resource for interacting with Strava segments
+ */
+class SegmentsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get segment by ID
+     */
+    async getById(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/segments/${id}`,
+        });
+    }
+    /**
+     * Explore segments
+     */
+    async explore(options) {
+        const [south, west, north, east] = options.bounds;
+        const query = {
+            bounds: `${south},${west},${north},${east}`,
+        };
+        if (options.activityType) {
+            query.activity_type = options.activityType;
+        }
+        if (options.minCat !== undefined) {
+            query.min_cat = options.minCat;
+        }
+        if (options.maxCat !== undefined) {
+            query.max_cat = options.maxCat;
+        }
+        return await this.client.request({
+            method: "GET",
+            path: "/segments/explore",
+            query,
+        });
+    }
+    /**
+     * Star segment
+     */
+    async star(id, starred = true) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "PUT",
+            path: `/segments/${id}/starred`,
+            query: { starred: starred ? "true" : "false" },
+        });
+    }
+    /**
+     * Unstar segment
+     */
+    async unstar(id) {
+        return await this.star(id, false);
+    }
+}
+exports.SegmentsResource = SegmentsResource;

package/script/src/resources/streams.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Streams resource
+ */
+import type { StravaClient } from "../client.js";
+import type { StreamSet } from "../types/api.js";
+/**
+ * Available stream types
+ */
+export type StreamType = "time" | "distance" | "latlng" | "altitude" | "velocity_smooth" | "heartrate" | "cadence" | "watts" | "temp" | "moving" | "grade_smooth";
+/**
+ * Options for getting streams
+ */
+export interface GetStreamsOptions {
+    /** Stream types to retrieve */
+    types?: StreamType[];
+    /** Whether to key streams by type */
+    keyByType?: boolean;
+}
+/**
+ * Resource for interacting with Strava streams
+ */
+export declare class StreamsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Get activity streams
+     */
+    getForActivity(id: number, options?: GetStreamsOptions): Promise<StreamSet>;
+    /**
+     * Get segment effort streams
+     */
+    getForSegmentEffort(id: number, options?: GetStreamsOptions): Promise<StreamSet>;
+    /**
+     * Get segment streams
+     */
+    getForSegment(id: number, options?: Omit<GetStreamsOptions, "types"> & {
+        types?: Array<"distance" | "latlng" | "altitude">;
+    }): Promise<StreamSet>;
+    /**
+     * Get route streams
+     */
+    getForRoute(id: number): Promise<StreamSet>;
+}
+//# sourceMappingURL=streams.d.ts.map

package/script/src/resources/streams.js

@@ -0,0 +1,79 @@
+"use strict";
+/**
+ * Streams resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamsResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+/**
+ * Resource for interacting with Strava streams
+ */
+class StreamsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Get activity streams
+     */
+    async getForActivity(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        const types = options?.types || ["time", "distance", "latlng", "altitude", "heartrate"];
+        const query = {
+            keys: types.join(","),
+            key_by_type: options?.keyByType ?? true,
+        };
+        return await this.client.request({
+            method: "GET",
+            path: `/activities/${id}/streams`,
+            query,
+        });
+    }
+    /**
+     * Get segment effort streams
+     */
+    async getForSegmentEffort(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        const types = options?.types || ["time", "distance", "latlng", "altitude", "heartrate"];
+        const query = {
+            keys: types.join(","),
+            key_by_type: options?.keyByType ?? true,
+        };
+        return await this.client.request({
+            method: "GET",
+            path: `/segment_efforts/${id}/streams`,
+            query,
+        });
+    }
+    /**
+     * Get segment streams
+     */
+    async getForSegment(id, options) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        const types = options?.types || ["distance", "latlng", "altitude"];
+        const query = {
+            keys: types.join(","),
+            key_by_type: options?.keyByType ?? true,
+        };
+        return await this.client.request({
+            method: "GET",
+            path: `/segments/${id}/streams`,
+            query,
+        });
+    }
+    /**
+     * Get route streams
+     */
+    async getForRoute(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/routes/${id}/streams`,
+        });
+    }
+}
+exports.StreamsResource = StreamsResource;

package/script/src/resources/uploads.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Uploads resource
+ */
+import type { StravaClient } from "../client.js";
+import type { Upload } from "../types/api.js";
+/**
+ * Options for creating an upload
+ */
+export interface CreateUploadOptions {
+    /** Activity file (FIT, TCX, or GPX format) */
+    file: File | Blob | Uint8Array;
+    /** Activity name */
+    name?: string;
+    /** Activity description */
+    description?: string;
+    /** Whether activity was done on trainer */
+    trainer?: boolean;
+    /** Whether activity is a commute */
+    commute?: boolean;
+    /** File data type */
+    dataType?: "fit" | "fit.gz" | "tcx" | "tcx.gz" | "gpx" | "gpx.gz";
+    /** External ID for the activity */
+    externalId?: string;
+}
+/**
+ * Resource for uploading activities to Strava
+ */
+export declare class UploadsResource {
+    private client;
+    constructor(client: StravaClient);
+    /**
+     * Create upload
+     */
+    create(options: CreateUploadOptions): Promise<Upload>;
+    /**
+     * Get upload by ID
+     */
+    getById(id: number): Promise<Upload>;
+    private getAccessToken;
+}
+//# sourceMappingURL=uploads.d.ts.map

package/script/src/resources/uploads.js

@@ -0,0 +1,83 @@
+"use strict";
+/**
+ * Uploads resource
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UploadsResource = void 0;
+const validators_js_1 = require("../utils/validators.js");
+/**
+ * Resource for uploading activities to Strava
+ */
+class UploadsResource {
+    constructor(client) {
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: client
+        });
+    }
+    /**
+     * Create upload
+     */
+    async create(options) {
+        const formData = new FormData();
+        if (options.file instanceof File) {
+            formData.append("file", options.file);
+        }
+        else if (options.file instanceof Blob) {
+            formData.append("file", options.file, "activity.fit");
+        }
+        else {
+            // Uint8Array
+            const blob = new Blob([options.file], { type: "application/octet-stream" });
+            formData.append("file", blob, "activity.fit");
+        }
+        if (options.name) {
+            formData.append("name", options.name);
+        }
+        if (options.description) {
+            formData.append("description", options.description);
+        }
+        if (options.trainer !== undefined) {
+            formData.append("trainer", options.trainer ? "1" : "0");
+        }
+        if (options.commute !== undefined) {
+            formData.append("commute", options.commute ? "1" : "0");
+        }
+        if (options.dataType) {
+            formData.append("data_type", options.dataType);
+        }
+        if (options.externalId) {
+            formData.append("external_id", options.externalId);
+        }
+        // Use direct fetch for multipart/form-data
+        const token = await this.getAccessToken();
+        const response = await fetch("https://www.strava.com/api/v3/uploads", {
+            method: "POST",
+            headers: {
+                "Authorization": `Bearer ${token}`,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const error = await response.json().catch(() => ({ message: response.statusText }));
+            throw new Error(`Upload failed: ${error.message || response.statusText}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Get upload by ID
+     */
+    async getById(id) {
+        (0, validators_js_1.validatePositiveInteger)(id, "id");
+        return await this.client.request({
+            method: "GET",
+            path: `/uploads/${id}`,
+        });
+    }
+    async getAccessToken() {
+        return await this.client.getAccessToken();
+    }
+}
+exports.UploadsResource = UploadsResource;

package/script/src/types/api.d.ts

@@ -0,0 +1,9 @@
+/**
+ * API types - Re-exports and type aliases for generated types
+ *
+ * This file provides convenient access to all generated types from the Swagger specification.
+ * Types are automatically generated from https://developers.strava.com/swagger/swagger.json
+ */
+export * from "./generated.js";
+export type { ActivityStats, ActivityTotal, ActivityType, ActivityZone, ClubActivity, ClubAnnouncement, ClubAthlete, Comment, DetailedActivity, DetailedActivity as Activity, DetailedAthlete as Athlete, DetailedClub as Club, DetailedGear as Gear, DetailedSegment as Segment, DetailedSegmentEffort as SegmentEffort, ExplorerResponse, ExplorerSegment, Fault, HeartRateZoneRanges, Lap, LatLng, MetaActivity, MetaAthlete, MetaClub, PhotosSummary, PolylineMap, PowerZoneRanges, Route, Split, SportType, StreamSet, StreamType, SummaryActivity, SummaryAthlete, SummaryClub, SummaryGear, SummaryPRSegmentEffort, SummarySegment, SummarySegmentEffort, UpdatableActivity, Upload, Waypoint, ZoneRange, ZoneRanges, Zones, } from "./generated.js";
+//# sourceMappingURL=api.d.ts.map

package/script/src/types/api.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * API types - Re-exports and type aliases for generated types
+ *
+ * This file provides convenient access to all generated types from the Swagger specification.
+ * Types are automatically generated from https://developers.strava.com/swagger/swagger.json
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./generated.js"), exports);

package/script/src/types/common.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Common types and interfaces for the Strava client
+ */
+/**
+ * Retry configuration for failed requests
+ */
+export interface RetryConfig {
+    /** Maximum number of retry attempts (default: 3) */
+    maxAttempts?: number;
+    /** Initial delay in milliseconds (default: 1000) */
+    initialDelay?: number;
+    /** Maximum delay in milliseconds (default: 10000) */
+    maxDelay?: number;
+    /** Exponential backoff factor (default: 2) */
+    backoffFactor?: number;
+    /** HTTP status codes that should trigger retry (default: [429, 500, 502, 503, 504]) */
+    retryableStatusCodes?: number[];
+}
+/**
+ * Rate limit strategy for handling rate limit errors
+ * - "queue": Queue requests and process when rate limit resets
+ * - "throw": Immediately throw error when rate limit is hit
+ * - "wait": Wait until rate limit resets before making request
+ */
+export type RateLimitStrategy = "queue" | "throw" | "wait";
+/**
+ * HTTP request configuration
+ */
+export interface RequestConfig {
+    /** HTTP method */
+    method: string;
+    /** API path (without base URL) */
+    path: string;
+    /** Query parameters */
+    query?: Record<string, string | number | boolean | undefined>;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Request body */
+    body?: unknown;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Pagination options for list endpoints
+ */
+export interface PaginationOptions {
+    /** Page number (default: 1) */
+    page?: number;
+    /** Number of items per page (default: 30, max: 200) */
+    perPage?: number;
+}
+/**
+ * Rate limit information from response headers
+ */
+export interface RateLimitInfo {
+    /** Short-term rate limit (15-minute window) */
+    shortTermLimit?: number;
+    /** Short-term usage count */
+    shortTermUsage?: number;
+    /** Daily rate limit */
+    dailyLimit?: number;
+    /** Daily usage count */
+    dailyUsage?: number;
+}
+//# sourceMappingURL=common.d.ts.map

package/script/src/types/common.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Common types and interfaces for the Strava client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });