@pinta365/strava 0.0.1

package/script/src/types/generated.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Auto-generated TypeScript types from Strava API Swagger specification
+ * Generated at: 2026-01-03T21:49:32.765Z
+ * Source: https://developers.strava.com/swagger/swagger.json
+ * DO NOT EDIT THIS FILE MANUALLY
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/script/src/utils/pagination.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Pagination helpers for Strava API
+ */
+import type { PaginationOptions } from "../types/common.js";
+/**
+ * Paginated iterator for auto-pagination
+ */
+export declare class PaginatedIterator<T> {
+    private fetchPage;
+    private perPage;
+    private currentPage;
+    private currentItems;
+    private hasMore;
+    constructor(fetchPage: (page: number, perPage: number) => Promise<T[]>, perPage?: number);
+    /**
+     * Get next page
+     */
+    next(): Promise<boolean>;
+    /**
+     * Get current page items
+     */
+    get current(): T[];
+    /**
+     * Check if there are more pages
+     */
+    get hasMorePages(): boolean;
+    /**
+     * Reset iterator
+     */
+    reset(): void;
+}
+/**
+ * Create async iterator for auto-pagination
+ * @param fetchPage - Function to fetch a page of data
+ * @param perPage - Number of items per page (default: 30)
+ * @returns Async generator that yields all items across pages
+ */
+export declare function listAll<T>(fetchPage: (page: number, perPage: number) => Promise<T[]>, perPage?: number): AsyncGenerator<T, void, unknown>;
+/**
+ * Build pagination query parameters
+ * @param options - Pagination options
+ * @returns Query parameters object
+ */
+export declare function buildPaginationQuery(options?: PaginationOptions): Record<string, number>;
+//# sourceMappingURL=pagination.d.ts.map

package/script/src/utils/pagination.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Pagination helpers for Strava API
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaginatedIterator = void 0;
+exports.listAll = listAll;
+exports.buildPaginationQuery = buildPaginationQuery;
+/**
+ * Paginated iterator for auto-pagination
+ */
+class PaginatedIterator {
+    constructor(fetchPage, perPage = 30) {
+        Object.defineProperty(this, "fetchPage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: fetchPage
+        });
+        Object.defineProperty(this, "perPage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: perPage
+        });
+        Object.defineProperty(this, "currentPage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "currentItems", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "hasMore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+    }
+    /**
+     * Get next page
+     */
+    async next() {
+        if (!this.hasMore) {
+            return false;
+        }
+        const items = await this.fetchPage(this.currentPage, this.perPage);
+        this.currentItems = items;
+        this.currentPage++;
+        if (items.length < this.perPage) {
+            this.hasMore = false;
+        }
+        return items.length > 0;
+    }
+    /**
+     * Get current page items
+     */
+    get current() {
+        return this.currentItems;
+    }
+    /**
+     * Check if there are more pages
+     */
+    get hasMorePages() {
+        return this.hasMore;
+    }
+    /**
+     * Reset iterator
+     */
+    reset() {
+        this.currentPage = 1;
+        this.currentItems = [];
+        this.hasMore = true;
+    }
+}
+exports.PaginatedIterator = PaginatedIterator;
+/**
+ * Create async iterator for auto-pagination
+ * @param fetchPage - Function to fetch a page of data
+ * @param perPage - Number of items per page (default: 30)
+ * @returns Async generator that yields all items across pages
+ */
+async function* listAll(fetchPage, perPage = 30) {
+    let page = 1;
+    let hasMore = true;
+    while (hasMore) {
+        const items = await fetchPage(page, perPage);
+        for (const item of items) {
+            yield item;
+        }
+        if (items.length < perPage) {
+            hasMore = false;
+        }
+        else {
+            page++;
+        }
+    }
+}
+/**
+ * Build pagination query parameters
+ * @param options - Pagination options
+ * @returns Query parameters object
+ */
+function buildPaginationQuery(options) {
+    const query = {};
+    if (options?.page !== undefined) {
+        query.page = options.page;
+    }
+    if (options?.perPage !== undefined) {
+        query.per_page = options.perPage;
+    }
+    return query;
+}

package/script/src/utils/transformers.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Response transformers for opinionated data transformations
+ */
+/**
+ * Convert snake_case keys to camelCase
+ * @param data - Data to normalize
+ * @returns Data with camelCase keys
+ */
+export declare function normalizeKeys<T>(data: T): T;
+/**
+ * Transform ISO date strings to Date objects
+ * @param data - Data to transform
+ * @returns Data with Date objects instead of ISO strings
+ */
+export declare function transformDates<T>(data: T): T;
+/**
+ * Flatten nested response structures
+ * @param data - Data to flatten
+ * @returns Flattened data structure
+ */
+export declare function flattenResponses<T>(data: T): T;
+/**
+ * Add computed fields
+ */
+export declare function addComputedFields<T>(data: T): T;
+/**
+ * Apply all transformations in order
+ */
+export declare function applyTransformations<T>(data: T, shouldNormalizeKeys: boolean, shouldTransformDates: boolean, shouldFlattenResponses: boolean, shouldAddComputedFields: boolean): T;
+//# sourceMappingURL=transformers.d.ts.map

