@dronedeploy/rocos-js-sdk 3.1.1 → 3.1.3-rc1

package/README.md

@@ -19,6 +19,134 @@ yarn add @dronedeploy/rocos-js-sdk rxjs@^7
 
 ## What's new
 
+### 3.1.2
+
+* Use the optional `fetch` implementation for the gRPC-web transport too, so a custom `fetch` can be supplied consistently across transports.
+
+### 3.1.1
+
+* Allow an optional `fetch` implementation to be supplied to the Connect transport.
+
+### 3.1.0
+
+* Add a Connect-RPC telemetry transport variant.
+* Upgrade `connectrpc` and `bufbuild` to the latest versions and move to TypeScript 6.
+* Prune unused and trivially-replaceable dependencies.
+
+### 3.0.30
+
+* *MapService*
+    * Add a `create` API and fix the `copy` API.
+
+### 3.0.29
+
+* Add new APIs for setting map content and metadata.
+
+### 3.0.28
+
+* Add `base_floor_plan` to `Level`.
+
+### 3.0.27
+
+* Add `staticAttributes` field to `AssetSyncDefinitionModel`.
+
+### 3.0.25
+
+* *IntegrationService*
+    * Add `getLevels` method.
+
+### 3.0.23
+
+* Add `metadata` field to device credentials.
+
+### 3.0.21
+
+* Export types for device credentials.
+
+### 3.0.20
+
+* Add library list/import endpoints.
+
+### 3.0.19
+
+* *CallerService*
+    * Add a cancel observable to service calls.
+
+### 3.0.18
+
+* *CallerService*
+    * Add a `rawPayload` option to service calls.
+
+### 3.0.17
+
+* *RobotService*
+    * List robots by account/org.
+
+### 3.0.16
+
+* Add missing types for `EventService` and `ProfileService`.
+
+### 3.0.15
+
+* *ProfileService*
+    * Change the profile export type to `Blob`.
+
+### 3.0.14
+
+* *Utils*
+    * Expose `splitRobotTopic`.
+
+### 3.0.13
+
+* *kscript*
+    * Additional support for custom widgets.
+
+### 3.0.11
+
+* Improve the accuracy of file sync types.
+
+### 3.0.10
+
+* *MapService*
+    * Add a system parameter to the list maps endpoint.
+
+### 3.0.9
+
+* *WorkflowService*
+    * Add methods for importing/exporting workflows.
+
+### 3.0.8
+
+* Add an HTTP listener/hook.
+
+### 3.0.7
+
+* *MapService*
+    * Add `lastModifiedTimestamp` to list maps.
+
+### 3.0.6
+
+* *WorkflowService*
+    * Add a function to delete an asset.
+
+### 3.0.5
+
+* Add `name` to the `Locations` type.
+
+### 3.0.4
+
+* *Panorama*
+    * Allow `any` type on the `data` prop.
+
+### 3.0.3
+
+* *MapService*
+    * Add a `hash` property to the cloud map object.
+
+### 3.0.2
+
+* Add a delete assets endpoint.
+
 ### 3.0.1
 
 #### Breaking Changes

package/cjs/api/streams/telemetry/FetchInjectingGrpcWebTransport.d.ts

@@ -0,0 +1,28 @@
+import { GrpcWebFetchTransport, GrpcWebOptions } from '@protobuf-ts/grpcweb-transport';
+import type { MethodInfo, RpcOptions, ServerStreamingCall, UnaryCall } from '@protobuf-ts/runtime-rpc';
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+export declare class FetchInjectingGrpcWebTransport extends GrpcWebFetchTransport {
+    private readonly customFetch;
+    constructor(customFetch: typeof globalThis.fetch | undefined, options: GrpcWebOptions);
+    private withFetch;
+    unary<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): UnaryCall<I, O>;
+    serverStreaming<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): ServerStreamingCall<I, O>;
+}

package/cjs/api/streams/telemetry/FetchInjectingGrpcWebTransport.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchInjectingGrpcWebTransport = void 0;
+const grpcweb_transport_1 = require("@protobuf-ts/grpcweb-transport");
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+class FetchInjectingGrpcWebTransport extends grpcweb_transport_1.GrpcWebFetchTransport {
+    constructor(customFetch, options) {
+        super(options);
+        this.customFetch = customFetch;
+    }
+    withFetch(start) {
+        if (!this.customFetch) {
+            return start();
+        }
+        const original = globalThis.fetch;
+        globalThis.fetch = this.customFetch;
+        try {
+            return start();
+        }
+        finally {
+            globalThis.fetch = original;
+        }
+    }
+    unary(method, input, options) {
+        return this.withFetch(() => super.unary(method, input, options));
+    }
+    serverStreaming(method, input, options) {
+        return this.withFetch(() => super.serverStreaming(method, input, options));
+    }
+}
+exports.FetchInjectingGrpcWebTransport = FetchInjectingGrpcWebTransport;

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TelemetryStream = void 0;
 const models_1 = require("../../../models");
 const teletubby_pb_1 = require("../../../grpc/teletubby_pb");
-const grpcweb_transport_1 = require("@protobuf-ts/grpcweb-transport");
+const FetchInjectingGrpcWebTransport_1 = require("./FetchInjectingGrpcWebTransport");
 const RocosLogger_1 = require("../../../logger/RocosLogger");
 const teletubby_pb_client_1 = require("../../../grpc/teletubby_pb.client");
 const TelemetryStreamAbstract_1 = require("./TelemetryStreamAbstract");
