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

package/api/streams/telemetry/TelemetryStreamAbstract.d.ts

@@ -1,12 +1,8 @@
 import { BehaviorSubject, Subject } from 'rxjs';
-import { ITelemetryParams } from '../../../models/params/ITelemetryParams';
-import { TelemetryAckStatusMap, TelemetryQueryRequest, TelemetryRequest } from '../../../grpc/teletubby/teletubby_pb';
-import { IRocosTelemetryMessage } from '../../../models/message/IRocosTelemetryMessage';
-import { ITelemetryStream } from '../../../models/stream/ITelemetryStream';
-import { ITelemetryStreamConfig } from '../../../models/ITelemetryStreamConfig';
+import { IRocosTelemetryMessage, ITelemetryParams, ITelemetryStream, ITelemetryStreamConfig, SubscriberStatusEnum } from '../../../models';
+import { TelemetryAckStatus, TelemetryMessage, TelemetryQueryRequest, TelemetryRequest, TelemetryStreamMessage } from '../../../grpc/teletubby_pb';
 import { Logger } from 'loglevel';
 import { StreamHeartbeat } from '../../atoms/StreamHeartbeat';
-import { SubscriberStatusEnum } from '../../../models/SubscriberStatusEnum';
 export declare abstract class TelemetryStreamAbstract implements ITelemetryStream {
     messageStream$: Subject<IRocosTelemetryMessage>;
     identifier: string;
@@ -22,7 +18,7 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     protected subscriberStatus: SubscriberStatusEnum;
     private checkerStartedAt?;
     private lastRobotMessageReceived?;
-    private messagesTimer;
+    private messagesTimer?;
     private lastMessageReceived?;
     private retryTimes;
     private options;
@@ -37,16 +33,17 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     protected abstract registerReceiver(): () => void;
     protected abstract requestTelemetryQuery(req: TelemetryQueryRequest): Promise<void>;
     protected abstract requestTelemetry(req: TelemetryRequest): Promise<void>;
-    protected abstract sendAcknowledgmentInternal(uid: string, status: TelemetryAckStatusMap[keyof TelemetryAckStatusMap], noRetry: boolean): boolean;
+    protected abstract sendAcknowledgmentInternal(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
     protected abstract sendHeartbeat(): void;
     setToken(token: string): void;
     init(): void;
     stopStream(): void;
     addSubscription(params: ITelemetryParams): void;
     removeSubscription(params: ITelemetryParams, terminateReceiverGroup?: boolean): Promise<void>;
-    sendAcknowledgment(uid: string, status: TelemetryAckStatusMap[keyof TelemetryAckStatusMap], noRetry: boolean): boolean;
+    sendAcknowledgment(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
     private getSubscriptions;
-    protected onData(message: IRocosTelemetryMessage): void;
+    protected onData(message: TelemetryStreamMessage, isStream: true): void;
+    protected onData(message: TelemetryMessage, isStream: false): void;
     private takeTelemetryAction;
     protected listenMessagesAndRenew(): void;
     private addTerminateToAction;
@@ -58,5 +55,5 @@ export declare abstract class TelemetryStreamAbstract implements ITelemetryStrea
     private isFoundCallsign;
     private isFoundSource;
     private isRegisteredMessage;
-    private updateReceviedDataStatsWithMessage;
+    private updateReceivedDataStatsWithMessage;
 }

package/api/streams/telemetry/TelemetryStreamAbstract.js

@@ -1,64 +1,40 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TelemetryStreamAbstract = void 0;
-const rxjs_1 = require("rxjs");
-const grpc_1 = require("../../../constants/grpc");
-const teletubby_pb_1 = require("../../../grpc/teletubby/teletubby_pb");
-const CallsignsLookup_1 = require("../../../models/callsigns/CallsignsLookup");
-const CallsignsEnums_1 = require("../../../models/callsigns/CallsignsEnums");
-const identifier_1 = require("../../../constants/identifier");
-const RocosStore_1 = require("../../../store/RocosStore");
-const RocosTelemetryMessage_1 = require("../../../models/message/RocosTelemetryMessage");
-const StreamHeartbeat_1 = require("../../atoms/StreamHeartbeat");
-const StreamOptions_1 = require("../../../models/StreamOptions");
-const StreamRegister_1 = require("../../StreamRegister");
-const SubscriberStatusEnum_1 = require("../../../models/SubscriberStatusEnum");
-const arrayUnique_1 = require("../../../helpers/arrayUnique");
-const operators_1 = require("rxjs/operators");
-const getSubscriptionsDifference_1 = require("../../../helpers/getSubscriptionsDifference");
-class TelemetryStreamAbstract {
+import { BehaviorSubject, Subject } from 'rxjs';
+import { CallsignsLookup, CallsignsLookupType, RocosTelemetryMessage, StreamOptions, SubscriberStatusEnum, } from '../../../models';
+import { GRPC_SOURCE_NOOP, GRPC_SOURCE_SUBSCRIBED } from '../../../constants/grpc';
+import { QueryOrPredicate, TelemetryAckStatus, TelemetryQueryRequest, TelemetryRequest, UnsubscribeOperation, } from '../../../grpc/teletubby_pb';
+import { IDENTIFIER_NAME_TELEMETRY } from '../../../constants/identifier';
+import { RocosStore } from '../../../store/RocosStore';
+import { StreamHeartbeat } from '../../atoms/StreamHeartbeat';
+import { StreamRegister } from '../../StreamRegister';
+import { arrayUnique } from '../../../helpers/arrayUnique';
+import { filter } from 'rxjs/operators';
+import { getSubscriptionsDifference } from '../../../helpers/getSubscriptionsDifference';
+export class TelemetryStreamAbstract {
     constructor(config) {
         // /////////////////
         // Subscriber Check
         this.timerIntervalInSec = 1;
-        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
         this.retryTimes = 0;
         this.receivedMessagesCount = 0;
         // send heartbeat timeout is set to 5 seconds 5000
         this.sendHeartbeatTime = 5000;
         this.receivedDataStats = {};
         this.subscriptions = new Map();
-        this.identifier = StreamRegister_1.StreamRegister.getIdentifier(identifier_1.IDENTIFIER_NAME_TELEMETRY, config.scope);
+        this.identifier = StreamRegister.getIdentifier(IDENTIFIER_NAME_TELEMETRY, config.scope);
         this.projectId = config.projectId;
         this.callsignsLookup = config.callsignsLookup;
         this.token = config.token;
         this.scope = config.scope;
         this.url = config.url;
         // make sure sources are unique for later comparison
-        this.sources = arrayUnique_1.arrayUnique(config.sources);
-        this.options = StreamOptions_1.StreamOptions.fromModel(config.options);
-        this.messageStream$ = new rxjs_1.Subject();
-        this.statusStream$ = new rxjs_1.BehaviorSubject(SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED);
-        this.heartbeat = new StreamHeartbeat_1.StreamHeartbeat(this.identifier);
-        // autoResubscribeEnabled = false
-        // // Resubscribe when received messages above this limit.
-        // autoResubscribeMessageLimit = 100
-        // // In seconds
-        // autoResubscribeMinimumTime = 10
-        // messageTimeoutInSec = 10
-        // TODO: implement receive heartbeat handler
-        // this.heartbeat
-        //   .setHealthTimeout(6000)
-        //   .setHealthMaxTimeout(10)
-        //   .setHealthMaxMisses(5)
-        //   .setHealthCheckStatusCallback(async (status) => {
-        //     console.log('heartbeat status', status)
-        //   })
-        //   .setHealthCheckErrorCallback(async () => {
-        //     console.log('heartbeat error')
-        //   })
-        RocosStore_1.RocosStore.getChangeSubject()
-            .pipe(operators_1.filter((message) => {
+        this.sources = arrayUnique(config.sources);
+        this.options = StreamOptions.fromModel(config.options);
+        this.messageStream$ = new Subject();
+        this.statusStream$ = new BehaviorSubject(SubscriberStatusEnum.STOPPED);
+        this.heartbeat = new StreamHeartbeat(this.identifier);
+        RocosStore.getChangeSubject()
+            .pipe(filter((message) => {
             return message.type === 'token' && message.url === this.url;
         }))
             .subscribe((msg) => {
@@ -74,13 +50,12 @@ class TelemetryStreamAbstract {
         this.registerReceiver();
     }
     stopStream() {
-        var _a;
-        (_a = this.heartbeat) === null || _a === void 0 ? void 0 : _a.stop();
+        this.heartbeat?.stop();
         this.stopInternal();
         if (this.messagesTimer) {
             clearInterval(this.messagesTimer);
         }
-        this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+        this.subscriberStatus = SubscriberStatusEnum.STOPPED;
         this.statusStream$.next(this.subscriberStatus);
     }
     addSubscription(params) {
@@ -88,18 +63,21 @@ class TelemetryStreamAbstract {
         if (!this.subscriptions.has(params.uniqueId)) {
             // get subscriptions before change
             const before = this.getSubscriptions();
-            this.subscriptions.set(params.uniqueId, Object.assign(Object.assign({}, params), { count: 1 }));
+            this.subscriptions.set(params.uniqueId, {
+                ...params,
+                count: 1, // set the count to one just in case it's set in param
+            });
             // get subscriptions after change
             const after = this.getSubscriptions();
             // assign the current values from state after change
-            this.callsignsLookup = new CallsignsLookup_1.CallsignsLookup(Object.keys(after));
-            this.sources = arrayUnique_1.arrayUnique(Object.values(after).reduce((a, v) => a.concat(v), []));
+            this.callsignsLookup = new CallsignsLookup(Object.keys(after));
+            this.sources = arrayUnique(Object.values(after).reduce((a, v) => a.concat(v), []));
             // compare before and after subscriptions and only add the difference
-            const { toAdd } = getSubscriptionsDifference_1.getSubscriptionsDifference(before, after);
+            const { toAdd } = getSubscriptionsDifference(before, after);
             // only subscribe if the subscriberId exists, otherwise the messages will be subscribed on lazy load
             if (toAdd.callsigns.length && toAdd.sources.length) {
                 this.logger.debug('New subscriptions added, we need to refresh sources', { toAdd });
-                void this.takeTelemetryAction('subscribe', new CallsignsLookup_1.CallsignsLookup(toAdd.callsigns), toAdd.sources);
+                void this.takeTelemetryAction('subscribe', new CallsignsLookup(toAdd.callsigns), toAdd.sources);
             }
         }
         else {
@@ -108,7 +86,7 @@ class TelemetryStreamAbstract {
             this.subscriptions.set(params.uniqueId, subs);
             this.logger.info('Stream subscriptions already exists, increasing count', params.uniqueId, subs.count);
         }
-        RocosStore_1.RocosStore.getChangeSubject().next({ type: 'telemetry-subscription', url: this.url, data: this.subscriptions });
+        RocosStore.getChangeSubject().next({ type: 'telemetry-subscription', url: this.url, data: this.subscriptions });
     }
     async removeSubscription(params, terminateReceiverGroup = false) {
         this.logger.info('Removing subscriptions from stream', params.uniqueId);
@@ -123,13 +101,13 @@ class TelemetryStreamAbstract {
         this.subscriptions.delete(params.uniqueId);
         const after = this.getSubscriptions();
         // assign the current values from state after change
-        this.callsignsLookup = new CallsignsLookup_1.CallsignsLookup(Object.keys(after));
-        this.sources = arrayUnique_1.arrayUnique(Object.values(after).reduce((a, v) => a.concat(v), []));
-        const { toRemove } = getSubscriptionsDifference_1.getSubscriptionsDifference(before, after);
+        this.callsignsLookup = new CallsignsLookup(Object.keys(after));
+        this.sources = arrayUnique(Object.values(after).reduce((a, v) => a.concat(v), []));
+        const { toRemove } = getSubscriptionsDifference(before, after);
         if (toRemove.callsigns.length && toRemove.sources.length) {
             this.logger.debug('Subscriptions removed, we need to refresh sources', { toRemove });
             try {
-                await this.takeTelemetryAction('unsubscribe', new CallsignsLookup_1.CallsignsLookup(toRemove.callsigns), toRemove.sources, terminateReceiverGroup);
+                await this.takeTelemetryAction('unsubscribe', new CallsignsLookup(toRemove.callsigns), toRemove.sources, terminateReceiverGroup);
             }
             catch (err) {
                 this.logger.error(`Failed to unsubscribe: ${err}`);
@@ -139,7 +117,7 @@ class TelemetryStreamAbstract {
             this.logger.info('No subscriptions remaining closing stream', params.uniqueId);
             this.stopStream();
             // self remove when no subscriptions a re left
-            void StreamRegister_1.StreamRegister.getInstance().removeStream(this);
+            void StreamRegister.getInstance().removeStream(this);
             this.logger.info('Stream closed');
         }
     }
@@ -152,79 +130,73 @@ class TelemetryStreamAbstract {
             if (data.callsigns) {
                 data.callsigns.forEach((item) => {
                     if (!subs[item]) {
-                        subs[item] = arrayUnique_1.arrayUnique([...data.sources]);
+                        subs[item] = arrayUnique([...data.sources]);
                     }
                     else {
-                        subs[item] = arrayUnique_1.arrayUnique([...subs[item], ...data.sources]);
+                        subs[item] = arrayUnique([...subs[item], ...data.sources]);
                     }
                 });
             }
         });
         return subs;
     }
-    onData(message) {
-        // Increase the counter
+    onData(message, isStream) {
         this.receivedMessagesCount++;
-        const { source } = message;
-        const { callsign } = message;
+        let rocosMessage;
+        const data = {
+            subscriberId: this.subscriberId,
+            subId: this.scope,
+            projectId: this.projectId,
+        };
+        if (isStream) {
+            rocosMessage = RocosTelemetryMessage.fromTelemetryStreamMessage(message, data, 'json');
+        }
+        else {
+            rocosMessage = RocosTelemetryMessage.fromTelemetryMessage(message, data, 'json');
+        }
+        const { source, callsign } = rocosMessage;
         let isRobotMessage = true;
         const now = new Date();
         // Update last message received time
         this.lastMessageReceived = now;
-        // Update the message's project id
-        message.projectId = this.projectId;
-        message.type = 'json';
-        message.subId = this.scope;
-        message.subscriberId = this.subscriberId;
-        message.receivedAt = new Date();
         switch (source) {
             // Subscribe message
-            case grpc_1.GRPC_SOURCE_SUBSCRIBED:
-                // eslint-disable-next-line no-case-declarations
-                const json = RocosTelemetryMessage_1.RocosTelemetryMessage.getPayloadAsJSON(message);
-                // eslint-disable-next-line no-case-declarations
-                const { subscriberId } = json;
+            case GRPC_SOURCE_SUBSCRIBED: {
+                const { subscriberId } = rocosMessage.payload;
                 if (this.subscriberId && subscriberId) {
                     this.logger.warn(`Replacing old subscriberId (${this.subscriberId}) with a new one (${subscriberId})`);
                 }
                 // Update the subscriberId
                 this.subscriberId = subscriberId;
-                message.subscriberId = this.subscriberId;
+                rocosMessage.subscriberId = this.subscriberId;
                 this.logger.info('onData', `subscriberId has been updated - ${subscriberId}`, { subscriberId });
                 void this.takeTelemetryAction('subscribe');
                 this.heartbeat.start(this.sendHeartbeat, this.sendHeartbeatTime);
                 isRobotMessage = false;
                 break;
+            }
             // Server heartbeat message
-            case grpc_1.GRPC_SOURCE_NOOP:
-                // this.logger.debug('onData', 'received noop message');
+            case GRPC_SOURCE_NOOP:
                 isRobotMessage = false;
                 break;
-            default:
-                isRobotMessage = true;
-                break;
-        }
-        if (!source) {
-            isRobotMessage = false;
         }
         // Update robot last message timestamp
         if (isRobotMessage) {
             this.lastRobotMessageReceived = now;
         }
-        message.payload = RocosTelemetryMessage_1.RocosTelemetryMessage.getPayloadByType(message);
         // Update stats
-        this.updateReceviedDataStatsWithMessage(message);
+        this.updateReceivedDataStatsWithMessage(rocosMessage);
         // Send message to subscribers
         if (this.isRegisteredMessage(callsign, source) && this.messageStream$) {
-            this.messageStream$.next(message);
-            if (message.isackable && this.options.autoAcknowledgmentEnabled) {
-                this.sendAcknowledgment(message.uid, teletubby_pb_1.TelemetryAckStatus.OK, false);
+            this.messageStream$.next(rocosMessage);
+            if (rocosMessage.isackable && this.options.autoAcknowledgmentEnabled) {
+                this.sendAcknowledgment(rocosMessage.uid, TelemetryAckStatus.OK, false);
             }
         }
         else if (isRobotMessage) {
             // acknowledge any way, as the user never receives this message
-            if (message.isackable) {
-                this.sendAcknowledgment(message.uid, teletubby_pb_1.TelemetryAckStatus.REJECT, true);
+            if (rocosMessage.isackable) {
+                this.sendAcknowledgment(rocosMessage.uid, TelemetryAckStatus.REJECT, true);
             }
             // All messages received should be subscribed.
             this.logger.debug('onData', 'received unsubscribed message', {
@@ -244,50 +216,55 @@ class TelemetryStreamAbstract {
             });
             return Promise.resolve();
         }
-        const actionSources = sources !== null && sources !== void 0 ? sources : this.sources;
-        const actionCallsigns = callsignsLookup !== null && callsignsLookup !== void 0 ? callsignsLookup : this.callsignsLookup;
-        if (this.callsignsLookup.lookupType === CallsignsEnums_1.CallsignsLookupType.List) {
+        const actionSources = sources ?? this.sources;
+        const actionCallsigns = callsignsLookup ?? this.callsignsLookup;
+        if (this.callsignsLookup.lookupType === CallsignsLookupType.List) {
             // Compose the request message
-            const req = new teletubby_pb_1.TelemetryRequest();
-            const actions = [];
-            const action = new teletubby_pb_1.TelemetryAction();
-            action.setOperation(actionType);
-            action.setCallsignsList(actionCallsigns.lookupValue);
-            action.setSourcesList(actionSources);
+            const req = TelemetryRequest.create({
+                subscriberId: this.subscriberId,
+                requestedActions: [
+                    {
+                        operation: actionType,
+                        callsigns: actionCallsigns.lookupValue,
+                        sources: actionSources,
+                    },
+                ],
+            });
             if (actionType === 'unsubscribe' && terminate) {
-                this.addTerminateToAction(action);
+                this.addTerminateToAction(req.requestedActions[0]);
             }
-            actions.push(action);
-            req.setRequestedactionsList(actions);
-            req.setSubscriberid(this.subscriberId);
             this.logger.debug('takeTelemetryAction', actionType, 'client.requestTelemetry', this.subscriberId);
             // Send the message to back-end.
             return this.requestTelemetry(req);
         }
-        else if (actionCallsigns.lookupType === CallsignsEnums_1.CallsignsLookupType.Query) {
+        else if (actionCallsigns.lookupType === CallsignsLookupType.Query) {
             const lookupValue = actionCallsigns.lookupValue;
-            // Compose the request message
-            const req = new teletubby_pb_1.TelemetryQueryRequest();
-            req.setSubscriberid(this.subscriberId);
-            req.setSourcesList(actionSources);
-            req.setOperation(actionType);
-            const telemetryQuery = new teletubby_pb_1.Query();
-            telemetryQuery.setOperation(lookupValue.operation);
             // We don't support nested query at the moment
             const queryOrPredicatesList = [];
             // Loop through user provided predicates to construct a telemetry query request
             lookupValue.predicates.forEach((callsignsPredicate) => {
-                const queryOrPredicate = new teletubby_pb_1.QueryOrPredicate();
-                const predicate = new teletubby_pb_1.Predicate();
-                // Map user provided predicate value to proto object
-                predicate.setAttribute(callsignsPredicate.attribute);
-                predicate.setOperation(callsignsPredicate.operation);
-                predicate.setValue(callsignsPredicate.value);
-                queryOrPredicate.setPredicate(predicate);
+                const queryOrPredicate = QueryOrPredicate.create({
+                    content: {
+                        oneofKind: 'predicate',
+                        predicate: {
+                            attribute: callsignsPredicate.attribute.valueOf(),
+                            operation: callsignsPredicate.operation.valueOf(),
+                            value: callsignsPredicate.value,
+                        },
+                    },
+                });
                 queryOrPredicatesList.push(queryOrPredicate);
             });
-            telemetryQuery.setQueryorpredicatesList(queryOrPredicatesList);
-            req.setCallsignquery(telemetryQuery);
+            // Compose the request message
+            const req = TelemetryQueryRequest.create({
+                subscriberId: this.subscriberId,
+                sources: actionSources,
+                operation: actionType,
+                callsignQuery: {
+                    operation: lookupValue.operation.valueOf(),
+                    queryOrPredicates: queryOrPredicatesList,
+                },
+            });
             this.logger.debug('takeTelemetryAction', actionType, 'client.requestTelemetry', this.subscriberId);
             // Send the telemetry query request to back-end.
             return this.requestTelemetryQuery(req);
@@ -302,45 +279,41 @@ class TelemetryStreamAbstract {
             clearInterval(timer);
         }
         this.messagesTimer = setInterval(() => {
-            var _a;
             const now = new Date();
             const latest = this.lastMessageReceived;
             const latestRobot = this.lastRobotMessageReceived;
-            const startedAt = (_a = this.checkerStartedAt) !== null && _a !== void 0 ? _a : new Date();
+            const startedAt = this.checkerStartedAt ?? new Date();
             const timeout = this.options.messageTimeoutInSec;
             let shouldRetry = false;
             let shouldAutoResubscribe = false;
-            if (latest && (now.getTime() - latest.getTime()) / 1000 > timeout) {
-                // If we received message before, we should retry after timeout.
-                shouldRetry = true;
-            }
-            else if (!latest && startedAt && (now.getTime() - startedAt.getTime()) / 1000 > timeout) {
-                // If we have not received message before, we should also retry after timeout.
+            const hasExceededTimeoutSinceLastMessage = latest && (now.getTime() - latest.getTime()) / 1000 > timeout;
+            const hasExceededTimeoutBeforeMessages = !latest && startedAt && (now.getTime() - startedAt.getTime()) / 1000 > timeout;
+            if (hasExceededTimeoutSinceLastMessage || hasExceededTimeoutBeforeMessages) {
                 shouldRetry = true;
             }
             if (latestRobot) {
                 // If we get robot messages at least once.
                 if ((now.getTime() - latestRobot.getTime()) / 1000 > timeout) {
                     // Offline
-                    this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.DEAD;
+                    this.subscriberStatus = SubscriberStatusEnum.DEAD;
                 }
                 else {
                     // Online
-                    this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.ALIVE;
+                    this.subscriberStatus = SubscriberStatusEnum.ALIVE;
                 }
             }
             else if ((now.getTime() - startedAt.getTime()) / 1000 > timeout) {
                 // If there is no robot messages received, then we compare with startedAt time.
                 // Timeout
-                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.DEAD;
+                this.subscriberStatus = SubscriberStatusEnum.DEAD;
             }
             else if (this.retryTimes <= 0) {
                 // Still trying, status unknown.
-                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.STOPPED;
+                this.subscriberStatus = SubscriberStatusEnum.STOPPED;
             }
             else {
                 // Tried multiple times. dead already.
-                this.subscriberStatus = SubscriberStatusEnum_1.SubscriberStatusEnum.DEAD;
+                this.subscriberStatus = SubscriberStatusEnum.DEAD;
             }
             if (this.options.autoResubscribeEnabled &&
                 this.receivedMessagesCount > this.options.autoResubscribeMessageLimit &&
@@ -367,13 +340,22 @@ class TelemetryStreamAbstract {
         }, this.timerIntervalInSec * 1000);
     }
     addTerminateToAction(telemetryAction) {
-        const unsubscribeOperation = new teletubby_pb_1.UnsubscribeOperation();
-        const unsubscribeOption = new teletubby_pb_1.UnsubscribeOption();
-        const receiverGroupUnsubscribeOption = new teletubby_pb_1.ReceiverGroupUnsubscribeOption();
-        receiverGroupUnsubscribeOption.setTerminate(true);
-        unsubscribeOption.setReceivergroupunsubscribeoption(receiverGroupUnsubscribeOption);
-        unsubscribeOperation.addOptions(unsubscribeOption);
-        telemetryAction.setUnsubscribeoperation(unsubscribeOperation);
+        const unsubscribeOperation = UnsubscribeOperation.create({
+            options: [
+                {
+                    content: {
+                        receivergroupUnsubscribeOption: {
+                            terminate: true,
+                        },
+                        oneofKind: 'receivergroupUnsubscribeOption',
+                    },
+                },
+            ],
+        });
+        telemetryAction.content = {
+            oneofKind: 'unsubscribeOperation',
+            unsubscribeOperation,
+        };
     }
     messageTimeoutTryAgain() {
         // Increase retry times.
@@ -397,7 +379,7 @@ class TelemetryStreamAbstract {
         this.registerReceiver();
     }
     isFoundCallsign(callsign) {
-        return this.callsignsLookup.lookupType === CallsignsEnums_1.CallsignsLookupType.List
+        return this.callsignsLookup.lookupType === CallsignsLookupType.List
             ? this.callsignsLookup.lookupValue.indexOf(callsign) !== -1
             : true; // If callsigns lookup option is query, we always return true
     }
@@ -407,7 +389,7 @@ class TelemetryStreamAbstract {
     isRegisteredMessage(callsign, source) {
         return this.isFoundCallsign(callsign) && this.isFoundSource(source);
     }
-    updateReceviedDataStatsWithMessage(msg) {
+    updateReceivedDataStatsWithMessage(msg) {
         const { source } = msg;
         const { callsign } = msg;
         const id = `${callsign}-${source}`;
@@ -418,4 +400,3 @@ class TelemetryStreamAbstract {
         this.receivedDataStats[id] = count + 1;
     }
 }
-exports.TelemetryStreamAbstract = TelemetryStreamAbstract;

package/api/streams/telemetry/TelemetryStreamNode.d.ts

@@ -1,11 +1,11 @@
-import { TelemetryAckStatusMap, TelemetryQueryRequest, TelemetryRequest } from '../../../grpc/teletubby/teletubby_pb';
-import { ITelemetryStreamConfig } from '../../../models/ITelemetryStreamConfig';
+import { ITelemetryStreamConfig } from '../../../models';
+import { TelemetryAckStatus, TelemetryQueryRequest, TelemetryRequest } from '../../../grpc/teletubby_pb';
 import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
 export declare class TelemetryStreamNode extends TelemetryStreamAbstract {
     private client?;
     private stream?;
-    private port;
-    private credentials;
+    private readonly port;
+    private readonly credentials;
     constructor(config: ITelemetryStreamConfig);
     protected stopInternal(): void;
     protected registerReceiver(): () => void;
@@ -16,6 +16,6 @@ export declare class TelemetryStreamNode extends TelemetryStreamAbstract {
     private getMetaData;
     protected requestTelemetry(req: TelemetryRequest): Promise<void>;
     protected requestTelemetryQuery(req: TelemetryQueryRequest): Promise<void>;
-    protected sendAcknowledgmentInternal(uid: string, status: TelemetryAckStatusMap[keyof TelemetryAckStatusMap], noRetry: boolean): boolean;
+    protected sendAcknowledgmentInternal(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
     protected sendHeartbeat(): void;
 }