@dlwiest/ts-tonal-client 0.1.0 → 0.2.0

package/README.md

@@ -1,5 +1,8 @@
 # TypeScript Tonal Client
 
+[![npm version](https://badge.fury.io/js/@dlwiest%2Fts-tonal-client.svg)](https://badge.fury.io/js/@dlwiest%2Fts-tonal-client)
+[![npm downloads](https://img.shields.io/npm/dm/@dlwiest/ts-tonal-client.svg)](https://www.npmjs.com/package/@dlwiest/ts-tonal-client)
+
 A comprehensive TypeScript client for accessing Tonal's API. This library provides a robust interface to retrieve workout data, user information, movements, and more from your Tonal account.
 
 ## Features
@@ -17,12 +20,19 @@ A comprehensive TypeScript client for accessing Tonal's API. This library provid
 
 ## Installation
 
-Clone the repository and install dependencies:
+### Option 1: Install from npm (Recommended)
+
+```bash
+npm install @dlwiest/ts-tonal-client
+```
+
+### Option 2: Clone and build from source
 
 ```bash
 git clone https://github.com/dlwiest/ts-tonal-client.git
 cd ts-tonal-client
 npm install
+npm run build
 ```
 
 ## Quick Start
@@ -30,7 +40,7 @@ npm install
 Basic usage:
 
 ```typescript
-import TonalClient from './src/index'
+import TonalClient from '@dlwiest/ts-tonal-client'
 
 const client = await TonalClient.create({
   username: 'your_email@example.com',

package/dist/index.d.ts

@@ -645,7 +645,8 @@ declare class TonalClient {
         username: string;
         password: string;
     }): Promise<TonalClient>;
-    getMovements(): Promise<TonalMovement[]>;
+    getMovements(useCache?: boolean): Promise<TonalMovement[]>;
+    invalidateMovementsCache(): Promise<void>;
     getUserInfo(): Promise<TonalUserInfo>;
     getGoals(): Promise<TonalGoal[]>;
     getTrainingEffectGoals(): Promise<TonalTrainingEffectGoalsResponse>;

package/dist/index.esm.js

@@ -1,3 +1,6 @@
+import fs from 'fs';
+import path from 'path';
+
 class TonalClientError extends Error {
     constructor(message, statusCode, originalError) {
         super(message);
@@ -10,7 +13,9 @@ class TonalClientError extends Error {
 class AuthManager {
     constructor(username, password) {
         this.idToken = '';
+        this.refreshToken = '';
         this.tokenExpiresAt = 0;
+        this.isRefreshing = false;
         this.authUrl = 'https://tonal.auth0.com/oauth/token';
         this.clientId = 'ERCyexW-xoVG_Yy3RDe-eV4xsOnRHP6L';
         this.username = username;
@@ -46,18 +51,70 @@ class AuthManager {
         }
         const tokenData = await response.json();
         this.idToken = tokenData.id_token;
+        this.refreshToken = tokenData.refresh_token;
         this.tokenExpiresAt = Date.now() + (tokenData.expires_in * 1000);
         return this.idToken;
     }
-    getValidToken() {
-        if (!this.isTokenValid()) {
-            throw new TonalClientError('Token expired. Call authenticate() first.');
+    async getValidToken() {
+        if (this.isTokenValid()) {
+            return this.idToken;
         }
-        return this.idToken;
+        if (this.refreshToken) {
+            if (!this.isRefreshing) {
+                await this.refreshTokens();
+            }
+            else {
+                // Wait for ongoing refresh to complete
+                while (this.isRefreshing) {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+            if (this.isTokenValid()) {
+                return this.idToken;
+            }
+        }
+        throw new TonalClientError('Token expired and refresh failed. Call authenticate() first.');
     }
     isTokenValid() {
         return !!this.idToken && Date.now() < this.tokenExpiresAt - 60000; // 1 minute buffer
     }
+    async refreshTokens() {
+        if (this.isRefreshing) {
+            return; // Prevent concurrent refresh attempts
+        }
+        this.isRefreshing = true;
+        try {
+            const response = await fetch(this.authUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    client_id: this.clientId,
+                    grant_type: 'refresh_token',
+                    refresh_token: this.refreshToken,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorData;
+                try {
+                    errorData = JSON.parse(errorText);
+                }
+                catch {
+                    errorData = { error: errorText };
+                }
+                throw new TonalClientError(errorData.error_description || errorData.error || 'Token refresh failed', response.status, errorData);
+            }
+            const tokenData = await response.json();
+            this.idToken = tokenData.id_token;
+            this.refreshToken = tokenData.refresh_token;
+            this.tokenExpiresAt = Date.now() + (tokenData.expires_in * 1000);
+        }
+        finally {
+            this.isRefreshing = false;
+        }
+    }
 }
 
 class HttpClient {
@@ -75,7 +132,7 @@ class HttpClient {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
         try {
-            const token = this.authManager.getValidToken();
+            const token = await this.authManager.getValidToken();
             const response = await fetch(url, {
                 ...options,
                 headers: {
@@ -123,6 +180,16 @@ class HttpClient {
             }
             catch (error) {
                 lastError = error instanceof TonalClientError ? error : new TonalClientError('Unknown error', undefined, error);
+                // If it's an auth error on first attempt, try to refresh token and retry once
+                if (attempt === 1 && lastError.statusCode && (lastError.statusCode === 401 || lastError.statusCode === 403)) {
+                    try {
+                        await this.authManager.getValidToken(); // This will refresh if needed
+                        continue; // Retry the request with the new token
+                    }
+                    catch (refreshError) {
+                        // If refresh fails, continue with normal retry logic
+                    }
+                }
                 if (attempt === this.maxRetries || (lastError.statusCode && lastError.statusCode < 500)) {
                     throw lastError;
                 }
@@ -259,12 +326,85 @@ class WorkoutService {
     }
 }
 
+class CacheManager {
+    constructor(cacheDir = '.cache', defaultTTL = 24 * 60 * 60 * 1000) {
+        this.cacheDir = cacheDir;
+        this.defaultTTL = defaultTTL;
+        this.ensureCacheDir();
+    }
+    ensureCacheDir() {
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+    getCachePath(key) {
+        return path.join(this.cacheDir, `${key}.json`);
+    }
+    async get(key) {
+        const cachePath = this.getCachePath(key);
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(cachePath, 'utf-8');
+            const entry = JSON.parse(content);
+            const cachedAt = new Date(entry.cachedAt).getTime();
+            const now = Date.now();
+            const age = now - cachedAt;
+            if (age > entry.ttl) {
+                // Cache expired
+                return null;
+            }
+            return entry.data;
+        }
+        catch (error) {
+            // If there's an error reading/parsing cache, treat as cache miss
+            return null;
+        }
+    }
+    async set(key, data, ttl) {
+        const cachePath = this.getCachePath(key);
+        const entry = {
+            cachedAt: new Date().toISOString(),
+            ttl: ttl || this.defaultTTL,
+            data,
+        };
+        fs.writeFileSync(cachePath, JSON.stringify(entry, null, 2), 'utf-8');
+    }
+    async invalidate(key) {
+        const cachePath = this.getCachePath(key);
+        if (fs.existsSync(cachePath)) {
+            fs.unlinkSync(cachePath);
+        }
+    }
+    async clear() {
+        if (fs.existsSync(this.cacheDir)) {
+            const files = fs.readdirSync(this.cacheDir);
+            for (const file of files) {
+                fs.unlinkSync(path.join(this.cacheDir, file));
+            }
+        }
+    }
+}
+
 class MovementService {
     constructor(httpClient) {
         this.httpClient = httpClient;
+        this.cacheManager = new CacheManager();
+    }
+    async getMovements(useCache = true) {
+        if (useCache) {
+            const cached = await this.cacheManager.get('movements');
+            if (cached) {
+                return cached;
+            }
+        }
+        const movements = await this.httpClient.request('/movements');
+        await this.cacheManager.set('movements', movements);
+        return movements;
     }
-    async getMovements() {
-        return this.httpClient.request('/movements');
+    async invalidateMovementsCache() {
+        await this.cacheManager.invalidate('movements');
     }
 }
 
@@ -377,8 +517,11 @@ class TonalClient {
         return client;
     }
     // Movement operations
-    async getMovements() {
-        return this.movementService.getMovements();
+    async getMovements(useCache = true) {
+        return this.movementService.getMovements(useCache);
+    }
+    async invalidateMovementsCache() {
+        return this.movementService.invalidateMovementsCache();
     }
     // User operations
     async getUserInfo() {

package/dist/index.js

@@ -2,6 +2,9 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
+var fs = require('fs');
+var path = require('path');
+
 class TonalClientError extends Error {
     constructor(message, statusCode, originalError) {
         super(message);
@@ -14,7 +17,9 @@ class TonalClientError extends Error {
 class AuthManager {
     constructor(username, password) {
         this.idToken = '';
+        this.refreshToken = '';
         this.tokenExpiresAt = 0;
+        this.isRefreshing = false;
         this.authUrl = 'https://tonal.auth0.com/oauth/token';
         this.clientId = 'ERCyexW-xoVG_Yy3RDe-eV4xsOnRHP6L';
         this.username = username;
@@ -50,18 +55,70 @@ class AuthManager {
         }
         const tokenData = await response.json();
         this.idToken = tokenData.id_token;
+        this.refreshToken = tokenData.refresh_token;
         this.tokenExpiresAt = Date.now() + (tokenData.expires_in * 1000);
         return this.idToken;
     }
-    getValidToken() {
-        if (!this.isTokenValid()) {
-            throw new TonalClientError('Token expired. Call authenticate() first.');
+    async getValidToken() {
+        if (this.isTokenValid()) {
+            return this.idToken;
         }
-        return this.idToken;
+        if (this.refreshToken) {
+            if (!this.isRefreshing) {
+                await this.refreshTokens();
+            }
+            else {
+                // Wait for ongoing refresh to complete
+                while (this.isRefreshing) {
+                    await new Promise(resolve => setTimeout(resolve, 100));
+                }
+            }
+            if (this.isTokenValid()) {
+                return this.idToken;
+            }
+        }
+        throw new TonalClientError('Token expired and refresh failed. Call authenticate() first.');
     }
     isTokenValid() {
         return !!this.idToken && Date.now() < this.tokenExpiresAt - 60000; // 1 minute buffer
     }
+    async refreshTokens() {
+        if (this.isRefreshing) {
+            return; // Prevent concurrent refresh attempts
+        }
+        this.isRefreshing = true;
+        try {
+            const response = await fetch(this.authUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    client_id: this.clientId,
+                    grant_type: 'refresh_token',
+                    refresh_token: this.refreshToken,
+                }),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorData;
+                try {
+                    errorData = JSON.parse(errorText);
+                }
+                catch {
+                    errorData = { error: errorText };
+                }
+                throw new TonalClientError(errorData.error_description || errorData.error || 'Token refresh failed', response.status, errorData);
+            }
+            const tokenData = await response.json();
+            this.idToken = tokenData.id_token;
+            this.refreshToken = tokenData.refresh_token;
+            this.tokenExpiresAt = Date.now() + (tokenData.expires_in * 1000);
+        }
+        finally {
+            this.isRefreshing = false;
+        }
+    }
 }
 
 class HttpClient {
@@ -79,7 +136,7 @@ class HttpClient {
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.requestTimeout);
         try {
-            const token = this.authManager.getValidToken();
+            const token = await this.authManager.getValidToken();
             const response = await fetch(url, {
                 ...options,
                 headers: {
@@ -127,6 +184,16 @@ class HttpClient {
             }
             catch (error) {
                 lastError = error instanceof TonalClientError ? error : new TonalClientError('Unknown error', undefined, error);
+                // If it's an auth error on first attempt, try to refresh token and retry once
+                if (attempt === 1 && lastError.statusCode && (lastError.statusCode === 401 || lastError.statusCode === 403)) {
+                    try {
+                        await this.authManager.getValidToken(); // This will refresh if needed
+                        continue; // Retry the request with the new token
+                    }
+                    catch (refreshError) {
+                        // If refresh fails, continue with normal retry logic
+                    }
+                }
                 if (attempt === this.maxRetries || (lastError.statusCode && lastError.statusCode < 500)) {
                     throw lastError;
                 }
@@ -263,12 +330,85 @@ class WorkoutService {
     }
 }
 
+class CacheManager {
+    constructor(cacheDir = '.cache', defaultTTL = 24 * 60 * 60 * 1000) {
+        this.cacheDir = cacheDir;
+        this.defaultTTL = defaultTTL;
+        this.ensureCacheDir();
+    }
+    ensureCacheDir() {
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+    getCachePath(key) {
+        return path.join(this.cacheDir, `${key}.json`);
+    }
+    async get(key) {
+        const cachePath = this.getCachePath(key);
+        if (!fs.existsSync(cachePath)) {
+            return null;
+        }
+        try {
+            const content = fs.readFileSync(cachePath, 'utf-8');
+            const entry = JSON.parse(content);
+            const cachedAt = new Date(entry.cachedAt).getTime();
+            const now = Date.now();
+            const age = now - cachedAt;
+            if (age > entry.ttl) {
+                // Cache expired
+                return null;
+            }
+            return entry.data;
+        }
+        catch (error) {
+            // If there's an error reading/parsing cache, treat as cache miss
+            return null;
+        }
+    }
+    async set(key, data, ttl) {
+        const cachePath = this.getCachePath(key);
+        const entry = {
+            cachedAt: new Date().toISOString(),
+            ttl: ttl || this.defaultTTL,
+            data,
+        };
+        fs.writeFileSync(cachePath, JSON.stringify(entry, null, 2), 'utf-8');
+    }
+    async invalidate(key) {
+        const cachePath = this.getCachePath(key);
+        if (fs.existsSync(cachePath)) {
+            fs.unlinkSync(cachePath);
+        }
+    }
+    async clear() {
+        if (fs.existsSync(this.cacheDir)) {
+            const files = fs.readdirSync(this.cacheDir);
+            for (const file of files) {
+                fs.unlinkSync(path.join(this.cacheDir, file));
+            }
+        }
+    }
+}
+
 class MovementService {
     constructor(httpClient) {
         this.httpClient = httpClient;
+        this.cacheManager = new CacheManager();
+    }
+    async getMovements(useCache = true) {
+        if (useCache) {
+            const cached = await this.cacheManager.get('movements');
+            if (cached) {
+                return cached;
+            }
+        }
+        const movements = await this.httpClient.request('/movements');
+        await this.cacheManager.set('movements', movements);
+        return movements;
     }
-    async getMovements() {
-        return this.httpClient.request('/movements');
+    async invalidateMovementsCache() {
+        await this.cacheManager.invalidate('movements');
     }
 }
 
@@ -381,8 +521,11 @@ class TonalClient {
         return client;
     }
     // Movement operations
-    async getMovements() {
-        return this.movementService.getMovements();
+    async getMovements(useCache = true) {
+        return this.movementService.getMovements(useCache);
+    }
+    async invalidateMovementsCache() {
+        return this.movementService.invalidateMovementsCache();
     }
     // User operations
     async getUserInfo() {

package/dist/src/auth/auth-manager.d.ts

@@ -2,11 +2,14 @@ export declare class AuthManager {
     private username;
     private password;
     private idToken;
+    private refreshToken;
     private tokenExpiresAt;
+    private isRefreshing;
     private readonly authUrl;
     private readonly clientId;
     constructor(username: string, password: string);
     authenticate(): Promise<string>;
-    getValidToken(): string;
+    getValidToken(): Promise<string>;
     private isTokenValid;
+    private refreshTokens;
 }

package/dist/src/client.d.ts

@@ -10,7 +10,8 @@ export declare class TonalClient {
         username: string;
         password: string;
     }): Promise<TonalClient>;
-    getMovements(): Promise<TonalMovement[]>;
+    getMovements(useCache?: boolean): Promise<TonalMovement[]>;
+    invalidateMovementsCache(): Promise<void>;
     getUserInfo(): Promise<TonalUserInfo>;
     getGoals(): Promise<TonalGoal[]>;
     getTrainingEffectGoals(): Promise<TonalTrainingEffectGoalsResponse>;

package/dist/src/services/movement-service.d.ts

@@ -2,6 +2,8 @@ import { HttpClient } from '../http/http-client';
 import { TonalMovement } from '../types';
 export declare class MovementService {
     private httpClient;
+    private cacheManager;
     constructor(httpClient: HttpClient);
-    getMovements(): Promise<TonalMovement[]>;
+    getMovements(useCache?: boolean): Promise<TonalMovement[]>;
+    invalidateMovementsCache(): Promise<void>;
 }

package/dist/src/utils/cache-manager.d.ts

@@ -0,0 +1,11 @@
+export declare class CacheManager {
+    private cacheDir;
+    private defaultTTL;
+    constructor(cacheDir?: string, defaultTTL?: number);
+    private ensureCacheDir;
+    private getCachePath;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, data: T, ttl?: number): Promise<void>;
+    invalidate(key: string): Promise<void>;
+    clear(): Promise<void>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dlwiest/ts-tonal-client",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "TypeScript client for Tonal API",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",
@@ -20,7 +20,10 @@
     "build": "rollup -c --bundleConfigAsCjs",
     "typecheck": "tsc --noEmit",
     "dev": "tsc --watch --noEmit",
-    "prepublishOnly": "npm run typecheck && npm run build",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "prepublishOnly": "npm run typecheck && npm run test && npm run build",
     "example:movements": "tsx examples/get-movements.ts",
     "example:movements:save": "tsx examples/get-movements.ts --save",
     "example:workout:id": "tsx examples/get-workout-by-id.ts",
@@ -53,7 +56,12 @@
     "type": "git",
     "url": "git+https://github.com/dlwiest/ts-tonal-client.git"
   },
-  "keywords": ["tonal", "tonal-api", "typescript", "client"],
+  "keywords": [
+    "tonal",
+    "tonal-api",
+    "typescript",
+    "client"
+  ],
   "author": "dlwiest",
   "license": "ISC",
   "bugs": {
@@ -62,10 +70,13 @@
   "homepage": "https://github.com/dlwiest/ts-tonal-client#readme",
   "devDependencies": {
     "@rollup/plugin-typescript": "^11.1.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.14.8",
     "dotenv": "^16.4.5",
+    "jest": "^30.2.0",
     "rollup": "^3.20.2",
     "rollup-plugin-dts": "^5.3.1",
+    "ts-jest": "^29.4.5",
     "ts-node": "^10.9.2",
     "tslib": "^2.7.0",
     "tsx": "^4.20.6",

package/dist/client.d.ts

@@ -1,16 +0,0 @@
-import { TonalMovement, TonalSharedWorkout, TonalWorkout } from './types';
-export declare class TonalClient {
-    private username;
-    private password;
-    private idToken;
-    private tokenExpiresAt;
-    private constructor();
-    static create({ username, password }: {
-        username: string;
-        password: string;
-    }): Promise<TonalClient>;
-    private refreshToken;
-    getMovements(): Promise<TonalMovement[]>;
-    getWorkoutById(id: string): Promise<TonalWorkout>;
-    getWorkoutByShareUrl(shareUrl: string): Promise<TonalSharedWorkout>;
-}

package/dist/types.d.ts

@@ -1,115 +0,0 @@
-export interface OAuthTokenResponse {
-    access_token: string;
-    id_token: string;
-    refresh_token: string;
-    scope: string;
-    token_type: string;
-    expires_in: number;
-}
-export type MuscleGroup = 'Obliques' | 'Abs' | 'Shoulders' | 'Glutes' | 'Back' | 'Biceps' | 'Quads' | 'Triceps' | 'Chest' | 'Hamstrings' | 'Calves' | 'Forearms';
-export interface TonalMovement {
-    id: string;
-    createdAt: string;
-    updatedAt: string;
-    name: string;
-    shortName: string;
-    muscleGroups: MuscleGroup[];
-    bodyRegion: string;
-    bodyRegionDisplay: string;
-    baseOfSupport: string;
-    pushPull: string;
-    family: string;
-    familyDisplay: string;
-    inFreeLift: boolean;
-    onMachine: boolean;
-    countReps: boolean;
-    isTwoSided: boolean;
-    isBilateral: boolean;
-    isAlternating: boolean;
-    offMachineAccessory: string;
-    descriptionHow: string;
-    descriptionWhy: string;
-    sortOrder: number;
-    imageAssetId: string;
-    skillLevel: number;
-    active: boolean;
-    featureGroupIds: null | string[];
-    isGeneric: boolean;
-}
-export interface TonalWorkout {
-    id: string;
-    createdAt: string;
-    title: string;
-    shortDescription: string;
-    description: string;
-    productionCode: string;
-    assetId: string;
-    coachId: string;
-    sets: WorkoutSet[];
-    duration: number;
-    publishState: string;
-    programId: string | null;
-    level: string;
-    groupIds: string[];
-    targetArea: string;
-    tags: string[] | null;
-    bodyRegions: MuscleGroup[];
-    goalIds: string[] | null;
-    trainingEffectGoals: string[];
-    disableModification: boolean;
-    publishedAt: string;
-    localPublishedAt: string;
-    type: string;
-    userId: string;
-    style: string;
-    trainingType: string;
-    trainingTypeIds: string[] | null;
-    mobileFriendly: boolean;
-    live: boolean;
-    recoveryWeight: boolean;
-    supportedDevices: string[] | null;
-    featureGroupIds: string[] | null;
-    movementIds: string[];
-    muscleGroupsForExclusion: MuscleGroup[] | null;
-    playbackType: string;
-    isImported: boolean;
-}
-interface WorkoutSet {
-    id: string;
-    workoutId: string;
-    blockStart: boolean;
-    movementId: string;
-    prescribedReps: number;
-    repetition: number;
-    repetitionTotal: number;
-    blockNumber: number;
-    burnout: boolean;
-    spotter: boolean;
-    eccentric: boolean;
-    chains: boolean;
-    skipSetup: boolean;
-    skipDemo: boolean;
-    finalSet: boolean;
-    calibration: boolean;
-    practice: boolean;
-    flex: boolean;
-    progressive: boolean;
-    weightPercentage: number;
-    warmUp: boolean;
-    durationBasedRepGoal: number;
-    setGroup: number;
-    round: number;
-    description: string;
-    dropSet: boolean;
-    omitempty: null | any;
-}
-export interface TonalSharedWorkout {
-    id: string;
-    sharerUserId: string;
-    parentWorkoutId: string;
-    workoutSnapshotId: string;
-    workoutSnapshotHash: string;
-    deepLinkUrl: string;
-    workoutSnapshot: TonalWorkout;
-}
-export {};