@doist/todoist-api-typescript 6.0.1 → 6.1.5

package/dist/esm/authentication.js

@@ -51,81 +51,76 @@ export function getAuthorizationUrl({ clientId, permissions, state, baseUrl, })
     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) {
+export async function getAuthToken(args, baseUrlOrOptions) {
     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);
+    let baseUrl;
+    let customFetch;
+    if (typeof baseUrlOrOptions === 'string') {
+        // Legacy signature: (args, baseUrl)
+        baseUrl = baseUrlOrOptions;
+        customFetch = undefined;
+    }
+    else if (baseUrlOrOptions) {
+        // New signature: (args, options)
+        baseUrl = baseUrlOrOptions.baseUrl;
+        customFetch = baseUrlOrOptions.customFetch;
+    }
+    try {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: getAuthBaseUri(baseUrl),
+            relativePath: ENDPOINT_GET_TOKEN,
+            apiToken: undefined,
+            payload: args,
+            customFetch,
+        });
+        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;
+    }
+    catch (error) {
+        // Re-throw with custom message for authentication failures
+        const err = error;
+        throw new TodoistRequestError('Authentication token exchange failed.', err.httpStatusCode, err.responseData);
     }
-    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) {
+export async function revokeAuthToken(args, baseUrlOrOptions) {
+    let baseUrl;
+    let customFetch;
+    if (typeof baseUrlOrOptions === 'string') {
+        // Legacy signature: (args, baseUrl)
+        baseUrl = baseUrlOrOptions;
+        customFetch = undefined;
+    }
+    else if (baseUrlOrOptions) {
+        // New signature: (args, options)
+        baseUrl = baseUrlOrOptions.baseUrl;
+        customFetch = baseUrlOrOptions.customFetch;
+    }
     const response = await request({
         httpMethod: 'POST',
         baseUri: getSyncBaseUri(baseUrl),
         relativePath: ENDPOINT_REVOKE_TOKEN,
         apiToken: undefined,
         payload: args,
+        customFetch,
     });
     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) {
+export async function revokeToken(args, baseUrlOrOptions) {
+    let baseUrl;
+    let customFetch;
+    if (typeof baseUrlOrOptions === 'string') {
+        // Legacy signature: (args, baseUrl)
+        baseUrl = baseUrlOrOptions;
+        customFetch = undefined;
+    }
+    else if (baseUrlOrOptions) {
+        // New signature: (args, options)
+        baseUrl = baseUrlOrOptions.baseUrl;
+        customFetch = baseUrlOrOptions.customFetch;
+    }
     const { clientId, clientSecret, token } = args;
     // Create Basic Auth header as per RFC 7009
     const basicAuth = createBasicAuthHeader(clientId, clientSecret);
@@ -146,6 +141,7 @@ export async function revokeToken(args, baseUrl) {
         requestId: undefined,
         hasSyncCommands: false,
         customHeaders: customHeaders,
+        customFetch,
     });
     return isSuccess(response);
 }

package/dist/esm/rest-client.js

@@ -12,9 +12,14 @@ export function paramsSerializer(params) {
             if (Array.isArray(value)) {
                 qs.append(key, value.join(','));
             }
-            else {
+            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();
@@ -58,7 +63,7 @@ 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;
+    const { httpMethod, baseUri, relativePath, apiToken, payload, requestId: initialRequestId, hasSyncCommands, customHeaders, customFetch, } = args;
     // Capture original stack for better error reporting
     const originalStack = new Error();
     try {
@@ -89,24 +94,26 @@ export async function request(args) {
                 }
                 break;
             case 'POST':
-            case 'PUT': {
+            case 'PUT':
+            case 'DELETE': {
                 // 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;
+                // 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;
             }
-            case 'DELETE':
-                // DELETE requests don't have a 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);

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

@@ -1,10 +1,3 @@
-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);
-}
+"use strict";
+// This file is reserved for future test utilities
+// All network mocking is now handled by MSW in msw-setup.ts

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

@@ -1,4 +1,32 @@
 import { setupServer } from 'msw/node';
+import { http, HttpResponse } from 'msw';
+// Request capture storage
+const capturedRequests = [];
+// Helper function to capture requests
+export function captureRequest({ request, body }) {
+    const headers = {};
+    request.headers.forEach((value, key) => {
+        headers[key] = value;
+    });
+    capturedRequests.push({
+        url: request.url,
+        method: request.method,
+        headers,
+        body,
+    });
+}
+// Helper function to get the last captured request
+export function getLastRequest() {
+    return capturedRequests[capturedRequests.length - 1];
+}
+// Helper function to get all captured requests
+export function getAllRequests() {
+    return [...capturedRequests];
+}
+// Helper function to clear captured requests
+export function clearCapturedRequests() {
+    capturedRequests.length = 0;
+}
 // Default handlers for common API responses
 export const handlers = [
 // Default handlers can be added here for common endpoints
@@ -6,17 +34,54 @@ export const handlers = [
 ];
 // Create MSW server instance
 export const server = setupServer(...handlers);
+// Helper to create a resolver function for MSW handlers
+function createResolver(data, status, headers) {
+    return async function resolver({ request }) {
+        let body = undefined;
+        if (request.method !== 'GET') {
+            try {
+                body = await request.json();
+            }
+            catch (_a) {
+                // Body might not be JSON
+                try {
+                    body = await request.text();
+                }
+                catch (_b) {
+                    // Body might be FormData or not parseable
+                }
+            }
+        }
+        captureRequest({ request, body });
+        return HttpResponse.json(data, {
+            status,
+            headers,
+        });
+    };
+}
+// Helper to mock a successful API response
+export function mockApiResponse({ endpoint, data, options = {}, }) {
+    const { status = 200, method = 'GET', headers = {} } = options;
+    const resolver = createResolver(data, status, headers);
+    const httpMethod = method.toLowerCase();
+    server.use(http[httpMethod](endpoint, resolver));
+}
+// Helper to mock an error response
+export function mockApiError({ endpoint, data, status, options = {}, }) {
+    mockApiResponse({ endpoint, data, options: Object.assign(Object.assign({}, options), { status }) });
+}
 // Setup MSW for tests
 beforeAll(() => {
     server.listen({
-        onUnhandledRequest: 'warn', // Log warnings for unhandled requests during development
+        onUnhandledRequest: 'error', // Throw errors for unhandled requests to catch unexpected fetch calls
     });
 });
 afterEach(() => {
     server.resetHandlers(); // Reset handlers between tests
+    clearCapturedRequests(); // Clear captured requests between tests
 });
 afterAll(() => {
     server.close(); // Clean up after all tests
 });
 // Export MSW utilities for use in tests
-export { http, HttpResponse } from 'msw';
+export { http, HttpResponse };

package/dist/esm/test-utils/obsidian-fetch-adapter.js

@@ -0,0 +1,50 @@
+/**
+ * Creates a CustomFetch adapter for Obsidian's requestUrl API.
+ *
+ * This adapter bridges the gap between Obsidian's requestUrl interface and the
+ * standard fetch-like interface expected by the Todoist API SDK.
+ *
+ * Key differences handled by this adapter:
+ * - Obsidian returns response data as properties (response.json, response.text)
+ *   while the SDK expects methods (response.json(), response.text())
+ * - Obsidian's requestUrl bypasses CORS restrictions that would block standard fetch
+ * - Obsidian throws on HTTP errors by default; we set throw: false to handle manually
+ * - Obsidian doesn't provide statusText; we default to empty string
+ *
+ * @example
+ * ```typescript
+ * import { requestUrl } from 'obsidian';
+ * import { createObsidianFetchAdapter } from './obsidian-fetch-adapter.js';
+ *
+ * const api = new TodoistApi('your-token', {
+ *   customFetch: createObsidianFetchAdapter(requestUrl)
+ * });
+ * ```
+ *
+ * @param requestUrl - The Obsidian requestUrl function
+ * @returns A CustomFetch function compatible with the Todoist API SDK
+ */
+export function createObsidianFetchAdapter(requestUrl) {
+    return async (url, options) => {
+        // Build the request parameters in Obsidian's format
+        const requestParams = {
+            url,
+            method: (options === null || options === void 0 ? void 0 : options.method) || 'GET',
+            headers: options === null || options === void 0 ? void 0 : options.headers,
+            body: options === null || options === void 0 ? void 0 : options.body,
+            throw: false, // Don't throw on HTTP errors; let the SDK handle status codes
+        };
+        // Make the request using Obsidian's requestUrl
+        const response = await requestUrl(requestParams);
+        // Transform Obsidian's response format to match CustomFetchResponse interface
+        return {
+            ok: response.status >= 200 && response.status < 300,
+            status: response.status,
+            statusText: '', // Obsidian doesn't provide statusText
+            headers: response.headers,
+            // Wrap Obsidian's direct properties as methods returning promises
+            text: () => Promise.resolve(response.text),
+            json: () => Promise.resolve(response.json),
+        };
+    };
+}