@todoist/sdk 0.0.0-stage → 18.0.0

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

@@ -0,0 +1,216 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { isNetworkError } from '../types/http.js';
+import { getDefaultTransport } from './http-dispatcher.js';
+/**
+ * Default retry configuration matching the original axios-retry behavior
+ */
+const DEFAULT_RETRY_CONFIG = {
+    retries: 3,
+    retryCondition: isNetworkError,
+    retryDelay: (retryNumber) => {
+        // First retry: immediate (0ms delay)
+        // Subsequent retries: 500ms delay
+        return retryNumber === 1 ? 0 : 500;
+    },
+};
+const TIMEOUT_ERROR_NAME = 'TimeoutError';
+function createTimeoutError(timeoutMs) {
+    const error = new Error(`Request timeout after ${timeoutMs}ms`);
+    error.name = TIMEOUT_ERROR_NAME;
+    return error;
+}
+/**
+ * Converts Headers object to a plain object
+ */
+function headersToObject(headers) {
+    const result = {};
+    headers.forEach((value, key) => {
+        result[key] = value;
+    });
+    return result;
+}
+/**
+ * Creates an AbortSignal that aborts after timeoutMs. Returns the signal and a
+ * clear function to cancel the timeout early.
+ */
+function createTimeoutSignal(timeoutMs, existingSignal) {
+    const controller = new AbortController();
+    // Timeout logic
+    const timeoutId = setTimeout(() => {
+        controller.abort(createTimeoutError(timeoutMs));
+    }, timeoutMs);
+    let abortHandler;
+    function clear() {
+        clearTimeout(timeoutId);
+        if (existingSignal && abortHandler) {
+            existingSignal.removeEventListener('abort', abortHandler);
+        }
+    }
+    // If there's an existing signal, forward its abort
+    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 });
+        }
+    }
+    // Clean up timeout when request completes
+    controller.signal.addEventListener('abort', () => {
+        clearTimeout(timeoutId);
+    });
+    return { signal: controller.signal, clear };
+}
+/**
+ * Converts native fetch Response to CustomFetchResponse for consistency
+ */
+function convertResponseToCustomFetch(response) {
+    // Clone the response so we can read it multiple times (if clone method exists)
+    const clonedResponse = response.clone ? response.clone() : response;
+    return {
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        headers: headersToObject(response.headers),
+        text: () => clonedResponse.text(),
+        json: () => response.json(),
+        arrayBuffer: () => response.arrayBuffer(),
+    };
+}
+/**
+ * Performs a fetch request with retry logic and timeout support
+ */
+export async function fetchWithRetry(args) {
+    var _a;
+    const { url, options = {}, retryConfig = {}, customFetch } = args;
+    const config = Object.assign(Object.assign({}, DEFAULT_RETRY_CONFIG), retryConfig);
+    const { timeout, signal: userSignal } = options, fetchOptions = __rest(options, ["timeout", "signal"]);
+    let lastError;
+    for (let attempt = 0; attempt <= config.retries; attempt++) {
+        // Timeout clear function for this attempt (hoisted for catch scope)
+        let clearTimeoutFn;
+        try {
+            // Set up timeout and signal handling
+            let requestSignal = userSignal || undefined;
+            if (timeout && timeout > 0) {
+                const timeoutResult = createTimeoutSignal(timeout, requestSignal);
+                requestSignal = timeoutResult.signal;
+                clearTimeoutFn = timeoutResult.clear;
+            }
+            // Use custom fetch or native fetch
+            let fetchResponse;
+            if (customFetch) {
+                fetchResponse = await customFetch(url, Object.assign(Object.assign({}, fetchOptions), { signal: requestSignal, timeout }));
+            }
+            else {
+                // 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();
+                const nativeFetchOptions = Object.assign(Object.assign({}, fetchOptions), { signal: requestSignal });
+                if ((transport === null || transport === void 0 ? void 0 : transport.dispatcher) !== undefined) {
+                    // @ts-expect-error - dispatcher is a valid option for Node.js fetch but not in the TS types
+                    nativeFetchOptions.dispatcher = transport.dispatcher;
+                }
+                // undici's `fetch` and the global `fetch` are the same function
+                // at runtime but carry different (undici vs DOM) types. Call
+                // through the global signature, which matches the options above.
+                const fetchImpl = ((_a = transport === null || transport === void 0 ? void 0 : transport.fetch) !== null && _a !== void 0 ? _a : fetch);
+                const nativeResponse = await fetchImpl(url, nativeFetchOptions);
+                fetchResponse = convertResponseToCustomFetch(nativeResponse);
+            }
+            // Check if the response is successful
+            if (!fetchResponse.ok) {
+                const errorMessage = `HTTP ${fetchResponse.status}: ${fetchResponse.statusText}`;
+                const error = new Error(errorMessage);
+                error.status = fetchResponse.status;
+                error.statusText = fetchResponse.statusText;
+                error.response = {
+                    data: undefined, // Will be set below if we can parse the response
+                    status: fetchResponse.status,
+                    statusText: fetchResponse.statusText,
+                    headers: fetchResponse.headers,
+                };
+                // Try to get response body for error details
+                try {
+                    const responseText = await fetchResponse.text();
+                    let responseData;
+                    try {
+                        responseData = responseText ? JSON.parse(responseText) : undefined;
+                    }
+                    catch (_b) {
+                        responseData = responseText;
+                    }
+                    error.data = responseData;
+                    error.response.data = responseData;
+                }
+                catch (_c) {
+                    // If we can't read the response body, that's OK
+                }
+                throw error;
+            }
+            // Parse response
+            const responseText = await fetchResponse.text();
+            let data;
+            try {
+                data = responseText ? JSON.parse(responseText) : undefined;
+            }
+            catch (_d) {
+                // If JSON parsing fails, return the raw text
+                data = responseText;
+            }
+            // Success – clear pending timeout (if any) so Node can exit promptly
+            if (clearTimeoutFn) {
+                clearTimeoutFn();
+            }
+            return {
+                data,
+                status: fetchResponse.status,
+                statusText: fetchResponse.statusText,
+                headers: fetchResponse.headers,
+            };
+        }
+        catch (error) {
+            if (clearTimeoutFn) {
+                clearTimeoutFn();
+            }
+            lastError = error;
+            // Check if this error should trigger a retry
+            const shouldRetry = attempt < config.retries && config.retryCondition(lastError);
+            if (!shouldRetry) {
+                // Add network error flag for network errors
+                if (isNetworkError(lastError)) {
+                    const networkError = lastError;
+                    networkError.isNetworkError = true;
+                }
+                throw lastError;
+            }
+            // Wait before retrying
+            const delay = config.retryDelay(attempt + 1);
+            if (delay > 0) {
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    // This should never be reached, but just in case
+    throw lastError || new Error('Request failed after retries');
+}

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

@@ -0,0 +1,140 @@
+import { v4 as uuidv4 } from 'uuid';
+import { API_BASE_URI } from '../consts/endpoints.js';
+import { TodoistRequestError } from '../types/errors.js';
+import { isHttpError, isNetworkError } from '../types/http.js';
+import { camelCaseKeys, snakeCaseKeys } from '../utils/case-conversion.js';
+import { mergeHeaders, resolveCustomHeaders } from '../utils/headers.js';
+import { fetchWithRetry } from './fetch-with-retry.js';
+export function paramsSerializer(params) {
+    const qs = new URLSearchParams();
+    Object.keys(params).forEach((key) => {
+        const value = params[key];
+        if (value !== null && value !== undefined) {
+            if (Array.isArray(value)) {
+                qs.append(key, JSON.stringify(value));
+            }
+            else if (typeof value === 'string' ||
+                typeof value === 'number' ||
+                typeof value === 'boolean') {
+                qs.append(key, String(value));
+            }
+            else {
+                qs.append(key, JSON.stringify(value));
+            }
+        }
+    });
+    return qs.toString();
+}
+const defaultHeaders = {
+    'Content-Type': 'application/json',
+};
+function getAuthHeader(apiKey) {
+    return `Bearer ${apiKey}`;
+}
+function getRetryDelay(retryCount) {
+    return retryCount === 1 ? 0 : 500;
+}
+function getTodoistRequestError(args) {
+    const { error, originalStack } = args;
+    const requestError = new TodoistRequestError(error.message);
+    requestError.stack = originalStack ? originalStack.stack : error.stack;
+    if (isHttpError(error)) {
+        requestError.httpStatusCode = error.status;
+        requestError.responseData = error.data;
+    }
+    return requestError;
+}
+/**
+ * Normalises anything thrown while making an API request into the error a
+ * caller should see: a `TodoistRequestError` (carrying the HTTP status and
+ * response body when there is one) reported against `originalStack`, or a
+ * generic `Error` when the thrown value isn't an `Error` at all.
+ */
+export function toTodoistRequestError(error, originalStack) {
+    if (!(error instanceof Error)) {
+        return new Error('An unknown error occurred during the request');
+    }
+    return getTodoistRequestError({ error, originalStack });
+}
+function getRequestConfiguration(args) {
+    const { baseURL, apiToken, requestId, customHeaders } = args;
+    const authHeader = apiToken ? { Authorization: getAuthHeader(apiToken) } : undefined;
+    const requestIdHeader = requestId ? { 'X-Request-Id': requestId } : undefined;
+    // Custom headers sit below auth and request id so they can never replace them.
+    const headers = mergeHeaders(defaultHeaders, resolveCustomHeaders(customHeaders), authHeader, requestIdHeader);
+    return { baseURL, headers };
+}
+function getHttpClientConfig(args) {
+    const { baseURL, apiToken, requestId, customHeaders } = args;
+    const configuration = getRequestConfiguration({ baseURL, apiToken, requestId, customHeaders });
+    return Object.assign(Object.assign({}, configuration), { timeout: 30000, retry: {
+            retries: 3,
+            retryCondition: isNetworkError,
+            retryDelay: getRetryDelay,
+        } });
+}
+export function isSuccess(response) {
+    return response.status >= 200 && response.status < 300;
+}
+export async function request(args) {
+    const { httpMethod, baseUri, relativePath, apiToken, payload, requestId: initialRequestId, hasSyncCommands, customHeaders, customFetch, opaqueKeyMaps, } = args;
+    // Capture original stack for better error reporting
+    const originalStack = new Error();
+    try {
+        let requestId = initialRequestId;
+        // Sync api don't allow a request id in the CORS
+        if (httpMethod === 'POST' && !requestId && !baseUri.includes(API_BASE_URI)) {
+            requestId = uuidv4();
+        }
+        const config = getHttpClientConfig({ baseURL: baseUri, apiToken, requestId, customHeaders });
+        const url = `${baseUri}${relativePath}`;
+        const fetchOptions = {
+            method: httpMethod,
+            headers: config.headers,
+            timeout: config.timeout,
+        };
+        let finalUrl = url;
+        switch (httpMethod) {
+            case 'GET':
+                // For GET requests, add query parameters to URL
+                if (payload) {
+                    // Convert payload from camelCase to snake_case
+                    const convertedPayload = snakeCaseKeys(payload);
+                    const queryString = paramsSerializer(convertedPayload);
+                    if (queryString) {
+                        const separator = url.includes('?') ? '&' : '?';
+                        finalUrl = `${url}${separator}${queryString}`;
+                    }
+                }
+                break;
+            case 'POST':
+            case 'PUT':
+            case 'PATCH':
+            case 'DELETE': {
+                // Convert payload from camelCase to snake_case
+                // Note: While DELETE with body is uncommon, the Todoist API uses it for some endpoints
+                if (payload) {
+                    const convertedPayload = snakeCaseKeys(payload);
+                    const body = hasSyncCommands
+                        ? JSON.stringify(convertedPayload)
+                        : JSON.stringify(convertedPayload);
+                    fetchOptions.body = body;
+                }
+                break;
+            }
+        }
+        // Make the request
+        const response = await fetchWithRetry({
+            url: finalUrl,
+            options: fetchOptions,
+            retryConfig: config.retry,
+            customFetch,
+        });
+        // Convert snake_case response to camelCase
+        const convertedData = camelCaseKeys(response.data, { opaqueKeyMaps });
+        return Object.assign(Object.assign({}, response), { data: convertedData });
+    }
+    catch (error) {
+        throw toTodoistRequestError(error, originalStack);
+    }
+}

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

@@ -0,0 +1,158 @@
+// Use effectively-disabled keep-alive so short-lived CLI processes do not stay
+// open waiting on idle sockets. Undici requires positive values, so we use 1ms.
+const KEEP_ALIVE_OPTIONS = {
+    keepAliveTimeout: 1,
+    keepAliveMaxTimeout: 1,
+};
+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.
+ *
+ * Use this when supplying a `customFetch` that should still honour the proxy
+ * environment variables (`HTTP_PROXY`, `HTTPS_PROXY`, `NO_PROXY`) and decode
+ * compressed responses the way the SDK does by default.
+ *
+ * Both halves must be used together. `dispatcher` decompresses the response
+ * body itself, so a `fetch` from a different undici build will try to decode
+ * it a second time and the request fails mid-stream with `terminated`. A
+ * `fetch` of `undefined` means the runtime's global `fetch` is the correct
+ * partner for this dispatcher.
+ *
+ * @example
+ * ```ts
+ * const transport = await getDefaultTransport()
+ * const fetchImpl = transport?.fetch ?? fetch
+ * const response = await fetchImpl(url, { ...options, dispatcher: transport?.dispatcher })
+ * ```
+ */
+export function getDefaultTransport() {
+    if (!isNodeEnvironment()) {
+        return Promise.resolve(undefined);
+    }
+    if (!defaultTransportPromise) {
+        defaultTransportPromise = createDefaultTransport()
+            .then((transport) => {
+            defaultTransport = transport;
+            return transport;
+        })
+            .catch((error) => {
+            defaultTransport = undefined;
+            defaultTransportPromise = undefined;
+            throw error;
+        });
+    }
+    return defaultTransportPromise;
+}
+/**
+ * The default dispatcher on its own.
+ *
+ * @deprecated Use {@link getDefaultTransport} instead, which returns this
+ * dispatcher together with the `fetch` it must be used with. Attaching this
+ * dispatcher to the runtime's global `fetch` decodes compressed responses
+ * twice on Node 26 and the request fails with `terminated`.
+ */
+export async function getDefaultDispatcher() {
+    var _a;
+    return (_a = (await getDefaultTransport())) === null || _a === void 0 ? void 0 : _a.dispatcher;
+}
+/**
+ * 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 === null || defaultTransport === void 0 ? void 0 : defaultTransport.fetch;
+}
+export async function resetDefaultDispatcherForTests() {
+    if (!defaultTransportPromise) {
+        return;
+    }
+    const transportPromise = defaultTransportPromise;
+    defaultTransport = undefined;
+    defaultTransportPromise = undefined;
+    await transportPromise.then((transport) => transport.dispatcher.close(), () => undefined);
+}
+async function createDefaultTransport() {
+    // Dynamic import so non-Node consumers (browser, edge runtimes) don't pull
+    // undici into their bundle. `getDefaultTransport` already short-circuits
+    // outside Node, so this branch only runs when undici is safe to load.
+    const { EnvHttpProxyAgent, interceptors, fetch: undiciFetch } = await import('undici');
+    const agent = new EnvHttpProxyAgent(KEEP_ALIVE_OPTIONS);
+    // Some runtimes report `process.versions.node` (so `isNodeEnvironment()`
+    // passes) but ship only a partial undici: `interceptors.decompress` is
+    // absent and dispatchers have no `.compose`. Bun is the common case. There
+    // the proxy agent alone is enough — Bun's `fetch` decompresses
+    // gzip/deflate/br/zstd natively — so skip the interceptor instead of
+    // crashing on the missing API.
+    if (typeof interceptors.decompress !== 'function') {
+        // Bun: pair the agent with the global `fetch` (undefined), which
+        // decompresses natively.
+        return { dispatcher: agent, fetch: undefined };
+    }
+    // Compose the response-decompression interceptor so gzip/deflate/br/zstd
+    // bodies are decoded before consumers parse them. Required on Node 24+:
+    // attaching any custom dispatcher to the global `fetch` strips the
+    // `content-encoding` header but does not actually decompress the body,
+    // so callers receive raw gzipped bytes and `JSON.parse` fails.
+    // See https://github.com/todoist/todoist-cli/issues/318.
+    const decompress = suppressExperimentalWarningsSync(() => interceptors.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 };
+}
+// undici emits an `ExperimentalWarning` the first time `interceptors.decompress()`
+// runs. The interceptor is stable for our gzipped-JSON-over-HTTPS use case;
+// silence the warning during dispatcher init only so it does not leak to every
+// consumer's stderr on the first request.
+//
+// `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.
+//
+// Exported for direct unit testing — the integration path through
+// `getDefaultDispatcher()` cannot reliably exercise the helper because both
+// the dispatcher singleton and undici's internal `warningEmitted` flag are
+// once-per-process.
+export 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;
+    }
+}
+function isNodeEnvironment() {
+    var _a;
+    return typeof process !== 'undefined' && Boolean((_a = process.versions) === null || _a === void 0 ? void 0 : _a.node);
+}

package/dist/esm/transport/sync-request.js

@@ -0,0 +1,106 @@
+import { ENDPOINT_SYNC } from '../consts/endpoints.js';
+import { TodoistArgumentError, TodoistSyncError } from '../types/index.js';
+import { DATE_FORMAT_TO_API, TIME_FORMAT_TO_API, DAY_OF_WEEK_TO_API, } from '../types/sync/index.js';
+import { spreadIfDefined } from '../utils/request-helpers.js';
+import { parseSyncResponse } from '../utils/validators.js';
+import { request } from './http-client.js';
+// An invalid Date would otherwise be sent as `null`, which the API reads as "no expiry".
+function serializeStatusActiveUntil(value) {
+    if (!(value instanceof Date))
+        return value;
+    if (Number.isNaN(value.getTime())) {
+        throw new TodoistArgumentError('status.activeUntil is an invalid Date');
+    }
+    return value.toISOString();
+}
+function serializeUserUpdateArgs(args) {
+    return Object.assign(Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({}, args), spreadIfDefined(args.dateFormat, (v) => ({
+        dateFormat: DATE_FORMAT_TO_API[v],
+    }))), spreadIfDefined(args.timeFormat, (v) => ({
+        timeFormat: TIME_FORMAT_TO_API[v],
+    }))), spreadIfDefined(args.startDay, (v) => ({
+        startDay: DAY_OF_WEEK_TO_API[v],
+    }))), spreadIfDefined(args.nextWeek, (v) => ({
+        nextWeek: DAY_OF_WEEK_TO_API[v],
+    }))), (args.status
+        ? {
+            status: Object.assign(Object.assign({}, args.status), spreadIfDefined(args.status.activeUntil, (v) => ({
+                activeUntil: serializeStatusActiveUntil(v),
+            }))),
+        }
+        : {}));
+}
+function serializeTaskUpdateDateCompleteArgs(args) {
+    return Object.assign(Object.assign(Object.assign({}, args), { isForward: args.isForward ? 1 : 0 }), spreadIfDefined(args.resetSubtasks, (v) => ({
+        resetSubtasks: v ? 1 : 0,
+    })));
+}
+function serializeUpdateGoalsArgs(args) {
+    return Object.assign(Object.assign(Object.assign(Object.assign({}, args), spreadIfDefined(args.vacationMode, (v) => ({ vacationMode: v ? 1 : 0 }))), spreadIfDefined(args.karmaDisabled, (v) => ({
+        karmaDisabled: v ? 1 : 0,
+    }))), spreadIfDefined(args.ignoreDays, (v) => ({
+        ignoreDays: v.map((day) => {
+            const apiValue = DAY_OF_WEEK_TO_API[day];
+            if (apiValue === undefined) {
+                throw new TodoistArgumentError(`Invalid ignoreDays entry "${String(day)}". Expected a DayOfWeek (e.g. "Monday").`);
+            }
+            return apiValue;
+        }),
+    })));
+}
+function preprocessSyncCommands(commands) {
+    return commands.map((cmd) => {
+        if (cmd.type === 'user_update')
+            return Object.assign(Object.assign({}, cmd), { args: serializeUserUpdateArgs(cmd.args) });
+        if (cmd.type === 'item_update_date_complete')
+            return Object.assign(Object.assign({}, cmd), { args: serializeTaskUpdateDateCompleteArgs(cmd.args) });
+        if (cmd.type === 'update_goals')
+            return Object.assign(Object.assign({}, cmd), { args: serializeUpdateGoalsArgs(cmd.args) });
+        return cmd;
+    });
+}
+/**
+ * Response fields keyed by the command `uuid` / `tempId` the caller sent. Their
+ * keys must reach the caller unchanged so each entry can be matched to its
+ * command; camel-casing would rewrite them (`a3bb189e-8bf9-…` → `a3Bb189E8Bf9…`).
+ */
+const COMMAND_KEYED_FIELDS = new Set(['sync_status', 'temp_id_mapping']);
+/**
+ * Makes a request to the Sync API and handles error checking.
+ *
+ * @param ctx - HTTP identity (auth token, sync API base URI, optional custom fetch and headers).
+ * @param syncRequest - The sync request payload.
+ * @param options - Optional request identifier and commands flag.
+ * @returns The sync response data, with `syncStatus` keyed by command `uuid` and
+ * `tempIdMapping` keyed by command `tempId`.
+ * @throws TodoistSyncError if any command failed. Commands are applied
+ * independently, so its `syncStatus` and `tempIdMapping` report the ones that
+ * were applied regardless.
+ */
+export async function performSyncRequest(ctx, syncRequest, options = {}) {
+    var _a, _b;
+    const { requestId, hasSyncCommands = false } = options;
+    const processedRequest = ((_a = syncRequest.commands) === null || _a === void 0 ? void 0 : _a.length)
+        ? Object.assign(Object.assign({}, syncRequest), { commands: preprocessSyncCommands(syncRequest.commands) }) : syncRequest;
+    const response = await request({
+        httpMethod: 'POST',
+        baseUri: ctx.syncApiBase,
+        relativePath: ENDPOINT_SYNC,
+        apiToken: ctx.authToken,
+        customFetch: ctx.customFetch,
+        customHeaders: ctx.customHeaders,
+        payload: processedRequest,
+        requestId: requestId,
+        hasSyncCommands: hasSyncCommands,
+        opaqueKeyMaps: COMMAND_KEYED_FIELDS,
+    });
+    const syncStatus = response.data.syncStatus;
+    const firstFailure = Object.values(syncStatus !== null && syncStatus !== void 0 ? syncStatus : {}).find((status) => status !== 'ok');
+    if (firstFailure) {
+        throw new TodoistSyncError(firstFailure, {
+            syncStatus: syncStatus !== null && syncStatus !== void 0 ? syncStatus : {},
+            tempIdMapping: (_b = response.data.tempIdMapping) !== null && _b !== void 0 ? _b : {},
+        });
+    }
+    return parseSyncResponse(response.data);
+}

package/dist/esm/types/activity/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/activity/requests.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/activity/types.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+/**
+ * Known activity object types, using modern names (`task`, `comment`) rather
+ * than legacy API names (`item`, `note`).
+ */
+export const ACTIVITY_OBJECT_TYPES = ['task', 'comment', 'project'];
+/**
+ * Known activity event types.
+ */
+export const ACTIVITY_EVENT_TYPES = [
+    'added',
+    'updated',
+    'deleted',
+    'completed',
+    'uncompleted',
+    'archived',
+    'unarchived',
+    'shared',
+    'left',
+    'moved',
+];
+/**
+ * Flexible object containing event-specific data.
+ * Uses z.record to accept any properties for forward compatibility.
+ */
+export const ActivityEventExtraDataSchema = z.record(z.string(), z.any()).nullable();
+/**
+ * Activity log event schema. Accepts unknown fields for forward compatibility.
+ */
+export const ActivityEventSchema = z
+    .object({
+    objectType: z.string(),
+    objectId: z.string(),
+    eventType: z.string(),
+    eventDate: z.coerce.date(),
+    id: z
+        .union([z.string(), z.number()])
+        .transform((val) => { var _a; return (_a = val === null || val === void 0 ? void 0 : val.toString()) !== null && _a !== void 0 ? _a : null; })
+        .nullable(),
+    parentProjectId: z.string().nullable(),
+    parentItemId: z.string().nullable(),
+    initiatorId: z.string().nullable(),
+    extraData: ActivityEventExtraDataSchema,
+})
+    .catchall(z.any());

package/dist/esm/types/apps/index.js

@@ -0,0 +1,2 @@
+export * from './types.js';
+export * from './requests.js';

package/dist/esm/types/apps/requests.js

@@ -0,0 +1 @@
+export {};