hevy-shared 1.0.845 → 1.0.847

package/built/API/APIClient.d.ts

@@ -1,6 +1,6 @@
 import { ClientAuthToken, DeepReadonly } from '..';
 import { RequestConfig, HTTPResponse, HTTPClient, HTTPErrorHandler } from './types';
-interface HevyAPIClientConfig {
+interface HevyAPIClientConfig<UserContext> {
     /**
      * How long before predicted token expiry to request a new token. We request
      * new tokens a little bit before they expire, so that we don't have to wait
@@ -55,7 +55,16 @@ interface HevyAPIClientConfig {
      *
      * Required.
      */
-    onNewAuthToken(newAuthToken: ClientAuthToken): void;
+    onNewAuthToken(newAuthToken: ClientAuthToken, userContext: UserContext): void;
+    /**
+     * Defines an arbitrary object to be passed back to the `onNewAuthToken`. The
+     * value is computed at the time when the request is made. Useful for passing
+     * back state that may have gotten changed during the time while the request
+     * was being processed, such as holding onto a userId across a logout action.
+     *
+     * Optional.
+     */
+    getUserContext?(): UserContext;
     /**
      * Callback to use when receiving an HTTP error response from the backend, to
      * determine whether it is a response indicating that the token has expired.
@@ -75,7 +84,7 @@ interface HevyAPIClientConfig {
      */
     isAccessTokenInvalidResponse?(response: HTTPResponse<unknown>): boolean;
 }
-export declare class HevyAPIClient {
+export declare class HevyAPIClient<UserContext = never> {
     private static readonly DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS;
     private static readonly DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS;
     private static readonly DEFAULT_TOKEN_REFRESH_THROTTLE_MS;
@@ -86,7 +95,7 @@ export declare class HevyAPIClient {
     private _legacyAuthToken;
     private _httpClient;
     private _lastTokenRefresh;
-    constructor(httpClient: HTTPClient, config: HevyAPIClientConfig);
+    constructor(httpClient: HTTPClient, config: HevyAPIClientConfig<UserContext>);
     private get _authToken();
     private get _authHeaders();
     private _addAuthHeaders;

package/built/API/APIClient.js

@@ -32,7 +32,7 @@ class HevyAPIClient {
                 (0, types_1.isHTTPErrorResponse)(response) &&
                 response.data.error === 'AccessTokenExpired', isAccessTokenInvalidResponse: (response) => response.status === 401 &&
                 (0, types_1.isHTTPErrorResponse)(response) &&
-                response.data.error === 'InvalidAccessToken' }, config);
+                response.data.error === 'InvalidAccessToken', getUserContext: () => undefined }, config);
         const classProperties = Object.getOwnPropertyNames(Object.getPrototypeOf(this)).filter((m) => m in this && typeof m === 'string' && m !== 'constructor');
         classProperties.forEach((m) => {
             if (typeof this[m] === 'function')
@@ -52,7 +52,7 @@ class HevyAPIClient {
             ? { authorization: `Bearer ${this._authToken.access_token}` }
             : {})), (this._legacyAuthToken ? { 'auth-token': this._legacyAuthToken } : {}));
     }