package/script/src/utils/transformers.js

@@ -0,0 +1,196 @@
+"use strict";
+/**
+ * Response transformers for opinionated data transformations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeKeys = normalizeKeys;
+exports.transformDates = transformDates;
+exports.flattenResponses = flattenResponses;
+exports.addComputedFields = addComputedFields;
+exports.applyTransformations = applyTransformations;
+/**
+ * Convert snake_case keys to camelCase
+ * @param data - Data to normalize
+ * @returns Data with camelCase keys
+ */
+function normalizeKeys(data) {
+    if (data === null || data === undefined) {
+        return data;
+    }
+    if (data instanceof Date) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map(normalizeKeys);
+    }
+    if (typeof data === "object") {
+        const normalized = {};
+        for (const [key, value] of Object.entries(data)) {
+            const camelKey = key.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+            normalized[camelKey] = normalizeKeys(value);
+        }
+        return normalized;
+    }
+    return data;
+}
+/**
+ * Transform ISO date strings to Date objects
+ * @param data - Data to transform
+ * @returns Data with Date objects instead of ISO strings
+ */
+function transformDates(data) {
+    if (data === null || data === undefined) {
+        return data;
+    }
+    if (data instanceof Date) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map(transformDates);
+    }
+    if (typeof data === "object") {
+        const transformed = {};
+        for (const [key, value] of Object.entries(data)) {
+            const lowerKey = key.toLowerCase();
+            const isDateField = /_(at|date|time)$/i.test(key) ||
+                /[dD]ate/.test(key) ||
+                /[tT]ime/.test(key) ||
+                lowerKey.includes("date") ||
+                lowerKey.includes("time");
+            if (isDateField && typeof value === "string") {
+                const date = new Date(value);
+                if (!isNaN(date.getTime())) {
+                    transformed[key] = date;
+                    continue;
+                }
+            }
+            transformed[key] = transformDates(value);
+        }
+        return transformed;
+    }
+    return data;
+}
+/**
+ * Flatten nested response structures
+ * @param data - Data to flatten
+ * @returns Flattened data structure
+ */
+function flattenResponses(data) {
+    if (data === null || data === undefined) {
+        return data;
+    }
+    if (data instanceof Date) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map(flattenResponses);
+    }
+    if (typeof data === "object") {
+        const flattened = {};
+        for (const [key, value] of Object.entries(data)) {
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                if ("id" in value || "firstname" in value || "name" in value) {
+                    for (const [nestedKey, nestedValue] of Object.entries(value)) {
+                        const flattenedKey = `${key}${nestedKey.charAt(0).toUpperCase() + nestedKey.slice(1)}`;
+                        flattened[flattenedKey] = nestedValue;
+                    }
+                    flattened[key] = value;
+                }
+                else {
+                    flattened[key] = flattenResponses(value);
+                }
+            }
+            else {
+                flattened[key] = flattenResponses(value);
+            }
+        }
+        return flattened;
+    }
+    return data;
+}
+/**
+ * Add computed fields
+ */
+function addComputedFields(data) {
+    if (data === null || data === undefined) {
+        return data;
+    }
+    if (data instanceof Date) {
+        return data;
+    }
+    if (Array.isArray(data)) {
+        return data.map(addComputedFields);
+    }
+    if (typeof data === "object") {
+        const enhanced = { ...data };
+        const dataRecord = data;
+        if ("distance" in dataRecord && ("movingTime" in dataRecord || "elapsedTime" in dataRecord)) {
+            const distance = dataRecord.distance;
+            const movingTime = dataRecord.movingTime || dataRecord.elapsedTime;
+            if (movingTime > 0) {
+                enhanced.averageSpeed = distance / movingTime;
+                enhanced.averageSpeedKmh = (distance / 1000) / (movingTime / 3600);
+                const type = dataRecord.type;
+                const sportType = dataRecord.sportType;
+                if (type === "Run" || sportType === "Run") {
+                    enhanced.pace = formatPace(movingTime / (distance / 1000));
+                }
+            }
+        }
+        if ("movingTime" in dataRecord || "elapsedTime" in dataRecord) {
+            const time = dataRecord.movingTime || dataRecord.elapsedTime;
+            enhanced.duration = {
+                seconds: time,
+                minutes: Math.floor(time / 60),
+                hours: Math.floor(time / 3600),
+                formatted: formatDuration(time),
+            };
+        }
+        for (const [key, value] of Object.entries(enhanced)) {
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                enhanced[key] = addComputedFields(value);
+            }
+        }
+        return enhanced;
+    }
+    return data;
+}
+/**
+ * Format pace (seconds per km to min:sec/km)
+ */
+function formatPace(secondsPerKm) {
+    const minutes = Math.floor(secondsPerKm / 60);
+    const seconds = Math.floor(secondsPerKm % 60);
+    return `${minutes}:${seconds.toString().padStart(2, "0")}/km`;
+}
+/**
+ * Format duration (seconds to human-readable)
+ */
+function formatDuration(seconds) {
+    const hours = Math.floor(seconds / 3600);
+    const minutes = Math.floor((seconds % 3600) / 60);
+    const secs = Math.floor(seconds % 60);
+    if (hours > 0) {
+        return `${hours}:${minutes.toString().padStart(2, "0")}:${secs.toString().padStart(2, "0")}`;
+    }
+    return `${minutes}:${secs.toString().padStart(2, "0")}`;
+}
+/**
+ * Apply all transformations in order
+ */
+function applyTransformations(data, shouldNormalizeKeys, shouldTransformDates, shouldFlattenResponses, shouldAddComputedFields) {
+    let result = data;
+    if (shouldNormalizeKeys) {
+        result = normalizeKeys(result);
+    }
+    if (shouldTransformDates) {
+        result = transformDates(result);
+    }
+    if (shouldFlattenResponses) {
+        result = flattenResponses(result);
+    }
+    if (shouldAddComputedFields) {
+        result = addComputedFields(result);
+    }
+    return result;
+}

