@dronedeploy/rocos-js-sdk 3.0.30 → 3.1.0

package/cjs/services/CallerService.js

@@ -9,7 +9,6 @@ const BaseStreamService_1 = require("./BaseStreamService");
 const CallerStream_1 = require("../api/streams/caller/CallerStream");
 const identifier_1 = require("../constants/identifier");
 const helpers_1 = require("../helpers");
-const uuid_1 = require("uuid");
 class CallerService extends BaseStreamService_1.BaseStreamService {
     constructor(config) {
         super('CallerService', config);
@@ -66,7 +65,7 @@ class CallerService extends BaseStreamService_1.BaseStreamService {
     }
     getCallerParams(params, component, topic) {
         return {
-            uid: params.options?.uid ?? (0, uuid_1.v4)(),
+            uid: params.options?.uid ?? crypto.randomUUID(),
             projectId: params.projectId,
             callsign: params.callsign,
             subSystem: '',

package/cjs/services/SpotProvisioningServiceNode.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import { IBaseService, IRocosSDKConfig, RocosError } from '../models';
 import { BaseServiceAbstract } from './BaseServiceAbstract';
 import { Timezone } from '../constants/timezones';

package/cjs/services/TelemetryService.js

@@ -8,6 +8,7 @@ const BaseStreamService_1 = require("./BaseStreamService");
 const identifier_1 = require("../constants/identifier");
 const RocosStore_1 = require("../store/RocosStore");
 const TelemetryStream_1 = require("../api/streams/telemetry/TelemetryStream");
+const TelemetryStreamConnect_1 = require("../api/streams/telemetry/TelemetryStreamConnect");
 const arrayUnique_1 = require("../helpers/arrayUnique");
 const flattenCallsignsLookup_1 = require("../helpers/flattenCallsignsLookup");
 const getUniqueId_1 = require("../helpers/getUniqueId");
@@ -162,6 +163,7 @@ class TelemetryService extends BaseStreamService_1.BaseStreamService {
             options: this.config.options,
             port: this.config.port,
             insecure: this.config.insecure,
+            transport: this.config.transport,
         });
         if (!newStream.isNew) {
             newStream.stream.statusStream$.subscribe((msg) => {
@@ -174,6 +176,9 @@ class TelemetryService extends BaseStreamService_1.BaseStreamService {
         return newStream.stream;
     }
     getStream(config) {
+        if (config.transport === 'connect') {
+            return new TelemetryStreamConnect_1.TelemetryStreamConnect(config);
+        }
         return new TelemetryStream_1.TelemetryStream(config);
     }
 }

package/esm/api/streams/caller/CallerStreamAbstract.js

@@ -6,7 +6,6 @@ import { IDENTIFIER_NAME_CALLER } from '../../../constants/identifier';
 import { RocosStore } from '../../../store/RocosStore';
 import { StreamRegister } from '../../StreamRegister';
 import { filter } from 'rxjs/operators';
-import { v4 as uuidv4 } from 'uuid';
 export class CallerStreamAbstract {
     constructor(config) {
         this.subscriberStatus = SubscriberStatusEnum.STOPPED;
@@ -78,7 +77,7 @@ export class CallerStreamAbstract {
                 version: UIDVersion.HEADER_HASH_RAND,
                 content: {
                     oneofKind: 'hash',
-                    hash: uid ?? uuidv4(),
+                    hash: uid ?? crypto.randomUUID(),
                 },
             },
             payload: this.getPayload(payload),

package/esm/api/streams/caller/CallerStreamNode.js

@@ -102,7 +102,7 @@ export class CallerStreamNode extends CallerStreamAbstract {
         });
     }
     getPayload(payload) {
-        return Buffer.from(payload);
+        return new TextEncoder().encode(payload);
     }
     getMetadata(projectId, callsign, subsystem) {
         const meta = new grpc.Metadata();

package/esm/api/streams/telemetry/TelemetryStream.js

@@ -12,6 +12,7 @@ export class TelemetryStream extends TelemetryStreamAbstract {
         const port = config.port ? `:${config.port}` : '';
         const transport = new GrpcWebFetchTransport({
             baseUrl: `${protocol}://${this.url}${port}`,
+            format: config.grpcWebFormat,
         });
         this.client = new TelemetryGatewayClient(transport);
     }

package/esm/api/streams/telemetry/TelemetryStreamConnect.d.ts

@@ -0,0 +1,26 @@
+import { ITelemetryStreamConfig } from '../../../models';
+import { TelemetryAckStatus, TelemetryQueryRequest, TelemetryRequest } from '../../../grpc/teletubby_pb';
+import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
+/**
+ * Connect-protocol telemetry receive stream. Mirrors TelemetryStream (grpc-web) but uses
+ * @connectrpc/connect. Selected when config.transport === 'connect'.
+ *
+ * The shared TelemetryStreamAbstract is typed with the protobuf-ts message types, while the
+ * Connect client uses @bufbuild/protobuf types. Both serialise to identical protobuf wire
+ * bytes, so we bridge across the boundary with toBinary/fromBinary rather than hand-written
+ * field mapping. This keeps all reconnect/subscription/heartbeat logic shared and untouched.
+ */
+export declare class TelemetryStreamConnect extends TelemetryStreamAbstract {
+    private client;
+    private abortController?;
+    constructor(config: ITelemetryStreamConfig);
+    protected stopInternal(): void;
+    protected registerReceiver(): () => void;
+    private onError;
+    private onEnd;
+    private getHeaders;
+    protected requestTelemetry(req: TelemetryRequest): Promise<void>;
+    protected requestTelemetryQuery(req: TelemetryQueryRequest): Promise<void>;
+    protected sendAcknowledgmentInternal(uid: string, status: TelemetryAckStatus, noRetry: boolean): boolean;
+    protected sendHeartbeat(): void;
+}

package/esm/api/streams/telemetry/TelemetryStreamConnect.js

@@ -0,0 +1,141 @@
+import { createClient } from '@connectrpc/connect';
+import { SubscriberStatusEnum } from '../../../models';
+import { RegistrationMessageSchema, TelemetryGateway, TelemetryQueryRequestSchema, TelemetryRequestSchema, } from '../../../grpc/connect/teletubby_pb';
+import { TelemetryMessage, TelemetryQueryRequest, TelemetryRequest, } from '../../../grpc/teletubby_pb';
+import { create, fromBinary } from '@bufbuild/protobuf';
+import { RocosLogger } from '../../../logger/RocosLogger';
+import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
+import { createConnectTransport } from '@connectrpc/connect-web';
+/**
+ * Connect-protocol telemetry receive stream. Mirrors TelemetryStream (grpc-web) but uses
+ * @connectrpc/connect. Selected when config.transport === 'connect'.
+ *
+ * The shared TelemetryStreamAbstract is typed with the protobuf-ts message types, while the
+ * Connect client uses @bufbuild/protobuf types. Both serialise to identical protobuf wire
+ * bytes, so we bridge across the boundary with toBinary/fromBinary rather than hand-written
+ * field mapping. This keeps all reconnect/subscription/heartbeat logic shared and untouched.
+ */
+export class TelemetryStreamConnect extends TelemetryStreamAbstract {
+    constructor(config) {
+        super(config);
+        this.logger = RocosLogger.getInstance(`TelemetryStreamConnect(${this.identifier})`);
+        const protocol = config.insecure ? 'http' : 'https';
+        const port = config.port ? `:${config.port}` : '';
+        const transport = createConnectTransport({
+            baseUrl: `${protocol}://${this.url}${port}`,
+            // Binary proto codec. The Connect default is JSON, which fails to decode real telemetry
+            // payloads containing control characters (verified against a live robot on dev) and is
+            // less efficient. Binary is required for correctness here.
+            useBinaryFormat: true,
+        });
+        this.client = createClient(TelemetryGateway, transport);
+    }
+    stopInternal() {
+        if (this.abortController) {
+            this.logger.info('Starting stop stream process');
+            this.abortController.abort();
+            this.abortController = undefined;
+            this.logger.info('Finished stop stream process');
+        }
+    }
+    registerReceiver() {
+        this.logger.info('registerReceiver');
+        // Reset counter
+        this.receivedMessagesCount = 0;
+        const abortController = new AbortController();
+        this.abortController = abortController;
+        void (async () => {
+            try {
+                const stream = this.client.registerReceiver(create(RegistrationMessageSchema, {}), {
+                    headers: this.getHeaders(this.projectId),
+                    signal: abortController.signal,
+                });
+                for await (const msg of stream) {
+                    // Bridge connect-es message -> protobuf-ts TelemetryMessage with a direct field map.
+                    // (Avoids a per-message re-serialize/re-parse; created/seq are int64/uint64 -> string
+                    // for protobuf-ts's long_type_string config.)
+                    const ptMsg = TelemetryMessage.create({
+                        source: msg.source,
+                        callsign: msg.callsign,
+                        payload: msg.payload,
+                        uid: msg.uid,
+                        created: msg.created.toString(),
+                        seq: msg.seq.toString(),
+                        meta: msg.meta,
+                    });
+                    this.onData(ptMsg, false);
+                }
+                this.onEnd(true);
+            }
+            catch (e) {
+                if (abortController.signal.aborted) {
+                    this.logger.debug('registerReceiver', 'aborted');
+                    return;
+                }
+                void this.onError(e);
+                this.onEnd(false);
+            }
+        })();
+        this.listenMessagesAndRenew();
+        return () => {
+            abortController.abort();
+        };
+    }
+    async onError(e) {
+        this.logger.error(`Telemetry Stream Error: ${e}, SubscriberId: ${this.subscriberId}`);
+        this.subscriberStatus = SubscriberStatusEnum.ERROR;
+        this.statusStream$.next(this.subscriberStatus);
+    }
+    onEnd(ok) {
+        this.logger.debug('registerReceiver', 'end');
+        if (ok) {
+            this.stopInternal();
+            this.registerReceiver();
+        }
+    }
+    getHeaders(projectId) {
+        const result = {
+            // Canary marker: the istio VirtualService routes only requests carrying this header to
+            // the Connect-Go handler (:8083), leaving existing grpc-web traffic untouched. Harmless
+            // when the backend does a full cutover or is hit directly. Must match the chart's
+            // virtualService.routes.connect.matchHeader.
+            'x-tt-connect': '1',
+        };
+        if (this.token) {
+            result.authorization = this.token;
+        }
+        if (projectId) {
+            result['r-p'] = projectId;
+        }
+        return result;
+    }
+    async requestTelemetry(req) {
+        this.logger.debug('Sending telemetry request');
+        try {
+            const connectReq = fromBinary(TelemetryRequestSchema, TelemetryRequest.toBinary(req));
+            await this.client.requestTelemetry(connectReq, { headers: this.getHeaders(this.projectId) });
+        }
+        catch (e) {
+            this.logger.error('error requestTelemetry ', e);
+            throw e;
+        }
+    }
+    async requestTelemetryQuery(req) {
+        this.logger.debug('Requesting telemetry with query');
+        try {
+            const connectReq = fromBinary(TelemetryQueryRequestSchema, TelemetryQueryRequest.toBinary(req));
+            await this.client.requestTelemetryQuery(connectReq, { headers: this.getHeaders(this.projectId) });
+        }
+        catch (e) {
+            this.logger.error('error requestTelemetryQuery ', e);
+            throw e;
+        }
+    }
+    sendAcknowledgmentInternal(uid, status, noRetry) {
+        this.logger.error('Error can not send Acknowledgment on connect client', { uid, status, noRetry });
+        return false;
+    }
+    sendHeartbeat() {
+        // Server-streaming Connect has no client->server channel for heartbeats.
+    }
+}

package/esm/api/streams/telemetry/TelemetryStreamNode.js

@@ -4,7 +4,6 @@ import { ReceiverStreamMessage, } from '../../../grpc/teletubby_pb';
 import { RocosLogger } from '../../../logger/RocosLogger';
 import { TelemetryReceiverClient } from '../../../grpc/teletubby_pb.grpc-client';
 import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
-import { v4 as uuid4 } from 'uuid';
 export class TelemetryStreamNode extends TelemetryStreamAbstract {
     constructor(config) {
         super(config);
@@ -104,7 +103,7 @@ export class TelemetryStreamNode extends TelemetryStreamAbstract {
     getMetaData() {
         const meta = new grpc.Metadata();
         meta.add('r-p', this.projectId);
-        meta.add('r-tid', uuid4());
+        meta.add('r-tid', crypto.randomUUID());
         meta.add('r-cs', 'rocos-js-sdk-agent');
         if (this.token)
             meta.add('authorization', this.token);