-    refreshExpiredAuthToken() {
+    refreshExpiredAuthToken(userContext) {
         return __awaiter(this, void 0, void 0, function* () {
             const { _authToken } = this;
             if (!_authToken)
@@ -63,15 +63,15 @@ class HevyAPIClient {
                 // Token is still valid, at least according to the client. Don't refresh.
                 return;
             }
-            yield this._refreshAuthToken(_authToken);
+            yield this._refreshAuthToken(_authToken, userContext);
         });
     }
-    forceRefreshAuthToken() {
+    forceRefreshAuthToken(userContext) {
         return __awaiter(this, void 0, void 0, function* () {
             const { _authToken } = this;
             if (!_authToken)
                 return;
-            yield this._refreshAuthToken(_authToken);
+            yield this._refreshAuthToken(_authToken, userContext);
         });
     }
     waitForTokenRefresh() {
@@ -86,7 +86,7 @@ class HevyAPIClient {
             _lastTokenRefresh.valueOf() >
                 new Date().valueOf() - this._config.tokenRefreshThrottleMs);
     }
-    _refreshAuthToken(authToken) {
+    _refreshAuthToken(authToken, userContext) {
         return __awaiter(this, void 0, void 0, function* () {
             if (this._isTokenRecentlyRefreshed) {
                 // We have called this function recently. Do not ever spam this endpoint.
@@ -103,7 +103,7 @@ class HevyAPIClient {
                 method,
                 url,
                 try: () => this._httpClient[method](url, { refresh_token }, { headers: { authorization: `Bearer ${access_token}` } }),
-            }, false);
+            }, userContext, false);
             const newToken = {
                 access_token: response.data.access_token,
                 refresh_token: response.data.refresh_token,
@@ -130,11 +130,11 @@ class HevyAPIClient {
             if (this._authTokenFactory.type === 'value') {
                 this._authTokenFactory.value = newToken;
             }
-            this._config.onNewAuthToken(newToken);
+            this._config.onNewAuthToken(newToken, userContext);
         });
     }
-    _handleResponse(request_1) {
-        return __awaiter(this, arguments, void 0, function* (request, retryOnFailure = !this._isTokenRecentlyRefreshed) {
+    _handleResponse(request_1, userContext_1) {
+        return __awaiter(this, arguments, void 0, function* (request, userContext, retryOnFailure = !this._isTokenRecentlyRefreshed) {
             const requestTime = new Date();
             try {
                 const response = yield request.try();
@@ -164,14 +164,14 @@ class HevyAPIClient {
                     isTokenRefreshedAfterRequest,
                 }));
                 if (retryOnFailure && this.isAccessTokenExpiredResponse(response)) {
-                    yield this.forceRefreshAuthToken();
-                    return yield this._handleResponse(request, false);
+                    yield this.forceRefreshAuthToken(userContext);
+                    return yield this._handleResponse(request, userContext, false);
                 }
                 else if (retryOnFailure &&
                     this.isAccessTokenInvalidResponse(response) &&
                     isTokenRefreshedAfterRequest) {
                     yield this.waitForTokenRefresh();
-                    return yield this._handleResponse(request, false);
+                    return yield this._handleResponse(request, userContext, false);
                 }
                 else {
                     throw e;
@@ -221,79 +221,86 @@ class HevyAPIClient {
     }
     get(url, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshExpiredAuthToken();
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
             const method = 'get';
             return this._handleResponse({
                 method,
                 url,
                 try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
-            });
+            }, userContext);
         });
     }
     delete(url, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshExpiredAuthToken();
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
             const method = 'delete';
             return this._handleResponse({
                 method,
                 url,
                 try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
-            });
+            }, userContext);
         });
     }
     head(url, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshExpiredAuthToken();
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
             const method = 'head';
             return this._handleResponse({
                 method,
                 url,
                 try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
-            });
+            }, userContext);
         });
     }
     options(url, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshExpiredAuthToken();
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
             const method = 'options';
             return this._handleResponse({
                 method,
                 url,
                 try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
-            });
+            }, userContext);
         });
     }
     post(url, data, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshExpiredAuthToken();
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
             const method = 'post';
             return this._handleResponse({
                 method,
                 url,
                 try: () => this._httpClient[method](url, data, this._addAuthHeaders(config)),
-            });
+            }, userContext);
         });
     }
     put(url, data, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshExpiredAuthToken();
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
             const method = 'put';
             return this._handleResponse({
                 method,
                 url,
                 try: () => this._httpClient[method](url, data, this._addAuthHeaders(config)),
-            });
+            }, userContext);
         });
     }
     patch(url, data, config) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.refreshExpiredAuthToken();
+            const userContext = this._config.getUserContext();
+            yield this.refreshExpiredAuthToken(userContext);
             const method = 'patch';
             return this._handleResponse({
                 method,
                 url,
                 try: () => this._httpClient[method](url, data, this._addAuthHeaders(config)),
-            });
+            }, userContext);
         });
     }
 }

package/built/hevyTrainer.d.ts

@@ -92,7 +92,6 @@ export interface BackofficeTrainerPreset {
     is_default?: boolean;
     updated_at?: string;
     settings: TrainerAlgorithmSettings;
-    workout_tab_ai_insight_prompt?: string;
 }
 export interface TrainerAlgorithmSettings {
     sets: SetsPerFrequency;

package/built/index.d.ts

@@ -1245,7 +1245,6 @@ export interface HevyTrainerProgram {
     routines: HevyTrainerRoutine[];
     focus_muscle?: SimplifiedMuscleGroup;
     next_workout_index: number;
-    workout_tab_ai_insights?: string;
     workout_duration_minutes?: WorkoutDurationMinutes;
 }
 export interface PostHevyTrainerProgramRequestBody {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hevy-shared",
-  "version": "1.0.845",
+  "version": "1.0.847",
   "description": "",
   "main": "built/index.js",
   "types": "built/index.d.ts",