@dronedeploy/rocos-js-sdk 2.6.1 → 3.0.0-alpha.20

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

@@ -1,9 +1,7 @@
-import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
+import { IRocosSDKConfig, RocosError } from '../models';
+import { QueryParams } from '../helpers';
 import { Logger } from 'loglevel';
-import { RocosError } from '../models/RocosError';
-declare type QueryParams = Record<string, string | number | boolean> | URLSearchParams;
-declare type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
-declare type Payload = unknown;
+type ResponseType = 'json' | 'blob' | 'stream' | 'text' | 'raw';
 interface RequestConfig {
     /**
      * Additional headers to send with the request.
@@ -21,18 +19,18 @@ interface RequestConfig {
 export declare abstract class BaseServiceAbstract {
     protected config: IRocosSDKConfig;
     protected logger: Logger;
-    constructor(config: IRocosSDKConfig);
+    protected constructor(config: IRocosSDKConfig);
     protected abstract getError(e: Error): RocosError;
-    protected callPost<T = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<T>;
-    protected callPut<T = unknown>(url: string, payload: Payload, errorMessage: string, config?: RequestConfig): Promise<T>;
-    protected callDelete<T = unknown>(url: string, errorMessage: string, payload?: unknown): Promise<T>;
-    protected callGet<T = unknown>(url: string, errorMessage: string, params?: QueryParams, config?: RequestConfig): Promise<T>;
-    protected call<T = unknown>(url: string, method: 'GET' | 'POST' | 'PUT' | 'DELETE', options: {
+    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?: unknown;
+        payload?: Payload;
         params?: QueryParams;
-    }): Promise<T>;
+    }): Promise<Response>;
     private fetchOrThrow;
 }
 export {};

package/services/BaseServiceAbstract.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseServiceAbstract = void 0;
-const RocosError_1 = require("../models/RocosError");
-const RocosStore_1 = require("../store/RocosStore");
+import { RocosError } from '../models';
+import { getURLSearchParams } from '../helpers';
+import { RocosStore } from '../store/RocosStore';
 class HttpError extends Error {
     constructor(response) {
         super(response.statusText);
@@ -10,7 +8,7 @@ class HttpError extends Error {
         this.name = 'HttpError';
     }
 }
-class BaseServiceAbstract {
+export class BaseServiceAbstract {
     constructor(config) {
         this.config = config;
     }
@@ -27,23 +25,20 @@ class BaseServiceAbstract {
         return this.call(url, 'GET', { errorMessage, params, config });
     }
     async call(url, method, options) {
-        var _a;
         const { errorMessage, config, payload, params } = options;
         try {
-            // change all params to string
-            const stringParams = Object.entries(params || {}).reduce((acc, [key, value]) => {
-                acc[key] = value.toString();
-                return acc;
-            }, {});
-            const formattedUrl = params ? `${url}?${new URLSearchParams(stringParams)}` : url;
+            const formattedUrl = params ? `${url}?${getURLSearchParams(params)}` : url;
             const defaultHeaders = {};
-            if (!(config === null || config === void 0 ? void 0 : config.public)) {
-                const token = await RocosStore_1.RocosStore.getSDKInstance(this.config).getAuthService().getToken();
-                defaultHeaders.Authorization = `Bearer ${token.value}`;
+            if (!config?.public) {
+                const token = await RocosStore.getSDKInstance(this.config).getAuthService().getToken();
+                defaultHeaders.Authorization = token.bearer;
             }
             const requestConfig = {
                 method,
-                headers: Object.assign(Object.assign({}, defaultHeaders), config === null || config === void 0 ? void 0 : config.headers),
+                headers: {
+                    ...defaultHeaders,
+                    ...config?.headers,
+                },
             };
             // must check if FormData exists for node support
             if (typeof FormData !== 'undefined' && payload instanceof FormData) {
@@ -51,19 +46,19 @@ class BaseServiceAbstract {
             }
             else if (payload) {
                 requestConfig.body = JSON.stringify(payload);
-                requestConfig.headers = Object.assign(Object.assign({}, requestConfig.headers), { 'Content-Type': 'application/json' });
+                requestConfig.headers = { ...requestConfig.headers, 'Content-Type': 'application/json' };
             }
-            return this.fetchOrThrow(formattedUrl, requestConfig, config === null || config === void 0 ? void 0 : config.responseType);
+            return this.fetchOrThrow(formattedUrl, requestConfig, config?.responseType);
         }
         catch (e) {
             const message = errorMessage;
             this.logger.error(message, e);
-            let httpError = new RocosError_1.RocosError(message);
+            let httpError = new RocosError(message);
             if (e instanceof HttpError) {
                 httpError = this.getError(e);
-                httpError.statusCode = (_a = e === null || e === void 0 ? void 0 : e.response) === null || _a === void 0 ? void 0 : _a.status;
+                httpError.statusCode = e?.response?.status;
             }
-            RocosStore_1.RocosStore.getChangeSubject().next({ type: 'http-error', url: this.config.url, data: httpError });
+            RocosStore.getChangeSubject().next({ type: 'http-error', url: this.config.url, data: httpError });
             throw httpError;
         }
     }
@@ -87,7 +82,7 @@ class BaseServiceAbstract {
             case 'json':
             default: {
                 const textRes = await res.text();
-                if (!(textRes === null || textRes === void 0 ? void 0 : textRes.trim()))
+                if (!textRes?.trim())
                     return undefined;
                 try {
                     return JSON.parse(textRes);
@@ -100,4 +95,3 @@ class BaseServiceAbstract {
         }
     }
 }
-exports.BaseServiceAbstract = BaseServiceAbstract;

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

@@ -1,22 +1,42 @@
-import { ICallerInvokeParams, ICallerParams } from '../models/params/ICallerParams';
-import { Observable, Subject } from 'rxjs';
-import { IBaseService } from '../models/IBaseService';
-import { ICallerStream } from '../models/stream/ICallerStream';
-import { IRocosCallerMessage } from '../models/message/IRocosCallerMessage';
-import { IRocosSDKConfig } from '../models/IRocosSDKConfig';
-import { IStreamConfig } from '../models/IStreamConfig';
-import { ISubscriberStatus } from '../models/ISubscriberStatus';
-import { SubscriberStatusEnum } from '../models/SubscriberStatusEnum';
-export declare class CallerService implements IBaseService, ISubscriberStatus {
-    private config;
-    private logger;
-    private status;
-    status$: Subject<SubscriberStatusEnum>;
+import { ICallerCallParams, ICallerInvokeParams, ICallerParams, ICallerStream, IRocosCallerMessage, IRocosCallerMessageResponseAck, IRocosCallerMessageResponseResult, IRocosCallerMessageResponseReturn, IRocosSDKConfig, IStreamConfig } from '../models';
+import { Observable } from 'rxjs';
+import { BaseStreamService } from './BaseStreamService';
+export declare class CallerService extends BaseStreamService<ICallerStream> {
     constructor(config: IRocosSDKConfig);
-    getStatus(): boolean;
     invokeRequest(params: ICallerInvokeParams): Observable<IRocosCallerMessage>;
     cancelRequest(params: ICallerParams): Observable<IRocosCallerMessage>;
-    private createStream;
-    private initStream;
+    /** Call a service and return the response(s).
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * @see invokeRequest
+     * @see call
+     */
+    callRaw(params: ICallerCallParams): {
+        return$: Observable<IRocosCallerMessageResponseReturn>;
+        result$: Observable<IRocosCallerMessageResponseResult>;
+        ack$: Observable<IRocosCallerMessageResponseAck>;
+    };
+    /** Call a service and return the response(s) as UTF-8 encoded JSON.
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * Equivalent to calling `callRaw` and then parsing the return payload as UTF-8 encoded JSON.
+     *
+     * @see callRaw
+     * @see invokeRequest
+     */
+    call<T = unknown>(params: ICallerCallParams): {
+        return$: Observable<T>;
+        result$: Observable<IRocosCallerMessageResponseResult>;
+        ack$: Observable<IRocosCallerMessageResponseAck>;
+    };
+    protected createStream(): Promise<ICallerStream>;
     protected getStream(config: IStreamConfig): ICallerStream;
 }

