hevy-shared 1.0.807 → 1.0.809

package/built/API/APIClient.d.ts

@@ -0,0 +1,122 @@
+import { ClientAuthToken, DeepReadonly } from '..';
+import { RequestConfig, HTTPResponse, HTTPClient, HTTPErrorHandler } from './types';
+interface HevyAPIClientConfig {
+    /**
+     * 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
+     * for the backend to send us a 401 first. We do it pre-emptively so that we
+     * wouldn't need to wait for requests to fail first, and then retry them.
+     *
+     * Optional.
+     *
+     * @default {1 minute}
+     */
+    readonly tokenExpirySafetyThresholdMs?: number;
+    /**
+     * How long we expect the access token to be valid for. Used to override the
+     * expiry time sent by the backend in case the client clock is in the future
+     * and the client thinks that the token will expire sooner than it actually
+     * will. Even if this assumption ever stops being correct, the client will be
+     * able to self-correct by receiving an `AccessTokenExpired` 401 response.
+     *
+     * Optional.
+     *
+     * @default {15 minutes}
+     */
+    readonly accessTokenMinimumValidAgeMs?: number;
+    /**
+     * Minimum time between successive calls to the `auth/refresh_token` endpoint
+     * in case it doesn't return an error. Also used to deal with potential clock
+     * issues on the client side, or some unforeseen issue on the backend, as the
+     * last line of defence. No matter what may happen, we absolutely never ever
+     * want to end up accidentally spamming this endpoint because it could have a
+     * cascading clusterfuck effect on all the other requests.
+     *
+     * Optional.
+     *
+     * @default {20 seconds}
+     */
+    readonly tokenRefreshThrottleMs?: number;
+    /**
+     * The API endpoint used to refresh the auth tokens using a refresh token.
+     * The URL is relative to the backend base URL.
+     *
+     * Optional.
+     *
+     * @default {POST /auth/refresh_token}
+     */
+    readonly refreshAuthTokenApiEndpoint?: {
+        readonly method: 'post';
+        readonly url: string;
+    };
+    /**
+     * Callback to use when receiving a new auth token. Used to send it to the
+     * consumer of the class to save the new token to its local storage.
+     *
+     * Required.
+     */
+    onNewAuthToken(newAuthToken: ClientAuthToken): void;
+    /**
+     * 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.
+     *
+     * Optional.
+     *
+     * @default ...
+     */
+    isAccessTokenExpiredResponse?(response: HTTPResponse<unknown>): boolean;
+    /**
+     * Callback to use when receiving an HTTP error response from the backend, to
+     * determine whether it is a response indicating that the token is invalid.
+     *
+     * Optional.
+     *
+     * @default ...
+     */
+    isAccessTokenInvalidResponse?(response: HTTPResponse<unknown>): boolean;
+}
+export declare class HevyAPIClient {
+    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;
+    private static readonly DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT;
+    private readonly _config;
+    private _errorHandlers;
+    private _authToken;
+    private _legacyAuthToken;
+    private _httpClient;
+    private _lastTokenRefresh;
+    constructor(httpClient: HTTPClient, config: HevyAPIClientConfig);
+    private get _authHeaders();
+    private _addAuthHeaders;
+    private refreshExpiredAuthToken;
+    private forceRefreshAuthToken;
+    private waitForTokenRefresh;
+    private get _isTokenRecentlyRefreshed();
+    private _refreshAuthToken;
+    private _handleResponse;
+    isAccessTokenExpiredResponse(response: HTTPResponse<unknown>): boolean;
+    isAccessTokenInvalidResponse(response: HTTPResponse<unknown>): boolean;
+    get refreshAuthTokenApiEndpoint(): {
+        readonly method: "post";
+        readonly url: string;
+    };
+    setAuthToken(newAuthToken: DeepReadonly<{
+        authToken: ClientAuthToken | null;
+        legacyAuthToken: string | null;
+    }>): Promise<void>;
+    clearAuthToken(): Promise<void>;
+    attachErrorHandler(onError: HTTPErrorHandler<{
+        willRetry: boolean;
+        isTokenRefreshedAfterRequest: boolean;
+    }>): void;
+    removeErrorHandlers(): void;
+    get<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    delete<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    head<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    options<T = never>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    post<T = never, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    put<T = never, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    patch<T = never, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+}
+export {};

package/built/API/APIClient.js

