@doist/comms-sdk 0.7.0 → 0.7.1

package/dist/cjs/testUtils/msw-setup.js

@@ -3,6 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.server = void 0;
 const node_1 = require("msw/node");
 const vitest_1 = require("vitest");
+// In production the transport uses undici's own `fetch` (paired with the
+// dispatcher) so the request client and dispatcher stay on one undici version.
+// MSW intercepts the *global* `fetch`, not that separate undici instance, so
+// force the transport onto the global `fetch` for every test in the suite;
+// MSW then intercepts requests as usual. The real undici transport is covered
+// directly by `http-dispatcher.test.ts` and `fetch-with-retry.test.ts`, which
+// opt out of this seam.
+vitest_1.vi.mock('../transport/http-dispatcher', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getDefaultTransport: vitest_1.vi.fn(async () => undefined),
+    };
+});
 // Create MSW server instance
 exports.server = (0, node_1.setupServer)();
 // Start server before all tests

package/dist/cjs/transport/fetch-with-retry.js

@@ -62,15 +62,25 @@ async function fetchWithRetry(url, options, maxRetries = 3, customFetch) {
     throw new errors_1.CommsRequestError(lastError?.message ?? 'Request failed');
 }
 async function fetchWithDefaultTransport(url, options, signal) {
-    const dispatcher = await (0, http_dispatcher_1.getDefaultDispatcher)();
-    const response = dispatcher
-        ? await fetch(url, {
+    // Read the dispatcher and its paired `fetch` as one value so they can never
+    // be mismatched. On Node, `fetch` is undici's own — paired with the
+    // dispatcher — so the request client and dispatcher stay on one undici
+    // version; otherwise the `decompress` interceptor terminates gzip responses
+    // when the global `fetch`'s bundled undici differs. Browser/edge (and Bun)
+    // have no paired `fetch` and fall back to the global one.
+    const transport = await (0, http_dispatcher_1.getDefaultTransport)();
+    // undici's `fetch` and the global `fetch` are the same function at runtime
+    // but carry different (undici vs DOM) `RequestInit`/`Response` types. Call
+    // through the global signature, which matches the global-typed `options`.
+    const fetchImpl = (transport?.fetch ?? fetch);
+    const response = transport?.dispatcher
+        ? await fetchImpl(url, {
             ...options,
             signal,
             // @ts-expect-error - dispatcher is valid for Node.js fetch but not in TS types
-            dispatcher,
+            dispatcher: transport.dispatcher,
         })
-        : await fetch(url, {
+        : await fetchImpl(url, {
             ...options,
             signal,
         });

package/dist/cjs/transport/http-dispatcher.js

@@ -33,29 +33,39 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultTransport = getDefaultTransport;
 exports.getDefaultDispatcher = getDefaultDispatcher;
 exports.closeDefaultDispatcher = closeDefaultDispatcher;
 exports.resetDefaultDispatcherForTests = resetDefaultDispatcherForTests;
+exports.getDefaultFetch = getDefaultFetch;
 exports.suppressExperimentalWarningsSync = suppressExperimentalWarningsSync;
-let defaultDispatcher;
-let defaultDispatcherPromise;
-async function getDefaultDispatcher() {
-    if (defaultDispatcher) {
-        return defaultDispatcher;
+let defaultTransport;
+let defaultTransportPromise;
+/**
+ * The default dispatcher and its paired `fetch`, as a single value so the two
+ * are always read consistently. Resolves to `undefined` outside Node (browser/
+ * edge), where callers use the global `fetch` with no dispatcher.
+ */
+async function getDefaultTransport() {
+    if (defaultTransport) {
+        return defaultTransport;
     }
-    if (!defaultDispatcherPromise) {
-        defaultDispatcherPromise = createDefaultDispatcher()
-            .then((dispatcher) => {
-            defaultDispatcher = dispatcher;
-            return dispatcher;
+    if (!defaultTransportPromise) {
+        defaultTransportPromise = createDefaultTransport()
+            .then((transport) => {
+            defaultTransport = transport;
+            return transport;
         })
             .catch((error) => {
-            defaultDispatcher = undefined;
-            defaultDispatcherPromise = undefined;
+            defaultTransport = undefined;
+            defaultTransportPromise = undefined;
             throw error;
         });
     }
-    return defaultDispatcherPromise;
+    return defaultTransportPromise;
+}
+async function getDefaultDispatcher() {
+    return (await getDefaultTransport())?.dispatcher;
 }
 /**
  * Drains the default dispatcher's connection pool. CLIs and scripts should
@@ -64,17 +74,17 @@ async function getDefaultDispatcher() {
  */
 async function closeDefaultDispatcher() {
     // Clear the singleton *before* awaiting init, so any concurrent
-    // `getDefaultDispatcher()` after this point creates a fresh dispatcher
+    // `getDefaultTransport()` after this point creates a fresh dispatcher
     // instead of receiving a reference to the one we're about to close.
-    const initPromise = defaultDispatcherPromise;
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    const initPromise = defaultTransportPromise;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
     if (!initPromise)
         return;
     try {
-        const dispatcher = await initPromise;
-        if (dispatcher) {
-            await dispatcher.close();
+        const transport = await initPromise;
+        if (transport) {
+            await transport.dispatcher.close();
         }
     }
     catch {
@@ -82,20 +92,39 @@ async function closeDefaultDispatcher() {
     }
 }
 function resetDefaultDispatcherForTests() {
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
+}
+/**
+ * The `fetch` implementation that must be used with the default dispatcher.
+ * Returns undici's own `fetch` on the full-undici Node path, or `undefined`
+ * (meaning: use the global `fetch`) in the browser/edge/Bun paths.
+ *
+ * Node's global `fetch` is backed by whatever undici version ships inside that
+ * Node release (6.x on Node 22 … 8.x on Node 26). Our dispatcher — and its
+ * `decompress` interceptor — comes from the npm `undici` package, which is a
+ * different version. Handing an npm-undici dispatcher to a mismatched built-in
+ * client makes gzip responses fail mid-stream with `terminated`. Sourcing
+ * `fetch` from the same npm `undici` keeps the whole request path on one
+ * version and removes the split.
+ *
+ * Only meaningful after {@link getDefaultTransport} has resolved, which is the
+ * one place that populates it.
+ */
+function getDefaultFetch() {
+    return defaultTransport?.fetch;
 }
 function isNodeEnvironment() {
     return typeof process !== 'undefined' && typeof process.versions?.node === 'string';
 }
-async function createDefaultDispatcher() {
+async function createDefaultTransport() {
     if (!isNodeEnvironment()) {
         return undefined;
     }
     // Dynamic import so non-Node consumers (browser, edge runtimes) don't pull
     // undici into their bundle. `isNodeEnvironment()` above already gated this
     // branch, so undici is safe to load when we get here.
-    const { EnvHttpProxyAgent, interceptors } = await Promise.resolve().then(() => __importStar(require('undici')));
+    const { EnvHttpProxyAgent, interceptors, fetch: undiciFetch } = await Promise.resolve().then(() => __importStar(require('undici')));
     // `EnvHttpProxyAgent` (with `allowH2`) and `interceptors.decompress()` both
     // emit an ExperimentalWarning on first use, so build the whole dispatcher
     // inside the suppression block.
@@ -112,14 +141,21 @@ async function createDefaultDispatcher() {
         // crashing on the missing API. Optional chaining also guards a runtime
         // that omits the `interceptors` export entirely.
         if (typeof interceptors?.decompress !== 'function') {
-            return agent;
+            // Bun: pair the agent with the global `fetch` (undefined), which
+            // decompresses natively.
+            return { dispatcher: agent, fetch: undefined };
         }
         // `interceptors.decompress()` decodes gzip/deflate/br/zstd bodies. On
         // Node 24+, attaching any custom dispatcher to global `fetch` strips
         // `content-encoding` without actually decompressing the body.
         // See https://github.com/Doist/todoist-cli/issues/318.
         const decompress = interceptors.decompress();
-        return agent.compose(decompress);
+        // Pair undici's own `fetch` with this dispatcher so the request client
+        // and the dispatcher stay on one undici version (see `getDefaultFetch`).
+        // The global `fetch` is backed by a different, Node-bundled undici;
+        // mixing the two makes the decompress interceptor terminate gzip
+        // responses on some Node versions.
+        return { dispatcher: agent.compose(decompress), fetch: undiciFetch };
     });
 }
 // `suppressExperimentalWarningsSync` is exported for direct unit testing —

package/dist/esm/testUtils/msw-setup.js

@@ -1,5 +1,19 @@
 import { setupServer } from 'msw/node';
-import { afterAll, afterEach, beforeAll } from 'vitest';
+import { afterAll, afterEach, beforeAll, vi } from 'vitest';
+// In production the transport uses undici's own `fetch` (paired with the
+// dispatcher) so the request client and dispatcher stay on one undici version.
+// MSW intercepts the *global* `fetch`, not that separate undici instance, so
+// force the transport onto the global `fetch` for every test in the suite;
+// MSW then intercepts requests as usual. The real undici transport is covered
+// directly by `http-dispatcher.test.ts` and `fetch-with-retry.test.ts`, which
+// opt out of this seam.
+vi.mock('../transport/http-dispatcher', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        getDefaultTransport: vi.fn(async () => undefined),
+    };
+});
 // Create MSW server instance
 export const server = setupServer();
 // Start server before all tests

package/dist/esm/transport/fetch-with-retry.js

@@ -1,7 +1,7 @@
 import { CommsRequestError } from '../types/errors.js';
 import { camelCaseKeys } from '../utils/case-conversion.js';
 import { transformTimestamps } from '../utils/timestamp-conversion.js';
-import { getDefaultDispatcher } from './http-dispatcher.js';
+import { getDefaultTransport } from './http-dispatcher.js';
 export async function fetchWithRetry(url, options, maxRetries = 3, customFetch) {
     let lastError;
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
@@ -59,15 +59,25 @@ export async function fetchWithRetry(url, options, maxRetries = 3, customFetch)
     throw new CommsRequestError(lastError?.message ?? 'Request failed');
 }
 async function fetchWithDefaultTransport(url, options, signal) {
-    const dispatcher = await getDefaultDispatcher();
-    const response = dispatcher
-        ? await fetch(url, {
+    // Read the dispatcher and its paired `fetch` as one value so they can never
+    // be mismatched. On Node, `fetch` is undici's own — paired with the
+    // dispatcher — so the request client and dispatcher stay on one undici
+    // version; otherwise the `decompress` interceptor terminates gzip responses
+    // when the global `fetch`'s bundled undici differs. Browser/edge (and Bun)
+    // have no paired `fetch` and fall back to the global one.
+    const transport = await getDefaultTransport();
+    // undici's `fetch` and the global `fetch` are the same function at runtime
+    // but carry different (undici vs DOM) `RequestInit`/`Response` types. Call
+    // through the global signature, which matches the global-typed `options`.
+    const fetchImpl = (transport?.fetch ?? fetch);
+    const response = transport?.dispatcher
+        ? await fetchImpl(url, {
             ...options,
             signal,
             // @ts-expect-error - dispatcher is valid for Node.js fetch but not in TS types
-            dispatcher,
+            dispatcher: transport.dispatcher,
         })
-        : await fetch(url, {
+        : await fetchImpl(url, {
             ...options,
             signal,
         });

package/dist/esm/transport/http-dispatcher.js

@@ -1,22 +1,30 @@
-let defaultDispatcher;
-let defaultDispatcherPromise;
-export async function getDefaultDispatcher() {
-    if (defaultDispatcher) {
-        return defaultDispatcher;
+let defaultTransport;
+let defaultTransportPromise;
+/**
+ * The default dispatcher and its paired `fetch`, as a single value so the two
+ * are always read consistently. Resolves to `undefined` outside Node (browser/
+ * edge), where callers use the global `fetch` with no dispatcher.
+ */
+export async function getDefaultTransport() {
+    if (defaultTransport) {
+        return defaultTransport;
     }
-    if (!defaultDispatcherPromise) {
-        defaultDispatcherPromise = createDefaultDispatcher()
-            .then((dispatcher) => {
-            defaultDispatcher = dispatcher;
-            return dispatcher;
+    if (!defaultTransportPromise) {
+        defaultTransportPromise = createDefaultTransport()
+            .then((transport) => {
+            defaultTransport = transport;
+            return transport;
         })
             .catch((error) => {
-            defaultDispatcher = undefined;
-            defaultDispatcherPromise = undefined;
+            defaultTransport = undefined;
+            defaultTransportPromise = undefined;
             throw error;
         });
     }
-    return defaultDispatcherPromise;
+    return defaultTransportPromise;
+}
+export async function getDefaultDispatcher() {
+    return (await getDefaultTransport())?.dispatcher;
 }
 /**
  * Drains the default dispatcher's connection pool. CLIs and scripts should
@@ -25,17 +33,17 @@ export async function getDefaultDispatcher() {
  */
 export async function closeDefaultDispatcher() {
     // Clear the singleton *before* awaiting init, so any concurrent
-    // `getDefaultDispatcher()` after this point creates a fresh dispatcher
+    // `getDefaultTransport()` after this point creates a fresh dispatcher
     // instead of receiving a reference to the one we're about to close.
-    const initPromise = defaultDispatcherPromise;
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    const initPromise = defaultTransportPromise;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
     if (!initPromise)
         return;
     try {
-        const dispatcher = await initPromise;
-        if (dispatcher) {
-            await dispatcher.close();
+        const transport = await initPromise;
+        if (transport) {
+            await transport.dispatcher.close();
         }
     }
     catch {
@@ -43,20 +51,39 @@ export async function closeDefaultDispatcher() {
     }
 }
 export function resetDefaultDispatcherForTests() {
-    defaultDispatcher = undefined;
-    defaultDispatcherPromise = undefined;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
+}
+/**
+ * The `fetch` implementation that must be used with the default dispatcher.
+ * Returns undici's own `fetch` on the full-undici Node path, or `undefined`
+ * (meaning: use the global `fetch`) in the browser/edge/Bun paths.
+ *
+ * Node's global `fetch` is backed by whatever undici version ships inside that
+ * Node release (6.x on Node 22 … 8.x on Node 26). Our dispatcher — and its
+ * `decompress` interceptor — comes from the npm `undici` package, which is a
+ * different version. Handing an npm-undici dispatcher to a mismatched built-in
+ * client makes gzip responses fail mid-stream with `terminated`. Sourcing
+ * `fetch` from the same npm `undici` keeps the whole request path on one
+ * version and removes the split.
+ *
+ * Only meaningful after {@link getDefaultTransport} has resolved, which is the
+ * one place that populates it.
+ */
+export function getDefaultFetch() {
+    return defaultTransport?.fetch;
 }
 function isNodeEnvironment() {
     return typeof process !== 'undefined' && typeof process.versions?.node === 'string';
 }
-async function createDefaultDispatcher() {
+async function createDefaultTransport() {
     if (!isNodeEnvironment()) {
         return undefined;
     }
     // Dynamic import so non-Node consumers (browser, edge runtimes) don't pull
     // undici into their bundle. `isNodeEnvironment()` above already gated this
     // branch, so undici is safe to load when we get here.
-    const { EnvHttpProxyAgent, interceptors } = await import('undici');
+    const { EnvHttpProxyAgent, interceptors, fetch: undiciFetch } = await import('undici');
     // `EnvHttpProxyAgent` (with `allowH2`) and `interceptors.decompress()` both
     // emit an ExperimentalWarning on first use, so build the whole dispatcher
     // inside the suppression block.
@@ -73,14 +100,21 @@ async function createDefaultDispatcher() {
         // crashing on the missing API. Optional chaining also guards a runtime
         // that omits the `interceptors` export entirely.
         if (typeof interceptors?.decompress !== 'function') {
-            return agent;
+            // Bun: pair the agent with the global `fetch` (undefined), which
+            // decompresses natively.
+            return { dispatcher: agent, fetch: undefined };
         }
         // `interceptors.decompress()` decodes gzip/deflate/br/zstd bodies. On
         // Node 24+, attaching any custom dispatcher to global `fetch` strips
         // `content-encoding` without actually decompressing the body.
         // See https://github.com/Doist/todoist-cli/issues/318.
         const decompress = interceptors.decompress();
-        return agent.compose(decompress);
+        // Pair undici's own `fetch` with this dispatcher so the request client
+        // and the dispatcher stay on one undici version (see `getDefaultFetch`).
+        // The global `fetch` is backed by a different, Node-bundled undici;
+        // mixing the two makes the decompress interceptor terminate gzip
+        // responses on some Node versions.
+        return { dispatcher: agent.compose(decompress), fetch: undiciFetch };
     });
 }
 // `suppressExperimentalWarningsSync` is exported for direct unit testing —

package/dist/types/transport/http-dispatcher.d.ts

@@ -1,4 +1,22 @@
 import type { Dispatcher } from 'undici';
+type UndiciFetch = typeof import('undici').fetch;
+/**
+ * A dispatcher and the `fetch` that must be used with it. `fetch` is undici's
+ * own `fetch` on the full-undici Node path, or `undefined` (meaning: use the
+ * global `fetch`) on the Bun path. The two are cached together so callers can
+ * never observe a dispatcher paired with a mismatched `fetch` — see
+ * {@link getDefaultFetch} for why the pairing matters.
+ */
+type DefaultTransport = {
+    dispatcher: Dispatcher;
+    fetch: UndiciFetch | undefined;
+};
+/**
+ * The default dispatcher and its paired `fetch`, as a single value so the two
+ * are always read consistently. Resolves to `undefined` outside Node (browser/
+ * edge), where callers use the global `fetch` with no dispatcher.
+ */
+export declare function getDefaultTransport(): Promise<DefaultTransport | undefined>;
 export declare function getDefaultDispatcher(): Promise<Dispatcher | undefined>;
 /**
  * Drains the default dispatcher's connection pool. CLIs and scripts should
@@ -7,4 +25,22 @@ export declare function getDefaultDispatcher(): Promise<Dispatcher | undefined>;
  */
 export declare function closeDefaultDispatcher(): Promise<void>;
 export declare function resetDefaultDispatcherForTests(): void;
+/**
+ * The `fetch` implementation that must be used with the default dispatcher.
+ * Returns undici's own `fetch` on the full-undici Node path, or `undefined`
+ * (meaning: use the global `fetch`) in the browser/edge/Bun paths.
+ *
+ * Node's global `fetch` is backed by whatever undici version ships inside that
+ * Node release (6.x on Node 22 … 8.x on Node 26). Our dispatcher — and its
+ * `decompress` interceptor — comes from the npm `undici` package, which is a
+ * different version. Handing an npm-undici dispatcher to a mismatched built-in
+ * client makes gzip responses fail mid-stream with `terminated`. Sourcing
+ * `fetch` from the same npm `undici` keeps the whole request path on one
+ * version and removes the split.
+ *
+ * Only meaningful after {@link getDefaultTransport} has resolved, which is the
+ * one place that populates it.
+ */
+export declare function getDefaultFetch(): UndiciFetch | undefined;
 export declare function suppressExperimentalWarningsSync<T>(fn: () => T): T;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@doist/comms-sdk",
-    "version": "0.7.0",
+    "version": "0.7.1",
     "description": "A TypeScript wrapper for the Comms REST API.",
     "author": "Doist developers",
     "homepage": "https://doist.github.io/comms-sdk-typescript/",