@pinta365/strava 0.0.1

package/script/src/auth/token-store.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * Token storage interface and implementations
+ */
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemTokenStore = exports.LocalStorageTokenStore = exports.MemoryTokenStore = void 0;
+exports.getDefaultTokenStore = getDefaultTokenStore;
+const mod_js_1 = require("../../deps/jsr.io/@cross/runtime/1.2.1/mod.js");
+/**
+ * In-memory token store (default)
+ */
+class MemoryTokenStore {
+    constructor() {
+        Object.defineProperty(this, "token", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+    }
+    get() {
+        return Promise.resolve(this.token);
+    }
+    set(token) {
+        this.token = token;
+        return Promise.resolve();
+    }
+    clear() {
+        this.token = null;
+        return Promise.resolve();
+    }
+}
+exports.MemoryTokenStore = MemoryTokenStore;
+/**
+ * Browser localStorage token store
+ */
+class LocalStorageTokenStore {
+    constructor(key = "strava_tokens") {
+        Object.defineProperty(this, "key", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.key = key;
+    }
+    get() {
+        if (mod_js_1.CurrentRuntime !== mod_js_1.Runtime.Browser) {
+            throw new Error("LocalStorageTokenStore can only be used in browser environment");
+        }
+        try {
+            const stored = localStorage.getItem(this.key);
+            if (!stored)
+                return Promise.resolve(null);
+            return Promise.resolve(JSON.parse(stored));
+        }
+        catch {
+            return Promise.resolve(null);
+        }
+    }
+    set(token) {
+        if (mod_js_1.CurrentRuntime !== mod_js_1.Runtime.Browser) {
+            throw new Error("LocalStorageTokenStore can only be used in browser environment");
+        }
+        localStorage.setItem(this.key, JSON.stringify(token));
+        return Promise.resolve();
+    }
+    clear() {
+        if (mod_js_1.CurrentRuntime !== mod_js_1.Runtime.Browser) {
+            throw new Error("LocalStorageTokenStore can only be used in browser environment");
+        }
+        localStorage.removeItem(this.key);
+        return Promise.resolve();
+    }
+}
+exports.LocalStorageTokenStore = LocalStorageTokenStore;
+/**
+ * File system token store (Node.js/Deno)
+ */
+class FileSystemTokenStore {
+    constructor(path = "./.strava-tokens.json") {
+        Object.defineProperty(this, "path", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.path = path;
+    }
+    async get() {
+        try {
+            let content;
+            if (mod_js_1.CurrentRuntime === mod_js_1.Runtime.Node || mod_js_1.CurrentRuntime === mod_js_1.Runtime.Bun) {
+                const { readFile } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+                content = await readFile(this.path, "utf-8");
+            }
+            else {
+                // Deno
+                content = await Deno.readTextFile(this.path);
+            }
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    async set(token) {
+        const content = JSON.stringify(token, null, 2);
+        if (mod_js_1.CurrentRuntime === mod_js_1.Runtime.Node || mod_js_1.CurrentRuntime === mod_js_1.Runtime.Bun) {
+            const { writeFile } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+            await writeFile(this.path, content, "utf-8");
+        }
+        else {
+            // Deno
+            await Deno.writeTextFile(this.path, content);
+        }
+    }
+    async clear() {
+        try {
+            if (mod_js_1.CurrentRuntime === mod_js_1.Runtime.Node || mod_js_1.CurrentRuntime === mod_js_1.Runtime.Bun) {
+                const { unlink } = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
+                await unlink(this.path);
+            }
+            else {
+                // Deno
+                await Deno.remove(this.path);
+            }
+        }
+        catch {
+            // File doesn't exist, ignore
+        }
+    }
+}
+exports.FileSystemTokenStore = FileSystemTokenStore;
+/**
+ * Get default token store based on runtime environment
+ * @returns TokenStore appropriate for the current runtime (browser, Node.js, Deno, Bun)
+ */
+function getDefaultTokenStore() {
+    if (mod_js_1.CurrentRuntime === mod_js_1.Runtime.Browser) {
+        return new LocalStorageTokenStore();
+    }
+    else if (mod_js_1.CurrentRuntime === mod_js_1.Runtime.Node || mod_js_1.CurrentRuntime === mod_js_1.Runtime.Deno || mod_js_1.CurrentRuntime === mod_js_1.Runtime.Bun) {
+        return new FileSystemTokenStore();
+    }
+    else {
+        return new MemoryTokenStore();
+    }
+}

package/script/src/client.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Main Strava API client
+ */
+import { type TokenStore } from "./auth/token-store.js";
+import type { RateLimitStrategy, RequestConfig, RetryConfig } from "./types/common.js";
+/**
+ * Client configuration options
+ */
+export interface ClientOptions {
+    clientId: string;
+    clientSecret: string;
+    redirectUri?: string;
+    tokenStore?: TokenStore;
+    baseUrl?: string;
+    timeout?: number;
+    retries?: RetryConfig;
+    rateLimitStrategy?: RateLimitStrategy;
+    deduplicationWindow?: number;
+    normalizeKeys?: boolean;
+    transformDates?: boolean;
+    flattenResponses?: boolean;
+    addComputedFields?: boolean;
+}
+/**
+ * Authentication credentials
+ */
+export interface AuthCredentials {
+    code: string;
+    redirectUri?: string;
+}
+/**
+ * Main Strava API client class
+ */
+export declare class StravaClient {
+    private readonly options;
+    private readonly oauthManager;
+    private readonly rateLimiter;
+    private readonly deduplicator;
+    private _athletes?;
+    private _activities?;
+    private _segments?;
+    private _segmentEfforts?;
+    private _clubs?;
+    private _gears?;
+    private _routes?;
+    private _uploads?;
+    private _streams?;
+    constructor(options: ClientOptions);
+    /**
+     * Authenticate with authorization code
+     */
+    authenticate(credentials: AuthCredentials): Promise<void>;
+    /**
+     * Refresh access token
+     */
+    refreshToken(): Promise<void>;
+    /**
+     * Get authorization URL
+     */
+    getAuthorizationUrl(options: {
+        redirectUri?: string;
+        scope: string[];
+        state?: string;
+        approvalPrompt?: "force" | "auto";
+    }): string;
+    /**
+     * Get current access token (for direct fetch calls)
+     */
+    getAccessToken(): Promise<string>;
+    /**
+     * Low-level request method
+     */
+    request<T>(config: RequestConfig): Promise<T>;
+    get athletes(): AthletesResource;
+    get activities(): ActivitiesResource;
+    get segments(): SegmentsResource;
+    get segmentEfforts(): SegmentEffortsResource;
+    get clubs(): ClubsResource;
+    get gears(): GearsResource;
+    get routes(): RoutesResource;
+    get uploads(): UploadsResource;
+    get streams(): StreamsResource;
+    /**
+     * Clean up resources (stop timers, clear caches)
+     * Call this when you're done with the client to allow the process to exit
+     */
+    destroy(): void;
+}
+import { AthletesResource } from "./resources/athletes.js";
+import { ActivitiesResource } from "./resources/activities.js";
+import { SegmentsResource } from "./resources/segments.js";
+import { SegmentEffortsResource } from "./resources/segment-efforts.js";
+import { ClubsResource } from "./resources/clubs.js";
+import { GearsResource } from "./resources/gears.js";
+import { RoutesResource } from "./resources/routes.js";
+import { UploadsResource } from "./resources/uploads.js";
+import { StreamsResource } from "./resources/streams.js";
+//# sourceMappingURL=client.d.ts.map

package/script/src/client.js

@@ -0,0 +1,239 @@
+"use strict";
+/**
+ * Main Strava API client
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StravaClient = void 0;
+const request_js_1 = require("./http/request.js");
+const rate_limiter_js_1 = require("./http/rate-limiter.js");
+const deduplication_js_1 = require("./http/deduplication.js");
+const oauth_js_1 = require("./auth/oauth.js");
+const token_store_js_1 = require("./auth/token-store.js");
+/**
+ * Main Strava API client class
+ */
+class StravaClient {
+    constructor(options) {
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "oauthManager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "rateLimiter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "deduplicator", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_athletes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_activities", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_segments", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_segmentEfforts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_clubs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_gears", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_routes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_uploads", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_streams", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.options = {
+            baseUrl: options.baseUrl || "https://www.strava.com/api/v3",
+            timeout: options.timeout || 30000,
+            retries: options.retries || {},
+            rateLimitStrategy: options.rateLimitStrategy || "queue",
+            deduplicationWindow: options.deduplicationWindow || 5000,
+            normalizeKeys: options.normalizeKeys ?? true,
+            transformDates: options.transformDates ?? true,
+            flattenResponses: options.flattenResponses ?? true,
+            addComputedFields: options.addComputedFields ?? true,
+            tokenStore: options.tokenStore || (0, token_store_js_1.getDefaultTokenStore)(),
+            redirectUri: options.redirectUri,
+            clientId: options.clientId,
+            clientSecret: options.clientSecret,
+        };
+        this.oauthManager = new oauth_js_1.OAuthManager(this.options.clientId, this.options.clientSecret, this.options.tokenStore);
+        this.rateLimiter = new rate_limiter_js_1.RateLimiter(this.options.rateLimitStrategy);
+        this.deduplicator = new deduplication_js_1.RequestDeduplicator(this.options.deduplicationWindow);
+    }
+    /**
+     * Authenticate with authorization code
+     */
+    async authenticate(credentials) {
+        await this.oauthManager.authenticate(credentials.code, credentials.redirectUri || this.options.redirectUri);
+    }
+    /**
+     * Refresh access token
+     */
+    async refreshToken() {
+        await this.oauthManager.refreshToken();
+    }
+    /**
+     * Get authorization URL
+     */
+    getAuthorizationUrl(options) {
+        return this.oauthManager.getAuthorizationUrl({
+            redirectUri: options.redirectUri || this.options.redirectUri || "",
+            scope: options.scope,
+            state: options.state,
+            approvalPrompt: options.approvalPrompt,
+        });
+    }
+    /**
+     * Get current access token (for direct fetch calls)
+     */
+    async getAccessToken() {
+        const token = await this.oauthManager.getToken();
+        if (!token) {
+            throw new Error("Not authenticated. Call authenticate() first.");
+        }
+        return token.accessToken;
+    }
+    /**
+     * Low-level request method
+     */
+    async request(config) {
+        const token = await this.oauthManager.getToken();
+        if (!token) {
+            throw new Error("Not authenticated. Call authenticate() first.");
+        }
+        return (0, request_js_1.request)(config, {
+            baseUrl: this.options.baseUrl,
+            timeout: this.options.timeout,
+            accessToken: token.accessToken,
+            rateLimiter: this.rateLimiter,
+            deduplicator: this.deduplicator,
+            retryConfig: this.options.retries,
+            normalizeKeys: this.options.normalizeKeys,
+            transformDates: this.options.transformDates,
+            flattenResponses: this.options.flattenResponses,
+            addComputedFields: this.options.addComputedFields,
+        });
+    }
+    get athletes() {
+        if (!this._athletes) {
+            this._athletes = new athletes_js_1.AthletesResource(this);
+        }
+        return this._athletes;
+    }
+    get activities() {
+        if (!this._activities) {
+            this._activities = new activities_js_1.ActivitiesResource(this);
+        }
+        return this._activities;
+    }
+    get segments() {
+        if (!this._segments) {
+            this._segments = new segments_js_1.SegmentsResource(this);
+        }
+        return this._segments;
+    }
+    get segmentEfforts() {
+        if (!this._segmentEfforts) {
+            this._segmentEfforts = new segment_efforts_js_1.SegmentEffortsResource(this);
+        }
+        return this._segmentEfforts;
+    }
+    get clubs() {
+        if (!this._clubs) {
+            this._clubs = new clubs_js_1.ClubsResource(this);
+        }
+        return this._clubs;
+    }
+    get gears() {
+        if (!this._gears) {
+            this._gears = new gears_js_1.GearsResource(this);
+        }
+        return this._gears;
+    }
+    get routes() {
+        if (!this._routes) {
+            this._routes = new routes_js_1.RoutesResource(this);
+        }
+        return this._routes;
+    }
+    get uploads() {
+        if (!this._uploads) {
+            this._uploads = new uploads_js_1.UploadsResource(this);
+        }
+        return this._uploads;
+    }
+    get streams() {
+        if (!this._streams) {
+            this._streams = new streams_js_1.StreamsResource(this);
+        }
+        return this._streams;
+    }
+    /**
+     * Clean up resources (stop timers, clear caches)
+     * Call this when you're done with the client to allow the process to exit
+     */
+    destroy() {
+        this.deduplicator.destroy();
+    }
+}
+exports.StravaClient = StravaClient;
+const athletes_js_1 = require("./resources/athletes.js");
+const activities_js_1 = require("./resources/activities.js");
+const segments_js_1 = require("./resources/segments.js");
+const segment_efforts_js_1 = require("./resources/segment-efforts.js");
+const clubs_js_1 = require("./resources/clubs.js");
+const gears_js_1 = require("./resources/gears.js");
+const routes_js_1 = require("./resources/routes.js");
+const uploads_js_1 = require("./resources/uploads.js");
+const streams_js_1 = require("./resources/streams.js");

package/script/src/errors.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Custom error classes for Strava API interactions
+ */
+/**
+ * Base error class for all Strava API errors
+ */
+export declare class StravaError extends Error {
+    statusCode?: number;
+    response?: unknown;
+    constructor(message: string, statusCode?: number, response?: unknown);
+}
+/**
+ * Authentication-related errors (401, invalid credentials, token expired)
+ */
+export declare class StravaAuthError extends StravaError {
+    constructor(message: string, statusCode?: number, response?: unknown);
+}
+/**
+ * Rate limit errors (429)
+ */
+export declare class StravaRateLimitError extends StravaError {
+    retryAfter?: number;
+    limit?: number;
+    usage?: number;
+    constructor(message: string, statusCode?: number, response?: unknown, retryAfter?: number, limit?: number, usage?: number);
+}
+/**
+ * Resource not found errors (404)
+ */
+export declare class StravaNotFoundError extends StravaError {
+    constructor(message: string, statusCode?: number, response?: unknown);
+}
+/**
+ * Validation errors (422)
+ */
+export declare class StravaValidationError extends StravaError {
+    errors?: Array<{
+        field: string;
+        message: string;
+    }>;
+    constructor(message: string, statusCode?: number, response?: unknown, errors?: Array<{
+        field: string;
+        message: string;
+    }>);
+}
+/**
+ * Server errors (5xx)
+ */
+export declare class StravaServerError extends StravaError {
+    constructor(message: string, statusCode?: number, response?: unknown);
+}
+//# sourceMappingURL=errors.d.ts.map

package/script/src/errors.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Custom error classes for Strava API interactions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StravaServerError = exports.StravaValidationError = exports.StravaNotFoundError = exports.StravaRateLimitError = exports.StravaAuthError = exports.StravaError = void 0;
+/**
+ * Base error class for all Strava API errors
+ */
+class StravaError extends Error {
+    constructor(message, statusCode, response) {
+        super(message);
+        Object.defineProperty(this, "statusCode", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "StravaError";
+        this.statusCode = statusCode;
+        this.response = response;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, StravaError);
+        }
+    }
+}
+exports.StravaError = StravaError;
+/**
+ * Authentication-related errors (401, invalid credentials, token expired)
+ */
+class StravaAuthError extends StravaError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = "StravaAuthError";
+    }
+}
+exports.StravaAuthError = StravaAuthError;
+/**
+ * Rate limit errors (429)
+ */
+class StravaRateLimitError extends StravaError {
+    constructor(message, statusCode, response, retryAfter, limit, usage) {
+        super(message, statusCode, response);
+        Object.defineProperty(this, "retryAfter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "limit", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "usage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "StravaRateLimitError";
+        this.retryAfter = retryAfter;
+        this.limit = limit;
+        this.usage = usage;
+    }
+}
+exports.StravaRateLimitError = StravaRateLimitError;
+/**
+ * Resource not found errors (404)
+ */
+class StravaNotFoundError extends StravaError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = "StravaNotFoundError";
+    }
+}
+exports.StravaNotFoundError = StravaNotFoundError;
+/**
+ * Validation errors (422)
+ */
+class StravaValidationError extends StravaError {
+    constructor(message, statusCode, response, errors) {
+        super(message, statusCode, response);
+        Object.defineProperty(this, "errors", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.name = "StravaValidationError";
+        this.errors = errors;
+    }
+}
+exports.StravaValidationError = StravaValidationError;
+/**
+ * Server errors (5xx)
+ */
+class StravaServerError extends StravaError {
+    constructor(message, statusCode, response) {
+        super(message, statusCode, response);
+        this.name = "StravaServerError";
+    }
+}
+exports.StravaServerError = StravaServerError;