@@ -0,0 +1,303 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HevyAPIClient = void 0;
+const __1 = require("..");
+const types_1 = require("./types");
+class HevyAPIClient {
+    constructor(httpClient, config) {
+        this._errorHandlers = [];
+        this._authToken = null;
+        this._legacyAuthToken = null;
+        this._addAuthHeaders = (config) => (Object.assign(Object.assign({}, config), { headers: Object.assign(Object.assign({}, config === null || config === void 0 ? void 0 : config.headers), this._authHeaders) }));
+        this._httpClient = httpClient;
+        this._config = Object.assign({ tokenExpirySafetyThresholdMs: HevyAPIClient.DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS, accessTokenMinimumValidAgeMs: HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS, tokenRefreshThrottleMs: HevyAPIClient.DEFAULT_TOKEN_REFRESH_THROTTLE_MS, refreshAuthTokenApiEndpoint: HevyAPIClient.DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT, isAccessTokenExpiredResponse: (response) => response.status === 401 &&
+                (0, types_1.isHTTPErrorResponse)(response) &&
+                response.data.error === 'AccessTokenExpired', isAccessTokenInvalidResponse: (response) => response.status === 401 &&
+                (0, types_1.isHTTPErrorResponse)(response) &&
+                response.data.error === 'InvalidAccessToken' }, 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')
+                this[m] = this[m].bind(this);
+        });
+    }
+    get _authHeaders() {
+        return this._authToken
+            ? { authorization: `Bearer ${this._authToken.access_token}` }
+            : this._legacyAuthToken
+                ? { 'auth-token': this._legacyAuthToken }
+                : null;
+    }
+    refreshExpiredAuthToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _authToken } = this;
+            if (!_authToken)
+                return;
+            if (new Date().valueOf() <=
+                new Date(_authToken.expires_at).valueOf() -
+                    this._config.tokenExpirySafetyThresholdMs) {
+                // Token is still valid, at least according to the client. Don't refresh.
+                return;
+            }
+            yield this._refreshAuthToken(_authToken);
+        });
+    }
+    forceRefreshAuthToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { _authToken } = this;
+            if (!_authToken)
+                return;
+            yield this._refreshAuthToken(_authToken);
+        });
+    }
+    waitForTokenRefresh() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // This may look like it does nothing, but that is absolutely not the case.
+            // Do not remove this function!
+        });
+    }
+    get _isTokenRecentlyRefreshed() {
+        const { _lastTokenRefresh } = this;
+        return (_lastTokenRefresh !== undefined &&
+            _lastTokenRefresh.valueOf() >
+                new Date().valueOf() - this._config.tokenRefreshThrottleMs);
+    }
+    _refreshAuthToken(authToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this._isTokenRecentlyRefreshed) {
+                // We have called this function recently. Do not ever spam this endpoint.
+                // Also, if any request needs to be retried due to issues with the client
+                // clock being out of sync with the backend, do that with the last token
+                // that was obtained after a 401 with the `AccessTokenExpired` response.
+                return;
+            }
+            this._lastTokenRefresh = new Date();
+            const { access_token, refresh_token } = authToken;
+            const { method, url } = this.refreshAuthTokenApiEndpoint;
+            // This will throw and bail out if the request fails.
+            const response = yield this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, { refresh_token }, { headers: { authorization: `Bearer ${access_token}` } }),
+            }, false);
+            const newToken = {
+                access_token: response.data.access_token,
+                refresh_token: response.data.refresh_token,
+                expires_at: new Date(response.data.expires_at),
+            };
+            /**
+             * Do not attempt to auto-refresh the token before this time - by default,
+             * {@link HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS 15 mins}
+             * after the current time. Normally the backend will generate a token that
+             * lives for at least 15 minutes, but since it sends the expiry timestamp
+             * rather than a max age in relative time units, even if the client's clock
+             * is severely out of sync, we don't want to think that the token has
+             * expired when in reality it hasn't.
+             *
+             * If we ever change the access tokens to really live for less than 15 min,
+             * this assertion will no longer hold, and any tokens that are expired
+             * despite the client not realising it will be handled by the logic that
+             * handles 401s with the `AccessTokenExpired` error response.
+             */
+            const earliestAutoRefreshUnixMs = new Date().valueOf() + this._config.accessTokenMinimumValidAgeMs;
+            if (newToken.expires_at.valueOf() < earliestAutoRefreshUnixMs) {
+                newToken.expires_at = new Date(earliestAutoRefreshUnixMs);
+            }
+            this._authToken = newToken;
+            this._config.onNewAuthToken(newToken);
+        });
+    }
+    _handleResponse(request_1) {
+        return __awaiter(this, arguments, void 0, function* (request, retryOnFailure = !this._isTokenRecentlyRefreshed) {
+            const requestTime = new Date();
+            try {
+                const response = yield request.try();
+                if (response.status >= 400) {
+                    throw Object.assign(new Error(`Request failed with status code ${response.status}`), {
+                        response,
+                    });
+                }
+                return response;
+            }
+            catch (e) {
+                if (!(0, types_1.isHTTPError)(e))
+                    throw e;
+                const { response } = e;
+                /**
+                 * We've had a {@link _refreshAuthToken} called _after_ this request was
+                 * made. If that request reached the server before this one did, this one
+                 * will have failed with a 401 because it's using the old token.
+                 *
+                 * In this (relatively unlikely) scenario, we will want to retry the
+                 * request, and also we will not want to log the user out.
+                 */
+                const isTokenRefreshedAfterRequest = this._lastTokenRefresh !== undefined &&
+                    requestTime < this._lastTokenRefresh;
+                this._errorHandlers.forEach((cb) => cb(response, request, {
+                    willRetry: retryOnFailure,
+                    isTokenRefreshedAfterRequest,
+                }));
+                if (retryOnFailure && this.isAccessTokenExpiredResponse(response)) {
+                    yield this.forceRefreshAuthToken();
+                    return yield this._handleResponse(request, false);
+                }
+                else if (retryOnFailure &&
+                    this.isAccessTokenInvalidResponse(response) &&
+                    isTokenRefreshedAfterRequest) {
+                    yield this.waitForTokenRefresh();
+                    return yield this._handleResponse(request, false);
+                }
+                else {
+                    throw e;
+                }
+            }
+        });
+    }
+    isAccessTokenExpiredResponse(response) {
+        return this._config.isAccessTokenExpiredResponse(response);
+    }
+    isAccessTokenInvalidResponse(response) {
+        return this._config.isAccessTokenInvalidResponse(response);
+    }
+    get refreshAuthTokenApiEndpoint() {
+        return Object.assign({}, this._config.refreshAuthTokenApiEndpoint);
+    }
+    setAuthToken(newAuthToken) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForTokenRefresh();
+            const { authToken, legacyAuthToken } = newAuthToken;
+            this._authToken = authToken
+                ? {
+                    access_token: authToken.access_token,
+                    refresh_token: authToken.refresh_token,
+                    expires_at: new Date(authToken.expires_at),
+                }
+                : null;
+            this._legacyAuthToken = legacyAuthToken;
+            this._lastTokenRefresh = undefined;
+        });
+    }
+    clearAuthToken() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitForTokenRefresh();
+            this._authToken = null;
+            this._legacyAuthToken = null;
+            this._lastTokenRefresh = undefined;
+        });
+    }
+    attachErrorHandler(onError) {
+        this._errorHandlers.push(onError);
+    }
+    removeErrorHandlers() {
+        this._errorHandlers.length = 0;
+    }
+    get(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshExpiredAuthToken();
+            const method = 'get';
+            return this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
+            });
+        });
+    }
+    delete(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshExpiredAuthToken();
+            const method = 'delete';
+            return this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
+            });
+        });
+    }
+    head(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshExpiredAuthToken();
+            const method = 'head';
+            return this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
+            });
+        });
+    }
+    options(url, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshExpiredAuthToken();
+            const method = 'options';
+            return this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, this._addAuthHeaders(config)),
+            });
+        });
+    }
+    post(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshExpiredAuthToken();
+            const method = 'post';
+            return this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, data, this._addAuthHeaders(config)),
+            });
+        });
+    }
+    put(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshExpiredAuthToken();
+            const method = 'put';
+            return this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, data, this._addAuthHeaders(config)),
+            });
+        });
+    }
+    patch(url, data, config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.refreshExpiredAuthToken();
+            const method = 'patch';
+            return this._handleResponse({
+                method,
+                url,
+                try: () => this._httpClient[method](url, data, this._addAuthHeaders(config)),
+            });
+        });
+    }
+}
+exports.HevyAPIClient = HevyAPIClient;
+HevyAPIClient.DEFAULT_TOKEN_EXPIRY_SAFETY_THRESHOLD_MS = 60000;
+HevyAPIClient.DEFAULT_ACCESS_TOKEN_MINIMUM_VALID_AGE_MS = 900000;
+HevyAPIClient.DEFAULT_TOKEN_REFRESH_THROTTLE_MS = 20000;
+HevyAPIClient.DEFAULT_REFRESH_AUTH_TOKEN_API_ENDPOINT = {
+    method: 'post',
+    url: 'auth/refresh_token',
+};
+__decorate([
+    (0, __1.synchronized)(true, 'refreshAuthToken')
+], HevyAPIClient.prototype, "refreshExpiredAuthToken", null);
+__decorate([
+    (0, __1.synchronized)(true, 'refreshAuthToken')
+], HevyAPIClient.prototype, "forceRefreshAuthToken", null);
+__decorate([
+    (0, __1.synchronized)(true, 'refreshAuthToken')
+], HevyAPIClient.prototype, "waitForTokenRefresh", null);

