@doist/comms-sdk 0.0.1 → 0.2.0

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

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchWithRetry = fetchWithRetry;
+const errors_1 = require("../types/errors");
+const case_conversion_1 = require("../utils/case-conversion");
+const timestamp_conversion_1 = require("../utils/timestamp-conversion");
+const http_dispatcher_1 = require("./http-dispatcher");
+async function fetchWithRetry(url, options, maxRetries = 3, customFetch) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        let clearTimeoutFn;
+        try {
+            let requestSignal = options.signal || undefined;
+            if (options.timeout && options.timeout > 0) {
+                const timeoutResult = createTimeoutSignal(options.timeout, requestSignal);
+                requestSignal = timeoutResult.signal;
+                clearTimeoutFn = timeoutResult.clear;
+            }
+            const response = customFetch
+                ? await customFetch(url, options)
+                : await fetchWithDefaultTransport(url, options, requestSignal);
+            const responseText = await response.text();
+            let responseData;
+            try {
+                responseData = responseText ? JSON.parse(responseText) : undefined;
+            }
+            catch {
+                responseData = responseText;
+            }
+            if (!response.ok) {
+                throw new errors_1.CommsRequestError(`Request failed with status ${response.status}`, response.status, responseData);
+            }
+            const camelCased = (0, case_conversion_1.camelCaseKeys)(responseData);
+            const transformed = (0, timestamp_conversion_1.transformTimestamps)(camelCased);
+            if (clearTimeoutFn) {
+                clearTimeoutFn();
+            }
+            return {
+                data: transformed,
+                status: response.status,
+                headers: response.headers,
+            };
+        }
+        catch (error) {
+            if (clearTimeoutFn) {
+                clearTimeoutFn();
+            }
+            lastError = error instanceof Error ? error : new Error('Unknown error');
+            if (attempt < maxRetries && isNetworkError(lastError)) {
+                const delay = getRetryDelay(attempt + 1);
+                if (delay > 0) {
+                    await sleep(delay);
+                }
+                continue;
+            }
+            break;
+        }
+    }
+    if (lastError instanceof errors_1.CommsRequestError) {
+        throw lastError;
+    }
+    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, {
+            ...options,
+            signal,
+            // @ts-expect-error - dispatcher is valid for Node.js fetch but not in TS types
+            dispatcher,
+        })
+        : await fetch(url, {
+            ...options,
+            signal,
+        });
+    return convertResponseToCustomFetch(response);
+}
+async function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+const timeoutErrorName = 'TimeoutError';
+function createTimeoutError(timeoutMs) {
+    const error = new Error(`Request timeout after ${timeoutMs}ms`);
+    error.name = timeoutErrorName;
+    return error;
+}
+function isNetworkError(error) {
+    return (error.name === 'TypeError' ||
+        error.name === timeoutErrorName ||
+        error.message.toLowerCase().includes('network'));
+}
+function getRetryDelay(retryCount) {
+    return retryCount === 1 ? 0 : 500;
+}
+function createTimeoutSignal(timeoutMs, existingSignal) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => {
+        controller.abort(createTimeoutError(timeoutMs));
+    }, timeoutMs);
+    let abortHandler;
+    function clear() {
+        clearTimeout(timeoutId);
+        if (existingSignal && abortHandler) {
+            existingSignal.removeEventListener('abort', abortHandler);
+        }
+    }
+    if (existingSignal) {
+        if (existingSignal.aborted) {
+            clearTimeout(timeoutId);
+            controller.abort(existingSignal.reason);
+        }
+        else {
+            abortHandler = () => {
+                clearTimeout(timeoutId);
+                controller.abort(existingSignal.reason);
+            };
+            existingSignal.addEventListener('abort', abortHandler, { once: true });
+        }
+    }
+    return { signal: controller.signal, clear };
+}
+function convertResponseToCustomFetch(response) {
+    const headers = {};
+    response.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+        text: () => response.clone().text(),
+        json: () => response.json(),
+    };
+}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paramsSerializer = paramsSerializer;
+exports.request = request;
+exports.isSuccess = isSuccess;
+const case_conversion_1 = require("../utils/case-conversion");
+const fetch_with_retry_1 = require("./fetch-with-retry");
+function paramsSerializer(params) {
+    const qs = new URLSearchParams();
+    Object.keys(params).forEach((key) => {
+        const value = params[key];
+        if (value != null) {
+            if (Array.isArray(value)) {
+                qs.append(key, value.join(','));
+            }
+            else {
+                qs.append(key, String(value));
+            }
+        }
+    });
+    return qs.toString();
+}
+const defaultHeaders = {
+    'Content-Type': 'application/json',
+};
+function getAuthHeader(apiToken) {
+    return `Bearer ${apiToken}`;
+}
+function getRequestConfiguration(baseURL, apiToken, requestId) {
+    const authHeader = apiToken ? { Authorization: getAuthHeader(apiToken) } : undefined;
+    const requestIdHeader = requestId ? { 'X-Request-Id': requestId } : undefined;
+    const headers = { ...defaultHeaders, ...authHeader, ...requestIdHeader };
+    return { baseURL, headers, timeout: 30000 };
+}
+async function request(args) {
+    const { httpMethod, baseUri, relativePath, apiToken, payload, requestId, customFetch } = args;
+    const config = getRequestConfiguration(baseUri, apiToken, requestId);
+    const url = new URL(relativePath, config.baseURL).toString();
+    const options = {
+        method: httpMethod,
+        headers: config.headers,
+        timeout: config.timeout,
+    };
+    if (httpMethod === 'GET' && payload) {
+        const searchParams = paramsSerializer((0, case_conversion_1.snakeCaseKeys)(payload));
+        const urlWithParams = searchParams ? `${url}?${searchParams}` : url;
+        return (0, fetch_with_retry_1.fetchWithRetry)(urlWithParams, options, 3, customFetch);
+    }
+    if (payload && httpMethod !== 'GET') {
+        options.body = JSON.stringify((0, case_conversion_1.snakeCaseKeys)(payload));
+    }
+    return (0, fetch_with_retry_1.fetchWithRetry)(url, options, 3, customFetch);
+}
+function isSuccess(response) {
+    return response.status >= 200 && response.status < 300;
+}

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