package/script/src/utils/validators.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Input validation helpers
+ */
+/**
+ * Validate that a value is a positive integer
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated positive integer
+ * @throws Error if value is not a positive integer
+ */
+export declare function validatePositiveInteger(value: unknown, name: string): number;
+/**
+ * Validate that a value is a non-negative integer
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated non-negative integer
+ * @throws Error if value is not a non-negative integer
+ */
+export declare function validateNonNegativeInteger(value: unknown, name: string): number;
+/**
+ * Validate that a value is within a range
+ * @param value - Value to validate
+ * @param min - Minimum allowed value
+ * @param max - Maximum allowed value
+ * @param name - Name of the parameter for error messages
+ * @returns Validated value
+ * @throws Error if value is outside the range
+ */
+export declare function validateRange(value: number, min: number, max: number, name: string): number;
+/**
+ * Validate that a value is a valid date
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated Date object
+ * @throws Error if value is not a valid Date
+ */
+export declare function validateDate(value: unknown, name: string): Date;
+/**
+ * Validate that a value is a non-empty string
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated non-empty string
+ * @throws Error if value is not a non-empty string
+ */
+export declare function validateNonEmptyString(value: unknown, name: string): string;
+/**
+ * Validate pagination options
+ * @param page - Page number (optional)
+ * @param perPage - Items per page (optional, must be 1-200)
+ * @throws Error if pagination options are invalid
+ */
+export declare function validatePagination(page?: number, perPage?: number): void;
+//# sourceMappingURL=validators.d.ts.map

package/script/src/utils/validators.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Input validation helpers
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePositiveInteger = validatePositiveInteger;
+exports.validateNonNegativeInteger = validateNonNegativeInteger;
+exports.validateRange = validateRange;
+exports.validateDate = validateDate;
+exports.validateNonEmptyString = validateNonEmptyString;
+exports.validatePagination = validatePagination;
+/**
+ * Validate that a value is a positive integer
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated positive integer
+ * @throws Error if value is not a positive integer
+ */
+function validatePositiveInteger(value, name) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw new Error(`${name} must be a positive integer, got: ${value}`);
+    }
+    return value;
+}
+/**
+ * Validate that a value is a non-negative integer
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated non-negative integer
+ * @throws Error if value is not a non-negative integer
+ */
+function validateNonNegativeInteger(value, name) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+        throw new Error(`${name} must be a non-negative integer, got: ${value}`);
+    }
+    return value;
+}
+/**
+ * Validate that a value is within a range
+ * @param value - Value to validate
+ * @param min - Minimum allowed value
+ * @param max - Maximum allowed value
+ * @param name - Name of the parameter for error messages
+ * @returns Validated value
+ * @throws Error if value is outside the range
+ */
+function validateRange(value, min, max, name) {
+    if (value < min || value > max) {
+        throw new Error(`${name} must be between ${min} and ${max}, got: ${value}`);
+    }
+    return value;
+}
+/**
+ * Validate that a value is a valid date
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated Date object
+ * @throws Error if value is not a valid Date
+ */
+function validateDate(value, name) {
+    if (!(value instanceof Date) || isNaN(value.getTime())) {
+        throw new Error(`${name} must be a valid Date object`);
+    }
+    return value;
+}
+/**
+ * Validate that a value is a non-empty string
+ * @param value - Value to validate
+ * @param name - Name of the parameter for error messages
+ * @returns Validated non-empty string
+ * @throws Error if value is not a non-empty string
+ */
+function validateNonEmptyString(value, name) {
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${name} must be a non-empty string`);
+    }
+    return value;
+}
+/**
+ * Validate pagination options
+ * @param page - Page number (optional)
+ * @param perPage - Items per page (optional, must be 1-200)
+ * @throws Error if pagination options are invalid
+ */
+function validatePagination(page, perPage) {
+    if (page !== undefined) {
+        validatePositiveInteger(page, "page");
+    }
+    if (perPage !== undefined) {
+        validateRange(perPage, 1, 200, "perPage");
+    }
+}