package/built/API/index.d.ts

@@ -0,0 +1,2 @@
+export * from './APIClient';
+export * from './types';

package/built/API/index.js

@@ -0,0 +1,18 @@
+"use strict";
+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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./APIClient"), exports);
+__exportStar(require("./types"), exports);

package/built/API/types.d.ts

@@ -0,0 +1,35 @@
+export interface HTTPClient {
+    get<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    delete<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    head<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    options<T>(url: string, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    post<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    put<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+    patch<T, R = unknown>(url: string, data?: R, config?: RequestConfig): Promise<HTTPResponse<T>>;
+}
+export interface RequestConfig {
+    headers?: Record<string, string>;
+    baseURL?: string;
+    params?: unknown;
+    signal?: AbortSignal;
+}
+export type HTTPMethod = keyof {
+    [K in keyof HTTPClient as HTTPClient[K] extends (...args: any) => Promise<HTTPResponse<never>> ? K : never]: never;
+};
+export interface HTTPRequestFactory<T = unknown> {
+    method: HTTPMethod;
+    url: string;
+    try(): Promise<HTTPResponse<T>>;
+}
+export type HTTPErrorHandler<E, T = unknown, R = unknown> = (response: HTTPResponse<T>, request: HTTPRequestFactory<R>, extraData: E) => void;
+export interface HTTPResponse<T = unknown> {
+    status: number;
+    data: T;
+}
+export interface HTTPError<T = unknown> extends Error {
+    response: HTTPResponse<T>;
+}
+export declare const isHTTPError: <T = unknown>(e: unknown) => e is HTTPError<T>;
+export declare const isHTTPErrorResponse: (response: HTTPResponse<unknown>) => response is HTTPResponse<{
+    error: string;
+}>;

package/built/API/types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHTTPErrorResponse = exports.isHTTPError = void 0;
+const isHTTPError = (e) => {
+    return (e instanceof Error &&
+        'response' in e &&
+        typeof e.response === 'object' &&
+        e.response !== null &&
+        'status' in e.response &&
+        typeof e.response.status === 'number');
+};
+exports.isHTTPError = isHTTPError;
+const isHTTPErrorResponse = (response) => response.status >= 400 &&
+    typeof response.data === 'object' &&
+    response.data !== null &&
+    'error' in response.data &&
+    typeof response.data.error === 'string';
+exports.isHTTPErrorResponse = isHTTPErrorResponse;

package/built/async.d.ts

@@ -34,3 +34,14 @@ export declare const allToResolveOrReject: <T>(promises: Promise<T>[]) => Promis
  * await handleRejection(fetch('https://hevy.com/blabla'));
  */
 export declare const handleRejection: <T>(p: Promise<T>) => Promise<T>;
+type MethodDecorator<T> = (target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => T>) => void;
+export declare function synchronized(queue: boolean): MethodDecorator<Promise<any>>;
+export declare function synchronized(queue: boolean, id: any): MethodDecorator<Promise<any>>;
+export declare function synchronized(target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => Promise<any>>): void;
+/** @deprecated Using this on a synchronous function has no effect */
+export declare function synchronized(queue: boolean): MethodDecorator<any>;
+/** @deprecated Using this on a synchronous function has no effect */
+export declare function synchronized(queue: boolean, id: any): MethodDecorator<any>;
+/** @deprecated Using this on a synchronous function has no effect */
+export declare function synchronized(target: unknown, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<(...args: any[]) => any>): void;
+export {};

package/built/async.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleRejection = exports.allToResolveOrReject = void 0;
+exports.synchronized = synchronized;
 /**
  * The difference between this and `Promise.all` is that `Promise.all` rejects
  * when any promise rejects, and this resolves when all promises resolve _or_
@@ -58,3 +59,50 @@ exports.allToResolveOrReject = allToResolveOrReject;
  */
 const handleRejection = (p) => (p.catch(() => { }), p);
 exports.handleRejection = handleRejection;
+function synchronized(arg0, arg1, arg2) {
+    if (arguments.length === 1) {
+        return function (target, propertyKey, descriptor) {
+            return synchronizedDecoratorFactory(target, propertyKey, descriptor, arg0);
+        };
+    }
+    else if (arguments.length === 2) {
+        return function (target, propertyKey, descriptor) {
+            return synchronizedDecoratorFactory(target, propertyKey, descriptor, arg0, arg1);
+        };
+    }
+    else {
+        return synchronizedDecoratorFactory(arg0, arg1, arg2, true);
+    }
+}
+const $queue = Symbol();
+function synchronizedDecoratorFactory(_target, _propertyKey, descriptor, wait, id) {
+    const origFn = descriptor.value;
+    const lockId = arguments.length === 5 ? id : Symbol();
+    descriptor.value = function (...args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            var _c;
+            const queue = ((_b = (_c = ((_a = this[$queue]) !== null && _a !== void 0 ? _a : (this[$queue] = {})))[lockId]) !== null && _b !== void 0 ? _b : (_c[lockId] = []));
+            if (queue.length > 0 && !wait) {
+                throw new Error('Operation is already in progress');
+            }
+            let done;
+            const thisCall = new Promise((resolve) => {
+                done = resolve;
+            });
+            const waiting = [...queue];
+            queue.push(thisCall);
+            yield (0, exports.allToResolveOrReject)(waiting);
+            try {
+                return yield origFn.apply(this, args);
+            }
+            finally {
+                done();
+                if (queue.shift() !== thisCall) {
+                    // eslint-disable-next-line no-unsafe-finally
+                    throw new Error('Assertion failed: @synchronized queue is mangled');
+                }
+            }
+        });
+    };
+}

