@dronedeploy/rocos-js-sdk 3.0.1-alpha.3 → 3.0.1-alpha.6

package/cjs/services/AssetStorageService.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetStorageService = void 0;
+const api_1 = require("../constants/api");
+const RocosError_1 = require("../models/RocosError");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+class AssetStorageService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`AssetStorageService(${this.config.url})`);
+    }
+    getError(e) {
+        return new RocosError_1.RocosError(e, RocosError_1.errorCodes.ASSET_STORAGE_SERVICE_ERROR);
+    }
+    getStatus() {
+        return true;
+    }
+    /**
+     * Create a new project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     * @param file - File payload
+     */
+    // TODO: map the response object
+    async create(projectId, filePath, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), formData, `Failed to create asset for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Update a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     * @param file - File payload
+     */
+    // TODO: map the response object
+    async update(projectId, filePath, file) {
+        const formData = new FormData();
+        formData.append('file', file);
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), formData, `Failed to update asset for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Delete a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    // TODO: map the response object
+    async delete(projectId, filePath) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), `Failed to delete asset for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Lost assets for a project or project file path
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    // TODO: map the response object
+    async list(projectId, filePath) {
+        let url = '';
+        if (filePath) {
+            url = (0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure);
+        }
+        else {
+            url = (0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_URL, { url: this.config.url, projectId }, this.config.insecure);
+        }
+        return this.callGet(url, `Failed to get asset list for ${projectId}, filePath ${filePath}.`);
+    }
+    /**
+     * Get a project asset
+     *
+     * @param projectId - Project Id
+     * @param filePath - Path to asset file
+     */
+    // TODO: map the response object
+    async getAsset(projectId, filePath) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_PATH_URL, { url: this.config.url, projectId, filePath }, this.config.insecure), `Failed to get asset for ${projectId}, filePath ${filePath}.`, undefined, {
+            responseType: 'blob',
+        });
+    }
+    /**
+     * List assets for a robot
+     *
+     * @param projectId
+     * @param callsign
+     * @param parent
+     * @param signedURL
+     */
+    async listRobotAssets(projectId, callsign, parent = '/', signedURL = false) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ROBOT_ASSET_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to get asset for ${projectId}, callsign ${callsign}.`, { parent, signedURL });
+    }
+    /**
+     * List assets for a flow
+     *
+     * @param projectId
+     * @param flowId
+     * @param flowInstance
+     * @param parent
+     * @param signedURL
+     */
+    async listFlowAssets(projectId, flowId, flowInstance, parent = '/', signedURL = false) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_FLOW_ASSET_PATH_URL, { url: this.config.url, projectId, flowId, flowInstance }, this.config.insecure), `Failed to get asset for ${projectId}, flow ${flowId}, flow instance ${flowInstance}.`, { parent, signedURL });
+    }
+    /**
+     * List assets for a mission
+     *
+     * @param projectId
+     * @param assetIdList
+     */
+    async listMissionAssets(projectId, assetIdList) {
+        const searchParams = new URLSearchParams();
+        assetIdList.forEach((assetId) => searchParams.append('assetID', assetId));
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_MISSION_ASSETS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset for ${projectId}, assetIdList ${assetIdList}.`, searchParams);
+    }
+    /**
+     * Get a single asset for a mission
+     *
+     * @param projectId
+     * @param assetId
+     */
+    async getMissionAsset(projectId, assetId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_MISSION_ASSET_PATH_URL, { url: this.config.url, projectId, assetId }, this.config.insecure), `Failed to get asset for ${projectId}, dataUUID ${assetId}.`, undefined);
+    }
+    /**
+     * Lists mapped assets
+     *
+     * @param projectId
+     * @param start Start date for the query (optional)
+     * @param end End date for the query (optional)
+     */
+    async listMappedAssets(projectId, start, end) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_MAPPED_ASSETS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to list mapped assets for ${projectId}.`, {
+            start: start?.toISOString() ?? '',
+            end: end?.toISOString() ?? '',
+        });
+    }
+    /**
+     * Set Robot Sync Definitions
+     * @param projectId
+     * @param callsign
+     * @param definition
+     */
+    setRobotSyncDefinitions(projectId, callsign, definition) {
+        const httpOptions = {
+            headers: {
+                'content-type': 'application/json',
+            },
+        };
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), definition, `Failed to update asset for ${projectId}, callsign ${callsign}.`, httpOptions);
+    }
+    /**
+     * Get Robot Sync Definitions
+     * @param projectId
+     * @param callsign
+     */
+    getRobotSyncDefinitions(projectId, callsign) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_ROBOTS_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, callsign }, this.config.insecure), `Failed to get asset for ${projectId}, callsign ${callsign}.`, undefined);
+    }
+    /**
+     * Set Profile Sync Definitions
+     * @param projectId
+     * @param profileId
+     * @param definition
+     */
+    setProfileSyncDefinitions(projectId, profileId, definition) {
+        const httpOptions = {
+            headers: {
+                'content-type': 'application/json',
+            },
+        };
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), definition, `Failed to update sync-definition for ${projectId}, callsign ${profileId}.`, httpOptions);
+    }
+    /**
+     * Get Profile Sync Definitions
+     * @param projectId
+     * @param profileId
+     */
+    getProfileSyncDefinition(projectId, profileId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_PROFILES_SYNC_DEFINITION_PATH_URL, { url: this.config.url, projectId, profileId }, this.config.insecure), `Failed to get sync-definition for ${projectId}, callsign ${profileId}.`, undefined);
+    }
+    /**
+     * Get Sync Integration Providers
+     * @param projectId
+     */
+    getSyncIntegrationProviders(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_INTEGRATION_PROVIDERS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset sync integration providers for ${projectId}.`);
+    }
+    /**
+     * Get Sync Integrations by Project
+     * @param projectId
+     */
+    getSyncIntegrations(projectId) {
+        return this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_INTEGRATIONS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), `Failed to get asset sync integrations for ${projectId}.`);
+    }
+    /**
+     * Create a new Sync Integration
+     * @param projectId
+     * @param integration
+     */
+    createSyncIntegration(projectId, integration) {
+        return this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_INTEGRATIONS_PATH_URL, { url: this.config.url, projectId }, this.config.insecure), integration, `Failed to create asset sync integration for ${projectId}.`);
+    }
+    /**
+     * Update a Sync Integration
+     * @param projectId
+     * @param integrationId
+     * @param integration
+     */
+    updateSyncIntegration(projectId, integrationId, integration) {
+        return this.callPut((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_INTEGRATION_PATH_URL, { url: this.config.url, projectId, integrationId }, this.config.insecure), integration, `Failed to update asset sync integrations for ${projectId}.`);
+    }
+    /**
+     * Delete a Sync Integration
+     * @param projectId
+     * @param integrationId
+     */
+    deleteSyncIntegration(projectId, integrationId) {
+        return this.callDelete((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_PROJECT_ASSET_INTEGRATION_PATH_URL, { url: this.config.url, projectId, integrationId }, this.config.insecure), `Failed to delete asset sync integrations for ${projectId}.`);
+    }
+}
+exports.AssetStorageService = AssetStorageService;

package/cjs/services/AuthService.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = void 0;
+const api_1 = require("../constants/api");
+const models_1 = require("../models");
+const BaseServiceAbstract_1 = require("./BaseServiceAbstract");
+const RocosLogger_1 = require("../logger/RocosLogger");
+const RocosStore_1 = require("../store/RocosStore");
+const formatServiceUrl_1 = require("../helpers/formatServiceUrl");
+const auth_1 = require("../constants/auth");
+class AuthService extends BaseServiceAbstract_1.BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.config = config;
+        this.config = config;
+        this.logger = RocosLogger_1.RocosLogger.getInstance(`AuthService(${this.config.url})`);
+        if (this.config.token) {
+            this.setToken(this.config.token);
+        }
+    }
+    getStatus() {
+        return true;
+    }
+    teardown() {
+        if (this.isTokenRefreshCheckerRunning()) {
+            this.logger.debug('Stopping token refresh checker');
+            this.stopTokenRefreshChecker();
+        }
+    }
+    getError(e) {
+        return new models_1.RocosError(e, models_1.errorCodes.AUTH_ERROR, e?.statusCode);
+    }
+    setToken(value, expiresIn) {
+        if (expiresIn !== undefined) {
+            this.logger.warn('setToken(value, expiresIn) is deprecated. Use setToken(value) instead');
+        }
+        if (typeof value === 'string') {
+            this.token = new models_1.Token(value);
+        }
+        else {
+            this.token = value;
+        }
+        this.config.token = this.token.value;
+        // output a message for token change
+        RocosStore_1.RocosStore.getChangeSubject().next({ type: 'token', url: this.config.url, data: this.token.value });
+    }
+    /**
+     * Clear token
+     */
+    clearToken() {
+        this.token = undefined;
+        this.config.token = undefined;
+    }
+    /**
+     * Get the authentication token for application Id and application Key.
+     */
+    async getAppToken() {
+        if (!('appId' in this.config) || !this.config.appId || !('appKey' in this.config) || !this.config.appKey) {
+            throw new models_1.RocosError('Can not get app token, missing appId and appKey', models_1.errorCodes.AUTH_ERROR);
+        }
+        const res = await this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_APPLICATION_AUTH_URL, { url: this.config.url }, this.config.insecure), {
+            applicationId: this.config.appId,
+            secret: this.config.appKey,
+        }, 'Failed to get users auth token.', { public: true });
+        return new models_1.Token(res.token);
+    }
+    /**
+     * Get new auth token for a user
+     * @desc This only works for user auth tokens, not appId auth tokens
+     */
+    async getNewUserToken() {
+        if (!('token' in this.config) || !this.config.token) {
+            throw new models_1.RocosError('Can not get new app token, missing token', models_1.errorCodes.AUTH_ERROR);
+        }
+        const token = new models_1.Token(this.config.token, this.config.refreshToken);
+        if (token?.isExpired()) {
+            throw new models_1.RocosError('Token expired', models_1.errorCodes.AUTH_ERROR);
+        }
+        if (!this.isTokenIssuedByApp(token)) {
+            this.logger.info('Token is not issued by app. Getting new token from DD token.');
+            return this.getNewUserTokenFromExternalToken();
+        }
+        return this.refreshToken(token);
+    }
+    /**
+     * Get new auth token for a user.
+     *
+     * Uses the OTP flow to exchange an external token for a user token.
+     *
+     * @desc This only works for user auth tokens, not appId auth tokens
+     */
+    async getNewUserTokenFromExternalToken() {
+        if (!('token' in this.config) || !this.config.token) {
+            throw new models_1.RocosError('Can not get new token, missing token', models_1.errorCodes.AUTH_ERROR);
+        }
+        const ddToken = new models_1.Token(this.config.token);
+        const { otp } = await this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_OTP_URL, { url: this.config.url }, this.config.insecure), undefined, 'Failed to get one time password.', { public: true, headers: { Authorization: ddToken.bearer } });
+        const { token, refreshToken } = await this.callPost((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_OTP_AUTH_URL, { url: this.config.url }, this.config.insecure), { otp }, 'Failed to get users auth token.', { public: true });
+        return new models_1.Token(token, refreshToken);
+    }
+    /**
+     * Get the authentication token
+     *
+     * This will return the current token if it is not expired, otherwise it will get a new token based on your config.
+     */
+    async getToken() {
+        if (this.token && this.isTokenValid(this.token)) {
+            if (this.token.isExpiredIn(15, 'minutes')) {
+                this.logger.info('Token expires within 15 minutes. Refreshing.');
+                const newToken = await this.refreshToken();
+                this.setToken(newToken);
+                return newToken;
+            }
+            return this.token;
+        }
+        let token;
+        try {
+            if ('appId' in this.config && 'appKey' in this.config) {
+                token = await this.getAppToken();
+            }
+            else if ('token' in this.config) {
+                token = await this.getNewUserToken();
+            }
+        }
+        catch (e) {
+            const message = 'Failed to get auth token.';
+            this.logger.error(message, e);
+            if (e instanceof Error) {
+                e.message = message;
+                throw new models_1.RocosError(e, models_1.errorCodes.AUTH_ERROR);
+            }
+            else {
+                throw new models_1.RocosError(message, models_1.errorCodes.AUTH_ERROR);
+            }
+        }
+        if (!token) {
+            const message = 'Failed to get auth token. Config invalid.';
+            this.logger.error(message);
+            throw new models_1.RocosError(message, models_1.errorCodes.AUTH_ERROR);
+        }
+        this.setToken(token);
+        return token;
+    }
+    /**
+     * Refresh the authentication token
+     *
+     * This only works for user auth tokens, not appId auth tokens.
+     *
+     * The new token is not automatically set as the current token. Use `setToken` to set the new token.
+     *
+     * @see setToken
+     * @param token the token to refresh. If not provided, the current token will be used.
+     */
+    async refreshToken(token) {
+        const tokenToRefresh = token ?? this.token;
+        if (!tokenToRefresh) {
+            throw new models_1.RocosError('No token to refresh', models_1.errorCodes.AUTH_ERROR);
+        }
+        const res = await this.callGet((0, formatServiceUrl_1.formatServiceUrl)(api_1.API_USER_TOKEN_URL, { url: this.config.url }, this.config.insecure), 'Failed to get users auth token.', undefined, { public: true, headers: { Authorization: tokenToRefresh.bearer } });
+        return new models_1.Token(res.token, res.refreshToken);
+    }
+    /** Refresh the token if it is expired or will expire in the next `minutes` minutes
+     *
+     * This only works for user auth tokens, not appId auth tokens.
+     *
+     * If you want to refresh the token regardless of the expiry time, use `refreshToken`.
+     *
+     * @param minutes the number of minutes before the token expires to refresh the token
+     * @see refreshToken
+     */
+    async refreshTokenIfExpired(minutes) {
+        if (this.token?.isExpiredIn(minutes, 'minutes')) {
+            this.logger.info('Token expires in 15 minutes. Refreshing.');
+            const newToken = await this.refreshToken();
+            this.setToken(newToken);
+        }
+    }
+    /** Start a 5-minute loop to check if the token needs to be refreshed
+     *
+     * This is useful when you are using GRPC services (i.e. telemetry) which does not automatically refresh the token.
+     * It is not required when using REST services as the token is refreshed automatically.
+     *
+     * The loop will stop when `stopTokenRefreshChecker` is called.
+     *
+     * @see stopTokenRefreshChecker
+     */
+    startTokenRefreshChecker() {
+        const maxInterval = 1000 * 60 * 10; // 10 minutes
+        const minInterval = 1000 * 60; // 1 minute
+        const threshold = 1000 * 60 * 15; // 15 minutes
+        if (this.isTokenRefreshCheckerRunning())
+            return;
+        if (!this.token)
+            throw new models_1.RocosError('No token to refresh', models_1.errorCodes.AUTH_ERROR);
+        if (!this.isTokenValid(this.token))
+            throw new models_1.RocosError('Token is not valid', models_1.errorCodes.AUTH_ERROR);
+        const loop = () => {
+            this.logger.debug('Checking scheduled token refresh');
+            this.refreshTokenIfExpired(15)
+                .catch((e) => {
+                this.logger.error('Failed to refresh token', e);
+            })
+                .finally(() => {
+                if (!this.token?.expires)
+                    return;
+                // schedule next check
+                const timeTillThreshold = this.token.expires.getTime() - Date.now() - threshold;
+                const interval = Math.max(minInterval, Math.min(maxInterval, timeTillThreshold));
+                this.tokenRefreshTimeoutId = setTimeout(() => loop(), interval);
+            });
+        };
+        loop();
+    }
+    /**
+     * Stop the token refresh checker
+     * @see startTokenRefreshChecker
+     */
+    stopTokenRefreshChecker() {
+        clearTimeout(this.tokenRefreshTimeoutId);
+        this.tokenRefreshTimeoutId = undefined;
+    }
+    /** Check if the token refresh checker is running
+     *
+     * @see startTokenRefreshChecker
+     * @see stopTokenRefreshChecker
+     * @returns true if the token refresh checker is running
+     */
+    isTokenRefreshCheckerRunning() {
+        return this.tokenRefreshTimeoutId !== undefined;
+    }
+    /** Checks if the token is valid for use with the API */
+    isTokenValid(token) {
+        return !token.isExpired() && this.isTokenIssuedByApp(token);
+    }
+    isTokenIssuedByApp(token) {
+        return token.issuer === auth_1.issuer;
+    }
+}
+exports.AuthService = AuthService;

package/cjs/services/AuthService.spec.js

@@ -0,0 +1,165 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_1 = require("../constants/auth");
+const AuthService_1 = require("./AuthService");
+const models_1 = require("../models");
+describe('authService', () => {
+    const baseDate = new Date(2021, 0, 1, 0, 0, 0, 0);
+    beforeEach(() => {
+        jest.useFakeTimers();
+        jest.setSystemTime(baseDate);
+    });
+    const expiredDate = new Date(baseDate.getTime() - 1000 * 60 * 5); // 5 minutes ago
+    const almostExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 5); // 5 minutes from now
+    const almostAlmostExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 25); // 35 minutes from now
+    const notExpiredDate = new Date(baseDate.getTime() + 1000 * 60 * 60 * 24); // 1 day from now
+    const getToken = (config) => {
+        const header = {
+            alg: 'HS256',
+            typ: 'JWT',
+        };
+        const payload = {
+            iat: Math.floor((config.iat ?? expiredDate).getTime() / 1000),
+            exp: Math.floor((config.exp ?? notExpiredDate).getTime() / 1000),
+            iss: config.iss ?? auth_1.issuer,
+            aud: config.aud ?? 'myaudience',
+            sub: config.sub ?? 'mysubject',
+        };
+        const encodedHeader = Buffer.from(JSON.stringify(header)).toString('base64');
+        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString('base64');
+        if (config.signature === false) {
+            return `${encodedHeader}.${encodedPayload}`;
+        }
+        return `${encodedHeader}.${encodedPayload}.signature`;
+    };
+    afterAll(() => jest.useRealTimers());
+    describe('getToken', () => {
+        it('should return the current token if it is not expired', async () => {
+            // Arrange
+            const token = getToken({ exp: notExpiredDate });
+            const service = new AuthService_1.AuthService({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            // Act
+            const newToken = await service.getToken();
+            // Assert
+            expect(newToken.value).toEqual(token);
+        });
+        it('should refresh the token if it is about to expire', async () => {
+            // Arrange
+            const token = getToken({ exp: almostExpiredDate });
+            const service = new AuthService_1.AuthService({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            const expected = getToken({ signature: false });
+            jest.spyOn(AuthService_1.AuthService.prototype, 'refreshToken').mockResolvedValue(new models_1.Token(expected));
+            // Act
+            const newToken = await service.getToken();
+            // Assert
+            expect(newToken.value).not.toEqual(token);
+            expect(newToken.value).toEqual(expected);
+            expect(AuthService_1.AuthService.prototype.refreshToken).toHaveBeenCalled();
+        });
+        it('should get a new token if there is no current token', async () => {
+            // Arrange
+            const token = getToken({ signature: false });
+            const service = new AuthService_1.AuthService({
+                url: 'http://localhost:0',
+                token,
+            });
+            service.clearToken();
+            const expected = getToken({ signature: false });
+            jest.spyOn(AuthService_1.AuthService.prototype, 'getNewUserToken').mockResolvedValue(new models_1.Token(expected));
+            // Act
+            const newToken = await service.getToken();
+            // Assert
+            expect(newToken.value).toEqual(expected);
+            expect(AuthService_1.AuthService.prototype.getNewUserToken).toHaveBeenCalled();
+        });
+    });
+    describe('tokenRefreshLoop', () => {
+        jest.spyOn(AuthService_1.AuthService.prototype, 'refreshTokenIfExpired').mockImplementation(() => {
+            // make sure the promise is resolved synchronously
+            return {
+                catch: () => {
+                    return {
+                        finally(onfinally) {
+                            onfinally?.();
+                            return Promise.resolve();
+                        },
+                    };
+                },
+            };
+        });
+        beforeEach(() => {
+            jest.clearAllTimers();
+            jest.clearAllMocks();
+            jest.useFakeTimers();
+            jest.setSystemTime(baseDate);
+        });
+        it('should check the token every 10 minutes', async () => {
+            // Arrange
+            const token = getToken({ exp: almostAlmostExpiredDate });
+            const service = new AuthService_1.AuthService({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            // Act
+            service.startTokenRefreshChecker();
+            expect(AuthService_1.AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
+            jest.advanceTimersByTime(1000 * 60 * 10); // 10 minutes
+            expect(AuthService_1.AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(2);
+            jest.advanceTimersByTime(1000 * 60); // 1 minutes - 24 minutes left
+            expect(AuthService_1.AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(3);
+            jest.advanceTimersByTime(1000 * 60 * 10); // 10 minutes - 14 minutes left
+            jest.runOnlyPendingTimers(); // wait for the next timer to run
+            service.stopTokenRefreshChecker();
+        });
+        it('should not run again when cancelled', () => {
+            // Arrange
+            const token = getToken({ exp: notExpiredDate });
+            const service = new AuthService_1.AuthService({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            // Act
+            service.startTokenRefreshChecker();
+            expect(AuthService_1.AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
+            service.stopTokenRefreshChecker();
+            jest.runOnlyPendingTimers();
+            expect(AuthService_1.AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
+        });
+        it('should correctly report running status', () => {
+            const token = getToken({ exp: notExpiredDate });
+            const service = new AuthService_1.AuthService({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
+            service.startTokenRefreshChecker();
+            expect(service.isTokenRefreshCheckerRunning()).toBe(true);
+            service.stopTokenRefreshChecker();
+            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
+        });
+        it('should correctly report running status', () => {
+            const token = getToken({ exp: notExpiredDate });
+            const service = new AuthService_1.AuthService({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
+            service.startTokenRefreshChecker();
+            expect(service.isTokenRefreshCheckerRunning()).toBe(true);
+            service.stopTokenRefreshChecker();
+            expect(service.isTokenRefreshCheckerRunning()).toBe(false);
+        });
+    });
+});