@dlwiest/ts-tonal-client 0.1.1 → 0.2.0

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);
@@ -323,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');
     }
 }
 
@@ -441,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);
@@ -327,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');
     }
 }
 
@@ -445,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/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.1",
+  "version": "0.2.0",
   "description": "TypeScript client for Tonal API",
   "main": "dist/index.js",
   "module": "dist/index.esm.js",

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 {};