package/services/CallerService.js

@@ -1,26 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CallerService = void 0;
-const rxjs_1 = require("rxjs");
-const CallerStream_1 = require("../api/streams/caller/CallerStream");
-const identifier_1 = require("../constants/identifier");
-const RocosLogger_1 = require("../logger/RocosLogger");
-const RocosStore_1 = require("../store/RocosStore");
-const StreamRegister_1 = require("../api/StreamRegister");
-const SubscriberStatusEnum_1 = require("../models/SubscriberStatusEnum");
-const operators_1 = require("rxjs/operators");
-class CallerService {
+import { ResultStatus, RocosResponseLevel, } from '../models';
+import { Subject, map, mergeMap, take, takeUntil } from 'rxjs';
+import { filter, finalize } from 'rxjs/operators';
+import { getResponses, handleChunkedMessages } from '../helpers/callerMessageHelpers';
+import { BaseStreamService } from './BaseStreamService';
+import { CallerStream } from '../api/streams/caller/CallerStream';
+import { IDENTIFIER_NAME_CALLER } from '../constants/identifier';
+import { v4 } from 'uuid';
+export class CallerService extends BaseStreamService {
     constructor(config) {
-        this.status = false;
-        this.status$ = new rxjs_1.Subject();
-        this.config = config;
-        this.logger = RocosLogger_1.RocosLogger.getInstance(`CallerService(${this.config.url})`);
-    }
-    getStatus() {
-        return this.status;
+        super('CallerService', config);
     }
     invokeRequest(params) {
-        const subject = new rxjs_1.Subject();
+        const subject = new Subject();
         let subscription;
         this.createStream()
             .then((stream) => {
@@ -30,12 +21,12 @@ class CallerService {
             this.logger.info('invokeRequest error', e);
             subject.error(e);
         });
-        return subject.asObservable().pipe(operators_1.finalize(() => {
-            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+        return subject.asObservable().pipe(finalize(() => {
+            subscription?.unsubscribe();
         }));
     }
     cancelRequest(params) {
-        const subject = new rxjs_1.Subject();
+        const subject = new Subject();
         let subscription;
         this.createStream()
             .then((stream) => {
@@ -45,52 +36,82 @@ class CallerService {
             this.logger.info('invokeRequest error', e);
             subject.error(e);
         });
-        return subject.asObservable().pipe(operators_1.finalize(() => {
-            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();
+        return subject.asObservable().pipe(finalize(() => {
+            subscription?.unsubscribe();
         }));
     }
-    async createStream() {
-        const scope = 'default';
-        const identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_CALLER, scope);
-        const streamRegister = StreamRegister_1.StreamRegister.getInstance();
-        let stream = streamRegister.getStream(identifier);
-        if (!stream) {
-            stream = this.getStream({
-                url: this.config.url,
-                token: this.config.token,
-                scope,
-                options: this.config.options,
-                port: this.config.port,
-                insecure: this.config.insecure,
-            });
-            stream.statusStream$.subscribe((msg) => {
-                this.status = msg === SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED || msg === SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
-                this.status$.next(msg);
-            });
-            // don't wait for these promises, they can be init after startup
-            await streamRegister.addStream(stream);
-            await this.initStream(stream);
-        }
-        return stream;
+    /** Call a service and return the response(s).
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * @see invokeRequest
+     * @see call
+     */
+    callRaw(params) {
+        const [component, ...topicItems] = params.source.replace(/^\/+/, '').split('/');
+        const topic = topicItems.join('/');
+        const payloadString = JSON.stringify(params.payload ?? {});
+        const source$ = this.invokeRequest({
+            uid: params.options?.uid ?? v4(),
+            projectId: params.projectId,
+            callsign: params.callsign,
+            subSystem: '',
+            component,
+            topic,
+            responseLevelNumber: RocosResponseLevel.ALL,
+            payload: payloadString,
+            query: params.options?.query,
+        }).pipe(mergeMap(getResponses), handleChunkedMessages());
+        const result$ = source$.pipe(filter((x) => x.result !== undefined), map((x) => x.result), take(1));
+        const resultNotifier$ = result$.pipe(map((x) => {
+            if (x.status !== ResultStatus.COMPLETE_SUCCESS)
+                throw x;
+            return x;
+        }));
+        const return$ = source$.pipe(filter((x) => x.return !== undefined), map((x) => x.return), takeUntil(resultNotifier$));
+        const ack$ = source$.pipe(filter((x) => x.ack !== undefined), map((x) => x.ack), takeUntil(resultNotifier$));
+        return {
+            return$,
+            result$,
+            ack$,
+        };
     }
-    async initStream(stream) {
-        // an async callback to set the stream token in case one was not set at startup
-        if (!this.config.token) {
-            try {
-                const authService = RocosStore_1.RocosStore.getSDKInstance(this.config).getAuthService();
-                const token = await authService.getToken();
-                if (token === null || token === void 0 ? void 0 : token.value) {
-                    this.config.token = token === null || token === void 0 ? void 0 : token.value;
-                    stream.setToken(this.config.token);
-                }
-            }
-            catch (e) {
-                this.logger.info('Can not retrieve auth token', e);
-            }
-        }
+    /** Call a service and return the response(s) as UTF-8 encoded JSON.
+     *
+     * It will complete once a result message is received with a `COMPLETE_SUCCESS` status,
+     * or throw an error if the status is not `COMPLETE_SUCCESS`.
+     *
+     * This is a high level method that wraps the lower level `invokeRequest` method.
+     *
+     * Equivalent to calling `callRaw` and then parsing the return payload as UTF-8 encoded JSON.
+     *
+     * @see callRaw
+     * @see invokeRequest
+     */
+    call(params) {
+        const stream = this.callRaw(params);
+        return {
+            ...stream,
+            return$: stream.return$.pipe(map((x) => {
+                const decoded = new TextDecoder().decode(x.payload);
+                return JSON.parse(decoded);
+            })),
+        };
+    }
+    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_1.CallerStream(config);
+        return new CallerStream(config);
     }
 }
-exports.CallerService = CallerService;

package/services/CallerService.spec.d.ts

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