@dronedeploy/rocos-js-sdk 0.0.1 → 3.0.0-alpha.19

package/services/AuthService.js

@@ -0,0 +1,235 @@
+import { API_APPLICATION_AUTH_URL, API_OTP_AUTH_URL, API_OTP_URL, API_USER_TOKEN_URL } from '../constants/api';
+import { RocosError, Token, errorCodes } from '../models';
+import { BaseServiceAbstract } from './BaseServiceAbstract';
+import { RocosLogger } from '../logger/RocosLogger';
+import { RocosStore } from '../store/RocosStore';
+import { formatServiceUrl } from '../helpers/formatServiceUrl';
+import { issuer } from '../constants/auth';
+export class AuthService extends BaseServiceAbstract {
+    constructor(config) {
+        super(config);
+        this.config = config;
+        this.config = config;
+        this.logger = 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 RocosError(e, 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 Token(value);
+        }
+        else {
+            this.token = value;
+        }
+        this.config.token = this.token.value;
+        // output a message for token change
+        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 RocosError('Can not get app token, missing appId and appKey', errorCodes.AUTH_ERROR);
+        }
+        const res = await this.callPost(formatServiceUrl(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 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 RocosError('Can not get new app token, missing token', errorCodes.AUTH_ERROR);
+        }
+        const token = new Token(this.config.token, this.config.refreshToken);
+        if (token?.isExpired()) {
+            throw new RocosError('Token expired', 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 RocosError('Can not get new token, missing token', errorCodes.AUTH_ERROR);
+        }
+        const ddToken = new Token(this.config.token);
+        const { otp } = await this.callPost(formatServiceUrl(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(formatServiceUrl(API_OTP_AUTH_URL, { url: this.config.url }, this.config.insecure), { otp }, 'Failed to get users auth token.', { public: true });
+        return new 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 RocosError(e, errorCodes.AUTH_ERROR);
+            }
+            else {
+                throw new RocosError(message, errorCodes.AUTH_ERROR);
+            }
+        }
+        if (!token) {
+            const message = 'Failed to get auth token. Config invalid.';
+            this.logger.error(message);
+            throw new RocosError(message, 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 RocosError('No token to refresh', errorCodes.AUTH_ERROR);
+        }
+        const res = await this.callGet(formatServiceUrl(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 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 RocosError('No token to refresh', errorCodes.AUTH_ERROR);
+        if (!this.isTokenValid(this.token))
+            throw new RocosError('Token is not valid', 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 === issuer;
+    }
+}

package/services/AuthService.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/services/AuthService.spec.js

@@ -0,0 +1,163 @@
+import { issuer } from '../constants/auth';
+import { AuthService } from './AuthService';
+import { Token } from '../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 ?? 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({
+                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({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            const expected = getToken({ signature: false });
+            jest.spyOn(AuthService.prototype, 'refreshToken').mockResolvedValue(new Token(expected));
+            // Act
+            const newToken = await service.getToken();
+            // Assert
+            expect(newToken.value).not.toEqual(token);
+            expect(newToken.value).toEqual(expected);
+            expect(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({
+                url: 'http://localhost:0',
+                token,
+            });
+            service.clearToken();
+            const expected = getToken({ signature: false });
+            jest.spyOn(AuthService.prototype, 'getNewUserToken').mockResolvedValue(new Token(expected));
+            // Act
+            const newToken = await service.getToken();
+            // Assert
+            expect(newToken.value).toEqual(expected);
+            expect(AuthService.prototype.getNewUserToken).toHaveBeenCalled();
+        });
+    });
+    describe('tokenRefreshLoop', () => {
+        jest.spyOn(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({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            // Act
+            service.startTokenRefreshChecker();
+            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
+            jest.advanceTimersByTime(1000 * 60 * 10); // 10 minutes
+            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(2);
+            jest.advanceTimersByTime(1000 * 60); // 1 minutes - 24 minutes left
+            expect(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({
+                token,
+                url: 'http://localhost:0',
+            });
+            service.setToken(token);
+            // Act
+            service.startTokenRefreshChecker();
+            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
+            service.stopTokenRefreshChecker();
+            jest.runOnlyPendingTimers();
+            expect(AuthService.prototype.refreshTokenIfExpired).toHaveBeenCalledTimes(1);
+        });
+        it('should correctly report running status', () => {
+            const token = getToken({ exp: notExpiredDate });
+            const service = new 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({
+                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);
+        });
+    });
+});

package/services/BaseServiceAbstract.d.ts

@@ -0,0 +1,36 @@
+import { IRocosSDKConfig, RocosError } from '../models';
+import { QueryParams } from '../helpers';
+import { Logger } from 'loglevel';
+type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
+interface RequestConfig {
+    /**
+     * Additional headers to send with the request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * If true, the request will be sent without authentication.
+     */
+    public?: boolean;
+    /**
+     * The response type to use for the request.
+     */
+    responseType?: ResponseType;
+}
+export declare abstract class BaseServiceAbstract {
+    protected config: IRocosSDKConfig;
+    protected logger: Logger;
+    protected constructor(config: IRocosSDKConfig);
+    protected abstract getError(e: Error): RocosError;
+    protected callPost<Response = unknown, Payload = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<Response>;
+    protected callPut<Response = unknown, Payload = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<Response>;
+    protected callDelete<Response = unknown, Payload = unknown>(url: string, errorMessage: string, payload?: Payload): Promise<Response>;
+    protected callGet<Response = unknown>(url: string, errorMessage: string, params?: QueryParams, config?: RequestConfig): Promise<Response>;
+    protected call<Response = unknown, Payload = unknown>(url: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE', options: {
+        errorMessage: string;
+        config?: RequestConfig;
+        payload?: Payload;
+        params?: QueryParams;
+    }): Promise<Response>;
+    private fetchOrThrow;
+}
+export {};

package/services/BaseServiceAbstract.js

@@ -0,0 +1,97 @@
+import { RocosError } from '../models';
+import { getURLSearchParams } from '../helpers';
+import { RocosStore } from '../store/RocosStore';
+class HttpError extends Error {
+    constructor(response) {
+        super(response.statusText);
+        this.response = response;
+        this.name = 'HttpError';
+    }
+}
+export class BaseServiceAbstract {
+    constructor(config) {
+        this.config = config;
+    }
+    async callPost(url, payload, errorMessage, config) {
+        return this.call(url, 'POST', { errorMessage, payload, config });
+    }
+    async callPut(url, payload, errorMessage, config) {
+        return this.call(url, 'PUT', { errorMessage, payload, config });
+    }
+    async callDelete(url, errorMessage, payload) {
+        return this.call(url, 'DELETE', { errorMessage, payload });
+    }
+    async callGet(url, errorMessage, params, config) {
+        return this.call(url, 'GET', { errorMessage, params, config });
+    }
+    async call(url, method, options) {
+        const { errorMessage, config, payload, params } = options;
+        try {
+            const formattedUrl = params ? `${url}?${getURLSearchParams(params)}` : url;
+            const defaultHeaders = {};
+            if (!config?.public) {
+                const token = await RocosStore.getSDKInstance(this.config).getAuthService().getToken();
+                defaultHeaders.Authorization = token.bearer;
+            }
+            const requestConfig = {
+                method,
+                headers: {
+                    ...defaultHeaders,
+                    ...config?.headers,
+                },
+            };
+            // must check if FormData exists for node support
+            if (typeof FormData !== 'undefined' && payload instanceof FormData) {
+                requestConfig.body = payload;
+            }
+            else if (payload) {
+                requestConfig.body = JSON.stringify(payload);
+                requestConfig.headers = { ...requestConfig.headers, 'Content-Type': 'application/json' };
+            }
+            return this.fetchOrThrow(formattedUrl, requestConfig, config?.responseType);
+        }
+        catch (e) {
+            const message = errorMessage;
+            this.logger.error(message, e);
+            let httpError = new RocosError(message);
+            if (e instanceof HttpError) {
+                httpError = this.getError(e);
+                httpError.statusCode = e?.response?.status;
+            }
+            RocosStore.getChangeSubject().next({ type: 'http-error', url: this.config.url, data: httpError });
+            throw httpError;
+        }
+    }
+    async fetchOrThrow(url, config, responseType) {
+        this.logger.debug('Fetching', { url, config });
+        const res = await fetch(url, config);
+        if (!res.ok) {
+            const payload = await res.text();
+            this.logger.warn('Failed HTTP Response', { status: res.statusText, payload, response: res });
+            throw new HttpError(res);
+        }
+        switch (responseType) {
+            case 'raw':
+                return res;
+            case 'stream':
+                return res.body;
+            case 'blob':
+                return res.blob();
+            case 'text':
+                return res.text();
+            case 'json':
+            default: {
+                const textRes = await res.text();
+                if (!textRes?.trim())
+                    return undefined;
+                try {
+                    return JSON.parse(textRes);
+                }
+                catch (e) {
+                    this.logger.error('Failed to parse JSON from response', { textRes });
+                    return textRes;
+                }
+            }
+        }
+    }
+}

package/services/BaseStreamService.d.ts

@@ -0,0 +1,18 @@
+import { IBaseService, IBaseStream, IRocosSDKConfig, IStreamConfig, SubscriberStatusEnum } from '../models';
+import { ISubscriberStatus } from '../models/ISubscriberStatus';
+import { Logger } from 'loglevel';
+import { Subject } from 'rxjs';
+export declare abstract class BaseStreamService<T extends IBaseStream, C extends IStreamConfig = IStreamConfig> implements IBaseService, ISubscriberStatus {
+    protected config: IRocosSDKConfig;
+    protected logger: Logger;
+    protected status: boolean;
+    status$: Subject<SubscriberStatusEnum>;
+    protected constructor(name: string, config: IRocosSDKConfig);
+    getStatus(): boolean;
+    protected initStream(stream: T): Promise<void>;
+    protected createStreamFromConfig(identifier: string, config: C): Promise<{
+        stream: T;
+        isNew: boolean;
+    }>;
+    protected abstract getStream(config: C): T;
+}

package/services/BaseStreamService.js

@@ -0,0 +1,47 @@
+import { SubscriberStatusEnum, Token } from '../models';
+import { RocosLogger } from '../logger/RocosLogger';
+import { RocosStore } from '../store/RocosStore';
+import { StreamRegister } from '../api/StreamRegister';
+import { Subject } from 'rxjs';
+export class BaseStreamService {
+    constructor(name, config) {
+        this.status = false;
+        this.status$ = new Subject();
+        this.config = config;
+        this.logger = RocosLogger.getInstance(`${name}(${this.config.url})`);
+    }
+    getStatus() {
+        return this.status;
+    }
+    async initStream(stream) {
+        const authService = RocosStore.getSDKInstance(this.config).getAuthService();
+        if (!this.config.token || !authService.isTokenValid(new Token(this.config.token))) {
+            try {
+                const token = await authService.getToken();
+                stream.setToken(token.value);
+            }
+            catch (e) {
+                this.logger.error('Can not retrieve auth token', e);
+                throw new Error('Can not retrieve auth token');
+            }
+        }
+        authService.startTokenRefreshChecker();
+    }
+    async createStreamFromConfig(identifier, config) {
+        const identifierWithScope = StreamRegister.getIdentifier(identifier, config.scope);
+        const streamRegister = StreamRegister.getInstance();
+        let stream = streamRegister.getStream(identifierWithScope);
+        let isNew = false;
+        if (!stream) {
+            isNew = true;
+            stream = this.getStream(config);
+            stream.statusStream$.subscribe((msg) => {
+                this.status = msg === SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum.ALIVE;
+                this.status$.next(msg);
+            });
+            await streamRegister.addStream(stream);
+            await this.initStream(stream);
+        }
+        return { stream, isNew };
+    }
+}

package/services/CallerService.d.ts

@@ -0,0 +1,10 @@
+import { ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IRocosSDKConfig, IStreamConfig } from '../models';
+import { Observable } from 'rxjs';
+import { BaseStreamService } from './BaseStreamService';
+export declare class CallerService extends BaseStreamService<ICallerStream> {
+    constructor(config: IRocosSDKConfig);
+    invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
+    cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
+    protected createStream(): Promise<ICallerStream>;
+    protected getStream(config: IStreamConfig): ICallerStream;
+}

package/services/CallerService.js

@@ -0,0 +1,53 @@
+import { Subject } from 'rxjs';
+import { BaseStreamService } from './BaseStreamService';
+import { CallerStream } from '../api/streams/caller/CallerStream';
+import { IDENTIFIER_NAME_CALLER } from '../constants/identifier';
+import { finalize } from 'rxjs/operators';
+export class CallerService extends BaseStreamService {
+    constructor(config) {
+        super('CallerService', config);
+    }
+    invokeRequest(params) {
+        const subject = new Subject();
+        let subscription;
+        this.createStream()
+            .then((stream) => {
+            subscription = stream.invokeRequest(params).subscribe(subject);
+        })
+            .catch((e) => {
+            this.logger.info('invokeRequest error', e);
+            subject.error(e);
+        });
+        return subject.asObservable().pipe(finalize(() => {
+            subscription?.unsubscribe();
+        }));
+    }
+    cancelRequest(params) {
+        const subject = new Subject();
+        let subscription;
+        this.createStream()
+            .then((stream) => {
+            subscription = stream.cancelRequest(params).subscribe(subject);
+        })
+            .catch((e) => {
+            this.logger.info('invokeRequest error', e);
+            subject.error(e);
+        });
+        return subject.asObservable().pipe(finalize(() => {
+            subscription?.unsubscribe();
+        }));
+    }
+    async createStream() {
+        return (await this.createStreamFromConfig(IDENTIFIER_NAME_CALLER, {
+            url: this.config.url,
+            token: this.config.token,
+            scope: 'default',
+            options: this.config.options,
+            port: this.config.port,
+            insecure: this.config.insecure,
+        })).stream;
+    }
+    getStream(config) {
+        return new CallerStream(config);
+    }
+}

package/services/CallerServiceNode.d.ts

@@ -0,0 +1,6 @@
+import { CallerService } from './CallerService';
+import { ICallerStream } from '../models/stream/ICallerStream';
+import { IStreamConfig } from '../models/IStreamConfig';
+export declare class CallerServiceNode extends CallerService {
+    protected getStream(config: IStreamConfig): ICallerStream;
+}