@@ -13,7 +13,11 @@ class TelemetryStream extends TelemetryStreamAbstract_1.TelemetryStreamAbstract
         this.logger = RocosLogger_1.RocosLogger.getInstance(`TelemetryStreamWeb(${this.identifier})`);
         const protocol = config.insecure ? 'http' : 'https';
         const port = config.port ? `:${config.port}` : '';
-        const transport = new grpcweb_transport_1.GrpcWebFetchTransport({
+        // Optional caller-supplied fetch (e.g. captured before Datadog RUM patches window.fetch, whose
+        // response cloning otherwise stalls this long-lived stream). When omitted, the transport uses
+        // the global fetch. @protobuf-ts/grpcweb-transport has no fetch option, so the injection happens
+        // in FetchInjectingGrpcWebTransport.
+        const transport = new FetchInjectingGrpcWebTransport_1.FetchInjectingGrpcWebTransport(config.fetch, {
             baseUrl: `${protocol}://${this.url}${port}`,
             format: config.grpcWebFormat,
         });

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

@@ -0,0 +1,28 @@
+import { GrpcWebFetchTransport, GrpcWebOptions } from '@protobuf-ts/grpcweb-transport';
+import type { MethodInfo, RpcOptions, ServerStreamingCall, UnaryCall } from '@protobuf-ts/runtime-rpc';
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+export declare class FetchInjectingGrpcWebTransport extends GrpcWebFetchTransport {
+    private readonly customFetch;
+    constructor(customFetch: typeof globalThis.fetch | undefined, options: GrpcWebOptions);
+    private withFetch;
+    unary<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): UnaryCall<I, O>;
+    serverStreaming<I extends object, O extends object>(method: MethodInfo<I, O>, input: I, options: RpcOptions): ServerStreamingCall<I, O>;
+}

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

@@ -0,0 +1,45 @@
+import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+/**
+ * A {@link GrpcWebFetchTransport} that issues its requests through a caller-supplied `fetch` instead
+ * of the global one.
+ *
+ * Why: `@protobuf-ts/grpcweb-transport` calls `globalThis.fetch(...)` directly and exposes no option
+ * to inject a custom fetch. Datadog RUM (and similar agents) monkey-patch `window.fetch` and
+ * `clone()` + read every response to measure timing; on the long-lived grpc-web telemetry stream
+ * (`RegisterReceiver`) that clone-read can stall the client's read of the body. Reading the stream
+ * through a `fetch` captured before RUM patched the global avoids that.
+ *
+ * How: the parent transport invokes `globalThis.fetch(...)` **synchronously** while starting a call
+ * (it builds the request body synchronously, then calls fetch and returns the call object). We swap
+ * `globalThis.fetch` for that synchronous window only. JavaScript is single-threaded, so no other
+ * code — and therefore no other request — runs between the swap and the `finally` restore; the
+ * custom fetch cannot leak to unrelated requests. Reading the response happens later, but the
+ * `Response`/stream is already bound to the custom fetch by then.
+ *
+ * When `customFetch` is undefined this behaves exactly like {@link GrpcWebFetchTransport}.
+ */
+export class FetchInjectingGrpcWebTransport extends GrpcWebFetchTransport {
+    constructor(customFetch, options) {
+        super(options);
+        this.customFetch = customFetch;
+    }
+    withFetch(start) {
+        if (!this.customFetch) {
+            return start();
+        }
+        const original = globalThis.fetch;
+        globalThis.fetch = this.customFetch;
+        try {
+            return start();
+        }
+        finally {
+            globalThis.fetch = original;
+        }
+    }
+    unary(method, input, options) {
+        return this.withFetch(() => super.unary(method, input, options));
+    }
+    serverStreaming(method, input, options) {
+        return this.withFetch(() => super.serverStreaming(method, input, options));
+    }
+}

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

@@ -1,6 +1,6 @@
 import { SubscriberStatusEnum } from '../../../models';
 import { RegistrationMessage, } from '../../../grpc/teletubby_pb';
-import { GrpcWebFetchTransport } from '@protobuf-ts/grpcweb-transport';
+import { FetchInjectingGrpcWebTransport } from './FetchInjectingGrpcWebTransport';
 import { RocosLogger } from '../../../logger/RocosLogger';
 import { TelemetryGatewayClient } from '../../../grpc/teletubby_pb.client';
 import { TelemetryStreamAbstract } from './TelemetryStreamAbstract';
@@ -10,7 +10,11 @@ export class TelemetryStream extends TelemetryStreamAbstract {
         this.logger = RocosLogger.getInstance(`TelemetryStreamWeb(${this.identifier})`);
         const protocol = config.insecure ? 'http' : 'https';
         const port = config.port ? `:${config.port}` : '';
-        const transport = new GrpcWebFetchTransport({
+        // Optional caller-supplied fetch (e.g. captured before Datadog RUM patches window.fetch, whose
+        // response cloning otherwise stalls this long-lived stream). When omitted, the transport uses
+        // the global fetch. @protobuf-ts/grpcweb-transport has no fetch option, so the injection happens
+        // in FetchInjectingGrpcWebTransport.
+        const transport = new FetchInjectingGrpcWebTransport(config.fetch, {
             baseUrl: `${protocol}://${this.url}${port}`,
             format: config.grpcWebFormat,
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dronedeploy/rocos-js-sdk",
-  "version": "3.1.1",
+  "version": "3.1.3-rc1",
   "description": "Javascript SDK for rocos",
   "main": "cjs/index.js",
   "module": "esm/index.js",