package/built/index.d.ts

@@ -217,6 +217,19 @@ export interface SocialLoginResult {
     email: string;
     is_new_user: boolean;
 }
+export interface ClientAuthToken {
+    access_token: string;
+    refresh_token: string;
+    expires_at: Date;
+}
+export interface ClientRefreshTokenRequest {
+    refresh_token: string;
+}
+export interface ClientAuthTokenResponse {
+    access_token: string;
+    refresh_token: string;
+    expires_at: string;
+}
 export interface UsernameAvailabilityResponse {
     isAvailable: boolean;
     suggestions: string[];
@@ -919,7 +932,6 @@ export interface PostWorkoutRequestWorkout {
     biometrics?: WorkoutBiometrics;
     is_biometrics_public: boolean;
     is_trainer_workout: boolean;
-    trainer_program_id?: string;
 }
 export declare const isHeartRateSamples: (x: any) => x is HeartRateSample[];
 export declare const isWorkoutBiometrics: (x: any) => x is WorkoutBiometrics;
@@ -1209,7 +1221,6 @@ export interface OutstandingInvitesForCoachTeamResponse {
     invites: CoachTeamInvite[];
 }
 export interface HevyTrainerProgram {
-    id: string;
     created_at: string;
     updated_at: string;
     title: string;

package/built/typeUtils.d.ts

@@ -1,5 +1,8 @@
 export type Lookup<T extends readonly unknown[]> = T[number];
 export declare const isInArray: <T, ReadonlyArrayOfT extends readonly T[]>(value: T, array: ReadonlyArrayOfT) => value is Lookup<ReadonlyArrayOfT>;
+export type DeepReadonly<T> = {
+    readonly [P in keyof T]: T[P] extends (...args: any[]) => any ? T[P] : DeepReadonly<T[P]>;
+};
 export declare const exhaustiveTypeCheck: (_: never) => undefined;
 export declare const exhaustiveTypeException: (type: never) => Error;
 export type Some<T> = {

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "hevy-shared",
-  "version": "1.0.807",
+  "version": "1.0.809",
   "description": "",
   "main": "built/index.js",
   "types": "built/index.d.ts",
   "prepublish": "tsc",
   "scripts": {
     "prepare": "tsc --skipLibCheck",
-    "build": "tsc",
+    "build": "tsc --removeComments && tsc --emitDeclarationOnly",
     "types": "tsc --skipLibCheck",
     "p": "npm run test && npm version patch && npm run build && npm publish && git push",
     "ci-build": "./scripts/publish.sh",
@@ -15,6 +15,17 @@
     "lint-fix": "eslint . --ext .ts --fix",
     "test": "jest"
   },
+  "exports": {
+    ".": "./built/index.js",
+    "./API": "./built/API/index.js"
+  },
+  "typesVersions": {
+    "*": {
+      "API": [
+        "built/API/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "built"
   ],