@@ -0,0 +1,143 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultDispatcher = getDefaultDispatcher;
+exports.closeDefaultDispatcher = closeDefaultDispatcher;
+exports.resetDefaultDispatcherForTests = resetDefaultDispatcherForTests;
+exports.suppressExperimentalWarningsSync = suppressExperimentalWarningsSync;
+let defaultDispatcher;
+let defaultDispatcherPromise;
+async function getDefaultDispatcher() {
+    if (defaultDispatcher) {
+        return defaultDispatcher;
+    }
+    if (!defaultDispatcherPromise) {
+        defaultDispatcherPromise = createDefaultDispatcher()
+            .then((dispatcher) => {
+            defaultDispatcher = dispatcher;
+            return dispatcher;
+        })
+            .catch((error) => {
+            defaultDispatcher = undefined;
+            defaultDispatcherPromise = undefined;
+            throw error;
+        });
+    }
+    return defaultDispatcherPromise;
+}
+/**
+ * Drains the default dispatcher's connection pool. CLIs and scripts should
+ * `await` this before exit so Node's event loop empties immediately instead
+ * of waiting ~4s on keep-alive. No-op in the browser branch.
+ */
+async function closeDefaultDispatcher() {
+    // Clear the singleton *before* awaiting init, so any concurrent
+    // `getDefaultDispatcher()` 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;
+    if (!initPromise)
+        return;
+    try {
+        const dispatcher = await initPromise;
+        if (dispatcher) {
+            await dispatcher.close();
+        }
+    }
+    catch {
+        // init failed; nothing to close
+    }
+}
+function resetDefaultDispatcherForTests() {
+    defaultDispatcher = undefined;
+    defaultDispatcherPromise = undefined;
+}
+function isNodeEnvironment() {
+    return typeof process !== 'undefined' && typeof process.versions?.node === 'string';
+}
+async function createDefaultDispatcher() {
+    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')));
+    // `allowH2: true` opts into HTTP/2 via ALPN; undici falls back to h1.1
+    // when the server doesn't negotiate h2. Without this flag undici
+    // defaults to h1.1 even when the server supports h2.
+    //
+    // `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.
+    //
+    // Both emit ExperimentalWarning on first use; suppressed during init.
+    return suppressExperimentalWarningsSync(() => {
+        const decompress = interceptors.decompress();
+        return new EnvHttpProxyAgent({ allowH2: true }).compose(decompress);
+    });
+}
+// `suppressExperimentalWarningsSync` is exported for direct unit testing —
+// the integration path through `getDefaultDispatcher()` can't reliably
+// exercise it because both the dispatcher singleton and undici's internal
+// `warningEmitted` flag are once-per-process.
+//
+// `fn` must be synchronous so the override covers a single critical section
+// (microseconds) — no unrelated `ExperimentalWarning` from elsewhere can
+// interleave and be lost. We suppress every `ExperimentalWarning` rather than
+// pattern-matching the message text: the message wording is an undici
+// implementation detail (not a stable API), and the suppression window is
+// narrow enough that a coarse type filter is safe.
+function suppressExperimentalWarningsSync(fn) {
+    const originalEmit = process.emitWarning;
+    process.emitWarning = ((warning, typeOrOptions, ...rest) => {
+        const type = typeof typeOrOptions === 'string'
+            ? typeOrOptions
+            : typeof typeOrOptions === 'object' && typeOrOptions !== null
+                ? typeOrOptions.type
+                : undefined;
+        if (type === 'ExperimentalWarning')
+            return;
+        originalEmit.call(process, warning, typeOrOptions, ...rest);
+    });
+    try {
+        return fn();
+    }
+    finally {
+        process.emitWarning = originalEmit;
+    }
+}

package/dist/cjs/types/api-version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_API_VERSION = exports.API_VERSIONS = void 0;
+/**
+ * Supported Comms API versions
+ */
+exports.API_VERSIONS = ['v1'];
+exports.DEFAULT_API_VERSION = 'v1';