@doist/todoist-api-typescript 5.8.0 → 6.0.0

package/dist/{utils → cjs/utils}/sanitization.js

@@ -1,36 +1,25 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getSanitizedContent = getSanitizedContent;
 exports.getSanitizedTasks = getSanitizedTasks;
-var BOLD_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*|__|!!)(.+?)(\*\*|__|!!)(?=$|[\s!?,;><:]+)/gi;
-var ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*|_|!)(.+?)(\*|_|!)(?=$|[\s!?,;><:]+)/gi;
-var BOLD_ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*\*|___|!!!)(.+?)(\*\*\*|___|!!!)(?=$|[\s!?,;><:]+)/gi;
-var CODE_BLOCK_FORMAT = /```([\s\S]*?)```/gi;
-var CODE_INLINE_FORMAT = /`([^`]+)`/gi;
-var TODOIST_LINK = /((?:(?:onenote:)?[\w-]+):\/\/[^\s]+)\s+[[(]([^)]+)[\])]/gi;
-var MARKDOWN_LINK = /\[(.+?)\]\((.+?)\)/gi;
-var GMAIL_LINK = /\[\[gmail=(.+?),\s*(.+?)\]\]/gi;
-var OUTLOOK_LINK = /\[\[outlook=(.+?),\s*(.+?)\]\]/gi;
-var THUNDERBIRD_LINK = /\[\[thunderbird\n(.+)\n(.+)\n\s*\]\]/gi;
-var FAKE_SECTION_PREFIX = '* ';
-var FAKE_SECTION_SUFFIX = ':';
+const BOLD_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*|__|!!)(.+?)(\*\*|__|!!)(?=$|[\s!?,;><:]+)/gi;
+const ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*|_|!)(.+?)(\*|_|!)(?=$|[\s!?,;><:]+)/gi;
+const BOLD_ITALIC_FORMAT = /(^|[\s!?,;>:]+)(?:\*\*\*|___|!!!)(.+?)(\*\*\*|___|!!!)(?=$|[\s!?,;><:]+)/gi;
+const CODE_BLOCK_FORMAT = /```([\s\S]*?)```/gi;
+const CODE_INLINE_FORMAT = /`([^`]+)`/gi;
+const TODOIST_LINK = /((?:(?:onenote:)?[\w-]+):\/\/[^\s]+)\s+[[(]([^)]+)[\])]/gi;
+const MARKDOWN_LINK = /\[(.+?)\]\((.+?)\)/gi;
+const GMAIL_LINK = /\[\[gmail=(.+?),\s*(.+?)\]\]/gi;
+const OUTLOOK_LINK = /\[\[outlook=(.+?),\s*(.+?)\]\]/gi;
+const THUNDERBIRD_LINK = /\[\[thunderbird\n(.+)\n(.+)\n\s*\]\]/gi;
+const FAKE_SECTION_PREFIX = '* ';
+const FAKE_SECTION_SUFFIX = ':';
 function removeStyleFormatting(input) {
     if (!input.includes('!') && !input.includes('*') && !input.includes('_')) {
         return input;
     }
     function removeMarkdown(match, prefix, text) {
-        return "".concat(prefix).concat(text);
+        return `${prefix}${text}`;
     }
     input = input.replace(BOLD_ITALIC_FORMAT, removeMarkdown);
     input = input.replace(BOLD_FORMAT, removeMarkdown);
@@ -74,13 +63,13 @@ function removeTodoistLinks(input) {
 }
 function removeAppLinks(input) {
     if (input.includes('gmail')) {
-        input = input.replace(GMAIL_LINK, function (match, id, text) { return text; });
+        input = input.replace(GMAIL_LINK, (match, id, text) => text);
     }
     if (input.includes('outlook')) {
-        input = input.replace(OUTLOOK_LINK, function (match, id, text) { return text; });
+        input = input.replace(OUTLOOK_LINK, (match, id, text) => text);
     }
     if (input.includes('thunderbird')) {
-        input = input.replace(THUNDERBIRD_LINK, function (match, text) { return text; });
+        input = input.replace(THUNDERBIRD_LINK, (match, text) => text);
     }
     return input;
 }
@@ -123,5 +112,5 @@ function getSanitizedContent(input) {
  * @returns Array of tasks with added sanitizedContent property
  */
 function getSanitizedTasks(tasks) {
-    return tasks.map(function (task) { return (__assign(__assign({}, task), { sanitizedContent: getSanitizedContent(task.content) })); });
+    return tasks.map((task) => (Object.assign(Object.assign({}, task), { sanitizedContent: getSanitizedContent(task.content) })));
 }

package/dist/{utils/urlHelpers.js → cjs/utils/url-helpers.js}

@@ -4,7 +4,7 @@ exports.formatDateToYYYYMMDD = formatDateToYYYYMMDD;
 exports.getTaskUrl = getTaskUrl;
 exports.getProjectUrl = getProjectUrl;
 exports.getSectionUrl = getSectionUrl;
-var endpoints_1 = require("../consts/endpoints");
+const endpoints_1 = require("../consts/endpoints");
 /**
  * Formats a Date object to YYYY-MM-DD string format.
  *
@@ -13,10 +13,10 @@ var endpoints_1 = require("../consts/endpoints");
  * @returns The formatted date string in YYYY-MM-DD format.
  */
 function formatDateToYYYYMMDD(date) {
-    var year = date.getFullYear();
-    var month = String(date.getMonth() + 1).padStart(2, '0');
-    var day = String(date.getDate()).padStart(2, '0');
-    return "".concat(year, "-").concat(month, "-").concat(day);
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
 }
 /**
  * Generate the URL for a given task.
@@ -26,9 +26,9 @@ function formatDateToYYYYMMDD(date) {
  * @returns The URL string for the task view.
  */
 function getTaskUrl(taskId, content) {
-    var slug = content ? slugify(content) : undefined;
-    var path = slug ? "".concat(slug, "-").concat(taskId) : taskId;
-    return "".concat(endpoints_1.TODOIST_WEB_URI, "/task/").concat(path);
+    const slug = content ? slugify(content) : undefined;
+    const path = slug ? `${slug}-${taskId}` : taskId;
+    return `${endpoints_1.TODOIST_WEB_URI}/task/${path}`;
 }
 /**
  * Generate the URL for a given project.
@@ -38,9 +38,9 @@ function getTaskUrl(taskId, content) {
  * @returns The URL string for the project view.
  */
 function getProjectUrl(projectId, name) {
-    var slug = name ? slugify(name) : undefined;
-    var path = slug ? "".concat(slug, "-").concat(projectId) : projectId;
-    return "".concat(endpoints_1.TODOIST_WEB_URI, "/project/").concat(path);
+    const slug = name ? slugify(name) : undefined;
+    const path = slug ? `${slug}-${projectId}` : projectId;
+    return `${endpoints_1.TODOIST_WEB_URI}/project/${path}`;
 }
 /**
  * Generate the URL for a given section.
@@ -50,9 +50,9 @@ function getProjectUrl(projectId, name) {
  * @returns The URL string for the section view.
  */
 function getSectionUrl(sectionId, name) {
-    var slug = name ? slugify(name) : undefined;
-    var path = slug ? "".concat(slug, "-").concat(sectionId) : sectionId;
-    return "".concat(endpoints_1.TODOIST_WEB_URI, "/section/").concat(path);
+    const slug = name ? slugify(name) : undefined;
+    const path = slug ? `${slug}-${sectionId}` : sectionId;
+    return `${endpoints_1.TODOIST_WEB_URI}/section/${path}`;
 }
 /**
  * Slugify function borrowed from Django.
@@ -62,7 +62,7 @@ function getSectionUrl(sectionId, name) {
  */
 function slugify(value) {
     // Convert to ASCII
-    var result = value.normalize('NFKD').replace(/[\u0300-\u036f]/g, '');
+    let result = value.normalize('NFKD').replace(/[\u0300-\u036f]/g, '');
     // Remove non-ASCII characters
     result = result.replace(/[^\x20-\x7E]/g, '');
     // Convert to lowercase and replace non-alphanumeric characters with dashes

package/dist/{utils → cjs/utils}/validators.js

@@ -19,7 +19,13 @@ exports.validateCurrentUser = validateCurrentUser;
 exports.validateActivityEvent = validateActivityEvent;
 exports.validateActivityEventArray = validateActivityEventArray;
 exports.validateAttachment = validateAttachment;
-var entities_1 = require("../types/entities");
+exports.validateWorkspaceUser = validateWorkspaceUser;
+exports.validateWorkspaceUserArray = validateWorkspaceUserArray;
+exports.validateWorkspaceInvitation = validateWorkspaceInvitation;
+exports.validateWorkspaceInvitationArray = validateWorkspaceInvitationArray;
+exports.validateWorkspacePlanDetails = validateWorkspacePlanDetails;
+exports.validateJoinWorkspaceResult = validateJoinWorkspaceResult;
+const entities_1 = require("../types/entities");
 function validateTask(input) {
     return entities_1.TaskSchema.parse(input);
 }
@@ -95,3 +101,24 @@ function validateActivityEventArray(input) {
 function validateAttachment(input) {
     return entities_1.AttachmentSchema.parse(input);
 }
+function validateWorkspaceUser(input) {
+    return entities_1.WorkspaceUserSchema.parse(input);
+}
+function validateWorkspaceUserArray(input) {
+    if (!Array.isArray(input)) {
+        throw new Error(`Expected array for workspace users, got ${typeof input}`);
+    }
+    return input.map(validateWorkspaceUser);
+}
+function validateWorkspaceInvitation(input) {
+    return entities_1.WorkspaceInvitationSchema.parse(input);
+}
+function validateWorkspaceInvitationArray(input) {
+    return input.map(validateWorkspaceInvitation);
+}
+function validateWorkspacePlanDetails(input) {
+    return entities_1.WorkspacePlanDetailsSchema.parse(input);
+}
+function validateJoinWorkspaceResult(input) {
+    return entities_1.JoinWorkspaceResultSchema.parse(input);
+}

package/dist/esm/authentication.js

@@ -0,0 +1,151 @@
+import { request, isSuccess } from './rest-client.js';
+import { v4 as uuid } from 'uuid';
+import { TodoistRequestError } from './types/index.js';
+import { getAuthBaseUri, getSyncBaseUri, ENDPOINT_AUTHORIZATION, ENDPOINT_GET_TOKEN, ENDPOINT_REVOKE_TOKEN, ENDPOINT_REVOKE, } from './consts/endpoints.js';
+/**
+ * Creates a Basic Authentication header value from client credentials.
+ * @param clientId - The OAuth client ID
+ * @param clientSecret - The OAuth client secret
+ * @returns The Basic Auth header value (without the 'Basic ' prefix)
+ */
+function createBasicAuthHeader(clientId, clientSecret) {
+    const credentials = `${clientId}:${clientSecret}`;
+    return Buffer.from(credentials).toString('base64');
+}
+/**
+ * Generates a random state parameter for OAuth2 authorization.
+ * The state parameter helps prevent CSRF attacks.
+ *
+ * @example
+ * ```typescript
+ * const state = getAuthStateParameter()
+ * // Store state in session
+ * const authUrl = getAuthorizationUrl(clientId, ['data:read'], state)
+ * ```
+ *
+ * @returns A random UUID v4 string
+ */
+export function getAuthStateParameter() {
+    return uuid();
+}
+/**
+ * Generates the authorization URL for the OAuth2 flow.
+ *
+ * @example
+ * ```typescript
+ * const url = getAuthorizationUrl(
+ *   'your-client-id',
+ *   ['data:read', 'task:add'],
+ *   state
+ * )
+ * // Redirect user to url
+ * ```
+ *
+ * @returns The full authorization URL to redirect users to
+ * @see https://todoist.com/api/v1/docs#tag/Authorization/OAuth
+ */
+export function getAuthorizationUrl({ clientId, permissions, state, baseUrl, }) {
+    if (!(permissions === null || permissions === void 0 ? void 0 : permissions.length)) {
+        throw new Error('At least one scope value should be passed for permissions.');
+    }
+    const scope = permissions.join(',');
+    return `${getAuthBaseUri(baseUrl)}${ENDPOINT_AUTHORIZATION}?client_id=${clientId}&scope=${scope}&state=${state}`;
+}
+/**
+ * Exchanges an authorization code for an access token.
+ *
+ * @example
+ * ```typescript
+ * const { accessToken } = await getAuthToken({
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   code: authCode
+ * })
+ * ```
+ *
+ * @returns The access token response
+ * @throws {@link TodoistRequestError} If the token exchange fails
+ */
+export async function getAuthToken(args, baseUrl) {
+    var _a;
+    const response = await request({
+        httpMethod: 'POST',
+        baseUri: getAuthBaseUri(baseUrl),
+        relativePath: ENDPOINT_GET_TOKEN,
+        apiToken: undefined,
+        payload: args,
+    });
+    if (response.status !== 200 || !((_a = response.data) === null || _a === void 0 ? void 0 : _a.accessToken)) {
+        throw new TodoistRequestError('Authentication token exchange failed.', response.status, response.data);
+    }
+    return response.data;
+}
+/**
+ * Revokes an access token, making it invalid for future use.
+ *
+ * @example
+ * ```typescript
+ * await revokeAuthToken({
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   accessToken: token
+ * })
+ * ```
+ *
+ * @deprecated Use {@link revokeToken} instead. This function uses a legacy endpoint that will be removed in a future version. The new function uses the RFC 7009 compliant endpoint.
+ * @returns True if revocation was successful
+ * @see https://todoist.com/api/v1/docs#tag/Authorization/operation/revoke_access_token_api_api_v1_access_tokens_delete
+ */
+export async function revokeAuthToken(args, baseUrl) {
+    const response = await request({
+        httpMethod: 'POST',
+        baseUri: getSyncBaseUri(baseUrl),
+        relativePath: ENDPOINT_REVOKE_TOKEN,
+        apiToken: undefined,
+        payload: args,
+    });
+    return isSuccess(response);
+}
+/**
+ * Revokes a token using the RFC 7009 OAuth 2.0 Token Revocation standard.
+ *
+ * This function uses HTTP Basic Authentication with client credentials and follows
+ * the RFC 7009 specification for token revocation.
+ *
+ * @example
+ * ```typescript
+ * await revokeToken({
+ *   clientId: 'your-client-id',
+ *   clientSecret: 'your-client-secret',
+ *   token: 'access-token-to-revoke'
+ * })
+ * ```
+ *
+ * @returns True if revocation was successful
+ * @see https://datatracker.ietf.org/doc/html/rfc7009
+ * @see https://todoist.com/api/v1/docs#tag/Authorization
+ */
+export async function revokeToken(args, baseUrl) {
+    const { clientId, clientSecret, token } = args;
+    // Create Basic Auth header as per RFC 7009
+    const basicAuth = createBasicAuthHeader(clientId, clientSecret);
+    const customHeaders = {
+        Authorization: `Basic ${basicAuth}`,
+    };
+    // Request body only contains the token and optional token_type_hint
+    const requestBody = {
+        token,
+        token_type_hint: 'access_token',
+    };
+    const response = await request({
+        httpMethod: 'POST',
+        baseUri: getSyncBaseUri(baseUrl),
+        relativePath: ENDPOINT_REVOKE,
+        apiToken: undefined,
+        payload: requestBody,
+        requestId: undefined,
+        hasSyncCommands: false,
+        customHeaders: customHeaders,
+    });
+    return isSuccess(response);
+}

package/dist/esm/consts/endpoints.js

@@ -0,0 +1,65 @@
+const BASE_URI = 'https://api.todoist.com';
+const TODOIST_URI = 'https://todoist.com';
+export const TODOIST_WEB_URI = 'https://app.todoist.com/app';
+// The API version is not configurable, to ensure
+// compatibility between the API and the client.
+export const API_VERSION = 'v1';
+export const API_BASE_URI = `/api/${API_VERSION}/`;
+const API_AUTHORIZATION_BASE_URI = '/oauth/';
+export function getSyncBaseUri(domainBase = BASE_URI) {
+    return new URL(API_BASE_URI, domainBase).toString();
+}
+export function getAuthBaseUri(domainBase = TODOIST_URI) {
+    return new URL(API_AUTHORIZATION_BASE_URI, domainBase).toString();
+}
+export const ENDPOINT_REST_TASKS = 'tasks';
+export const ENDPOINT_REST_TASKS_FILTER = ENDPOINT_REST_TASKS + '/filter';
+export const ENDPOINT_REST_TASKS_COMPLETED_BY_COMPLETION_DATE = ENDPOINT_REST_TASKS + '/completed/by_completion_date';
+export const ENDPOINT_REST_TASKS_COMPLETED_BY_DUE_DATE = ENDPOINT_REST_TASKS + '/completed/by_due_date';
+export const ENDPOINT_REST_TASKS_COMPLETED_SEARCH = 'completed/search';
+export const ENDPOINT_REST_SECTIONS = 'sections';
+export const ENDPOINT_REST_LABELS = 'labels';
+export const ENDPOINT_REST_LABELS_SHARED = ENDPOINT_REST_LABELS + '/shared';
+export const ENDPOINT_REST_LABELS_SHARED_RENAME = ENDPOINT_REST_LABELS_SHARED + '/rename';
+export const ENDPOINT_REST_LABELS_SHARED_REMOVE = ENDPOINT_REST_LABELS_SHARED + '/remove';
+export const ENDPOINT_REST_COMMENTS = 'comments';
+export const ENDPOINT_REST_TASK_CLOSE = 'close';
+export const ENDPOINT_REST_TASK_REOPEN = 'reopen';
+export const ENDPOINT_REST_TASK_MOVE = 'move';
+export const ENDPOINT_REST_PROJECTS = 'projects';
+export const ENDPOINT_REST_PROJECTS_ARCHIVED = ENDPOINT_REST_PROJECTS + '/archived';
+export const ENDPOINT_REST_PROJECT_COLLABORATORS = 'collaborators';
+export const ENDPOINT_REST_USER = 'user';
+export const ENDPOINT_REST_PRODUCTIVITY = ENDPOINT_REST_TASKS + '/completed/stats';
+export const ENDPOINT_REST_ACTIVITIES = 'activities';
+export const ENDPOINT_REST_UPLOADS = 'uploads';
+export const PROJECT_ARCHIVE = 'archive';
+export const PROJECT_UNARCHIVE = 'unarchive';
+export const ENDPOINT_SYNC_QUICK_ADD = ENDPOINT_REST_TASKS + '/quick';
+export const ENDPOINT_SYNC = 'sync';
+export const ENDPOINT_AUTHORIZATION = 'authorize';
+export const ENDPOINT_GET_TOKEN = 'access_token';
+export const ENDPOINT_REVOKE_TOKEN = 'access_tokens/revoke';
+export const ENDPOINT_REVOKE = 'revoke';
+// Workspace endpoints
+export const ENDPOINT_WORKSPACE_INVITATIONS = 'workspaces/invitations';
+export const ENDPOINT_WORKSPACE_INVITATIONS_ALL = 'workspaces/invitations/all';
+export const ENDPOINT_WORKSPACE_INVITATIONS_DELETE = 'workspaces/invitations/delete';
+export const ENDPOINT_WORKSPACE_JOIN = 'workspaces/join';
+export const ENDPOINT_WORKSPACE_LOGO = 'workspaces/logo';
+export const ENDPOINT_WORKSPACE_PLAN_DETAILS = 'workspaces/plan_details';
+export const ENDPOINT_WORKSPACE_USERS = 'workspaces/users';
+// Workspace invitation actions (require invite_code parameter)
+export function getWorkspaceInvitationAcceptEndpoint(inviteCode) {
+    return `workspaces/invitations/${inviteCode}/accept`;
+}
+export function getWorkspaceInvitationRejectEndpoint(inviteCode) {
+    return `workspaces/invitations/${inviteCode}/reject`;
+}
+// Workspace projects (require workspace_id parameter)
+export function getWorkspaceActiveProjectsEndpoint(workspaceId) {
+    return `workspaces/${workspaceId}/projects/active`;
+}
+export function getWorkspaceArchivedProjectsEndpoint(workspaceId) {
+    return `workspaces/${workspaceId}/projects/archived`;
+}

package/dist/esm/index.js

@@ -0,0 +1,4 @@
+export * from './todoist-api.js';
+export * from './authentication.js';
+export * from './types/index.js';
+export * from './utils/index.js';

package/dist/esm/rest-client.js

@@ -0,0 +1,119 @@
+import { TodoistRequestError } from './types/errors.js';
+import { isNetworkError, isHttpError } from './types/http.js';
+import { v4 as uuidv4 } from 'uuid';
+import { API_BASE_URI } from './consts/endpoints.js';
+import { camelCaseKeys, snakeCaseKeys } from './utils/case-conversion.js';
+import { fetchWithRetry } from './utils/fetch-with-retry.js';
+export 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(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;
+}
+function getRequestConfiguration(args) {
+    const { baseURL, apiToken, requestId, customHeaders } = args;
+    const authHeader = apiToken ? { Authorization: getAuthHeader(apiToken) } : undefined;
+    const requestIdHeader = requestId ? { 'X-Request-Id': requestId } : undefined;
+    const headers = Object.assign(Object.assign(Object.assign(Object.assign({}, defaultHeaders), authHeader), requestIdHeader), customHeaders);
+    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, } = 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) {
+                    const queryString = paramsSerializer(payload);
+                    if (queryString) {
+                        const separator = url.includes('?') ? '&' : '?';
+                        finalUrl = `${url}${separator}${queryString}`;
+                    }
+                }
+                break;
+            case 'POST':
+            case 'PUT': {
+                // Convert payload from camelCase to snake_case
+                const convertedPayload = payload ? snakeCaseKeys(payload) : payload;
+                const body = hasSyncCommands
+                    ? JSON.stringify(convertedPayload)
+                    : JSON.stringify(convertedPayload);
+                fetchOptions.body = body;
+                break;
+            }
+            case 'DELETE':
+                // DELETE requests don't have a body
+                break;
+        }
+        // Make the request
+        const response = await fetchWithRetry({
+            url: finalUrl,
+            options: fetchOptions,
+            retryConfig: config.retry,
+        });
+        // Convert snake_case response to camelCase
+        const convertedData = camelCaseKeys(response.data);
+        return Object.assign(Object.assign({}, response), { data: convertedData });
+    }
+    catch (error) {
+        if (!(error instanceof Error)) {
+            throw new Error('An unknown error occurred during the request');
+        }
+        throw getTodoistRequestError({ error, originalStack });
+    }
+}

package/dist/esm/test-utils/asserts.js

@@ -0,0 +1,8 @@
+// Has to use 'any' to express constructor type
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function assertInstance(value, type) {
+    if (value instanceof type) {
+        return;
+    }
+    throw new TypeError(`Unexpected type ${typeof value}`);
+}

package/dist/esm/test-utils/mocks.js

@@ -0,0 +1,10 @@
+import * as restClient from '../rest-client.js';
+export function setupRestClientMock(responseData, status = 200) {
+    const response = {
+        status,
+        statusText: status === 200 ? 'OK' : 'Error',
+        headers: {},
+        data: responseData,
+    };
+    return jest.spyOn(restClient, 'request').mockResolvedValue(response);
+}

package/dist/esm/test-utils/msw-setup.js

@@ -0,0 +1,22 @@
+import { setupServer } from 'msw/node';
+// Default handlers for common API responses
+export const handlers = [
+// Default handlers can be added here for common endpoints
+// Individual test files will add their own specific handlers
+];
+// Create MSW server instance
+export const server = setupServer(...handlers);
+// Setup MSW for tests
+beforeAll(() => {
+    server.listen({
+        onUnhandledRequest: 'warn', // Log warnings for unhandled requests during development
+    });
+});
+afterEach(() => {
+    server.resetHandlers(); // Reset handlers between tests
+});
+afterAll(() => {
+    server.close(); // Clean up after all tests
+});
+// Export MSW utilities for use in tests
+export { http, HttpResponse } from 'msw';