@doist/todoist-api-typescript 5.8.0 → 6.0.0

package/dist/esm/utils/colors.js

@@ -0,0 +1,215 @@
+export const berryRed = {
+    id: 30,
+    key: 'berry_red',
+    displayName: 'Berry Red',
+    name: 'Berry Red',
+    hexValue: '#b8255f',
+    value: '#b8255f',
+};
+export const red = {
+    id: 31,
+    key: 'red',
+    displayName: 'Red',
+    name: 'Red',
+    hexValue: '#db4035',
+    value: '#db4035',
+};
+export const orange = {
+    id: 32,
+    key: 'orange',
+    displayName: 'Orange',
+    name: 'Orange',
+    hexValue: '#ff9933',
+    value: '#ff9933',
+};
+export const yellow = {
+    id: 33,
+    key: 'yellow',
+    displayName: 'Yellow',
+    name: 'Yellow',
+    hexValue: '#fad000',
+    value: '#fad000',
+};
+export const oliveGreen = {
+    id: 34,
+    key: 'olive_green',
+    displayName: 'Olive Green',
+    name: 'Olive Green',
+    hexValue: '#afb83b',
+    value: '#afb83b',
+};
+export const limeGreen = {
+    id: 35,
+    key: 'lime_green',
+    displayName: 'Lime Green',
+    name: 'Lime Green',
+    hexValue: '#7ecc49',
+    value: '#7ecc49',
+};
+export const green = {
+    id: 36,
+    key: 'green',
+    displayName: 'Green',
+    name: 'Green',
+    hexValue: '#299438',
+    value: '#299438',
+};
+export const mintGreen = {
+    id: 37,
+    key: 'mint_green',
+    displayName: 'Mint Green',
+    name: 'Mint Green',
+    hexValue: '#6accbc',
+    value: '#6accbc',
+};
+export const turquoise = {
+    id: 38,
+    key: 'turquoise',
+    displayName: 'Turquoise',
+    name: 'Turquoise',
+    hexValue: '#158fad',
+    value: '#158fad',
+};
+export const skyBlue = {
+    id: 39,
+    key: 'sky_blue',
+    displayName: 'Sky Blue',
+    name: 'Sky Blue',
+    hexValue: '#14aaf5',
+    value: '#14aaf5',
+};
+export const lightBlue = {
+    id: 40,
+    key: 'light_blue',
+    displayName: 'Light Blue',
+    name: 'Light Blue',
+    hexValue: '#96c3eb',
+    value: '#96c3eb',
+};
+export const blue = {
+    id: 41,
+    key: 'blue',
+    displayName: 'Blue',
+    name: 'Blue',
+    hexValue: '#4073ff',
+    value: '#4073ff',
+};
+export const grape = {
+    id: 42,
+    key: 'grape',
+    displayName: 'Grape',
+    name: 'Grape',
+    hexValue: '#884dff',
+    value: '#884dff',
+};
+export const violet = {
+    id: 43,
+    key: 'violet',
+    displayName: 'Violet',
+    name: 'Violet',
+    hexValue: '#af38eb',
+    value: '#af38eb',
+};
+export const lavender = {
+    id: 44,
+    key: 'lavender',
+    displayName: 'Lavender',
+    name: 'Lavender',
+    hexValue: '#eb96eb',
+    value: '#eb96eb',
+};
+export const magenta = {
+    id: 45,
+    key: 'magenta',
+    displayName: 'Magenta',
+    name: 'Magenta',
+    hexValue: '#e05194',
+    value: '#e05194',
+};
+export const salmon = {
+    id: 46,
+    key: 'salmon',
+    displayName: 'Salmon',
+    name: 'Salmon',
+    hexValue: '#ff8d85',
+    value: '#ff8d85',
+};
+export const charcoal = {
+    id: 47,
+    key: 'charcoal',
+    displayName: 'Charcoal',
+    name: 'Charcoal',
+    hexValue: '#808080',
+    value: '#808080',
+};
+export const gray = {
+    id: 48,
+    key: 'gray',
+    displayName: 'Gray',
+    name: 'Gray',
+    hexValue: '#b8b8b8',
+    value: '#b8b8b8',
+};
+export const taupe = {
+    id: 49,
+    key: 'taupe',
+    displayName: 'Taupe',
+    name: 'Taupe',
+    hexValue: '#ccac93',
+    value: '#ccac93',
+};
+export const colors = [
+    berryRed,
+    red,
+    orange,
+    yellow,
+    oliveGreen,
+    limeGreen,
+    green,
+    mintGreen,
+    turquoise,
+    skyBlue,
+    lightBlue,
+    blue,
+    grape,
+    violet,
+    lavender,
+    magenta,
+    salmon,
+    charcoal,
+    gray,
+    taupe,
+];
+export const defaultColor = charcoal;
+/**
+ * @private
+ * @deprecated Use {@link getColorByKey} instead
+ */
+export function getColorById(colorId) {
+    const color = colors.find((color) => color.id === colorId);
+    return color !== null && color !== void 0 ? color : defaultColor;
+}
+/**
+ * @private
+ * @deprecated Use {@link getColorByKey} instead
+ */
+export function getColorByName(colorName) {
+    const color = colors.find((color) => color.name === colorName);
+    return color !== null && color !== void 0 ? color : defaultColor;
+}
+/**
+ * Retrieves a {@link Color} object by its key identifier.
+ *
+ * @param colorKey - The unique key identifier of the color to find (e.g., 'berry_red', 'sky_blue')
+ * @returns The matching Color object if found, otherwise returns the default color (charcoal)
+ *
+ * @example
+ * ```typescript
+ * const color = getColorByKey('berry_red');
+ * console.log(color.hexValue); // '#b8255f'
+ * ```
+ */
+export function getColorByKey(colorKey) {
+    const color = colors.find((color) => color.key === colorKey);
+    return color !== null && color !== void 0 ? color : defaultColor;
+}

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

@@ -0,0 +1,147 @@
+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';
+/**
+ * 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;
+    },
+};
+/**
+ * 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 times out after the specified duration
+ */
+function createTimeoutSignal(timeoutMs, existingSignal) {
+    const controller = new AbortController();
+    // Timeout logic
+    const timeoutId = setTimeout(() => {
+        controller.abort(new Error(`Request timeout after ${timeoutMs}ms`));
+    }, timeoutMs);
+    // If there's an existing signal, forward its abort
+    if (existingSignal) {
+        if (existingSignal.aborted) {
+            clearTimeout(timeoutId);
+            controller.abort(existingSignal.reason);
+        }
+        else {
+            existingSignal.addEventListener('abort', () => {
+                clearTimeout(timeoutId);
+                controller.abort(existingSignal.reason);
+            }, { once: true });
+        }
+    }
+    // Clean up timeout when request completes
+    controller.signal.addEventListener('abort', () => {
+        clearTimeout(timeoutId);
+    });
+    return controller.signal;
+}
+/**
+ * Performs a fetch request with retry logic and timeout support
+ */
+export async function fetchWithRetry(args) {
+    const { url, options = {}, retryConfig = {} } = 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++) {
+        try {
+            // Set up timeout and signal handling
+            let requestSignal = userSignal || undefined;
+            if (timeout && timeout > 0) {
+                requestSignal = createTimeoutSignal(timeout, requestSignal);
+            }
+            const response = await fetch(url, Object.assign(Object.assign({}, fetchOptions), { signal: requestSignal }));
+            // Check if the response is successful
+            if (!response.ok) {
+                const errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                const error = new Error(errorMessage);
+                error.status = response.status;
+                error.statusText = response.statusText;
+                error.response = {
+                    data: undefined, // Will be set below if we can parse the response
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: headersToObject(response.headers),
+                };
+                // Try to get response body for error details
+                try {
+                    const responseText = await response.text();
+                    let responseData;
+                    try {
+                        responseData = responseText ? JSON.parse(responseText) : undefined;
+                    }
+                    catch (_a) {
+                        responseData = responseText;
+                    }
+                    error.data = responseData;
+                    error.response.data = responseData;
+                }
+                catch (_b) {
+                    // If we can't read the response body, that's OK
+                }
+                throw error;
+            }
+            // Parse response
+            const responseText = await response.text();
+            let data;
+            try {
+                data = responseText ? JSON.parse(responseText) : undefined;
+            }
+            catch (_c) {
+                // If JSON parsing fails, return the raw text
+                data = responseText;
+            }
+            return {
+                data,
+                status: response.status,
+                statusText: response.statusText,
+                headers: headersToObject(response.headers),
+            };
+        }
+        catch (error) {
+            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/utils/index.js

@@ -0,0 +1,3 @@
+export * from './colors.js';
+export * from './sanitization.js';
+export { getTaskUrl, getProjectUrl, getSectionUrl } from './url-helpers.js';

package/dist/esm/utils/multipart-upload.js

@@ -0,0 +1,120 @@
+import FormData from 'form-data';
+import { createReadStream } from 'fs';
+import { basename } from 'path';
+import { fetchWithRetry } from './fetch-with-retry.js';
+/**
+ * Helper function to determine content-type from filename extension.
+ * @param fileName - The filename to analyze
+ * @returns The appropriate MIME type
+ */
+function getContentTypeFromFileName(fileName) {
+    const extension = fileName.toLowerCase().split('.').pop();
+    switch (extension) {
+        case 'png':
+            return 'image/png';
+        case 'jpg':
+        case 'jpeg':
+            return 'image/jpeg';
+        case 'gif':
+            return 'image/gif';
+        case 'webp':
+            return 'image/webp';
+        case 'svg':
+            return 'image/svg+xml';
+        default:
+            return 'application/octet-stream';
+    }
+}
+/**
+ * Uploads a file using multipart/form-data.
+ *
+ * This is a shared utility for uploading files to Todoist endpoints that require
+ * multipart/form-data content type (e.g., file uploads, workspace logo uploads).
+ *
+ * @param baseUrl - The base API URL (e.g., https://api.todoist.com/api/v1/)
+ * @param authToken - The authentication token
+ * @param endpoint - The relative endpoint path (e.g., 'uploads', 'workspaces/logo')
+ * @param file - The file content (Buffer, ReadableStream, or file system path)
+ * @param fileName - Optional file name (required for Buffer/Stream, optional for paths)
+ * @param additionalFields - Additional form fields to include (e.g., project_id, workspace_id)
+ * @param requestId - Optional request ID for idempotency
+ * @returns The response data from the server
+ *
+ * @example
+ * ```typescript
+ * // Upload from a file path
+ * const result = await uploadMultipartFile(
+ *   'https://api.todoist.com/api/v1/',
+ *   'my-token',
+ *   'uploads',
+ *   '/path/to/file.pdf',
+ *   undefined,
+ *   { project_id: '12345' }
+ * )
+ *
+ * // Upload from a Buffer
+ * const buffer = Buffer.from('file content')
+ * const result = await uploadMultipartFile(
+ *   'https://api.todoist.com/api/v1/',
+ *   'my-token',
+ *   'uploads',
+ *   buffer,
+ *   'document.pdf',
+ *   { project_id: '12345' }
+ * )
+ * ```
+ */
+export async function uploadMultipartFile(args) {
+    const { baseUrl, authToken, endpoint, file, fileName, additionalFields, requestId } = args;
+    const form = new FormData();
+    // Determine file type and add to form data
+    if (typeof file === 'string') {
+        // File path - create read stream
+        const filePath = file;
+        const resolvedFileName = fileName || basename(filePath);
+        form.append('file', createReadStream(filePath), resolvedFileName);
+    }
+    else if (Buffer.isBuffer(file)) {
+        // Buffer - require fileName
+        if (!fileName) {
+            throw new Error('fileName is required when uploading from a Buffer');
+        }
+        // Detect content-type from filename extension
+        const contentType = getContentTypeFromFileName(fileName);
+        form.append('file', file, {
+            filename: fileName,
+            contentType: contentType,
+        });
+    }
+    else {
+        // Stream - require fileName
+        if (!fileName) {
+            throw new Error('fileName is required when uploading from a stream');
+        }
+        form.append('file', file, fileName);
+    }
+    // Add additional fields to the form
+    for (const [key, value] of Object.entries(additionalFields)) {
+        if (value !== undefined && value !== null) {
+            form.append(key, value.toString());
+        }
+    }
+    // Build the full URL
+    const url = `${baseUrl}${endpoint}`;
+    // Prepare headers
+    const headers = Object.assign({ Authorization: `Bearer ${authToken}` }, form.getHeaders());
+    if (requestId) {
+        headers['X-Request-Id'] = requestId;
+    }
+    // Make the request using fetch
+    const response = await fetchWithRetry({
+        url,
+        options: {
+            method: 'POST',
+            body: form, // FormData from 'form-data' package is compatible with fetch
+            headers,
+            timeout: 30000, // 30 second timeout for file uploads
+        },
+    });
+    return response.data;
+}

package/dist/esm/utils/processing-helpers.js

@@ -0,0 +1,12 @@
+import camelcase from 'camelcase';
+import emojiRegex from 'emoji-regex';
+function isEmojiKey(key) {
+    const regex = emojiRegex();
+    return regex.test(key);
+}
+export function customCamelCase(input) {
+    // If the value is a solitary emoji string, return the key as-is
+    if (isEmojiKey(input))
+        return input;
+    return camelcase(input);
+}

package/dist/esm/utils/sanitization.js

@@ -0,0 +1,112 @@
+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 `${prefix}${text}`;
+    }
+    input = input.replace(BOLD_ITALIC_FORMAT, removeMarkdown);
+    input = input.replace(BOLD_FORMAT, removeMarkdown);
+    input = input.replace(ITALIC_FORMAT, removeMarkdown);
+    return input;
+}
+function removeCodeFormatting(input) {
+    function removeMarkdown(match, text) {
+        return text;
+    }
+    input = input.replace(CODE_BLOCK_FORMAT, removeMarkdown);
+    input = input.replace(CODE_INLINE_FORMAT, removeMarkdown);
+    return input;
+}
+function removeFakeSectionFormatting(input) {
+    if (input.startsWith(FAKE_SECTION_PREFIX)) {
+        input = input.slice(FAKE_SECTION_PREFIX.length);
+    }
+    if (input.endsWith(FAKE_SECTION_SUFFIX)) {
+        input = input.slice(0, input.length - FAKE_SECTION_SUFFIX.length);
+    }
+    return input;
+}
+function removeMarkdownLinks(input) {
+    if (!input.includes('[') || !input.includes(']')) {
+        return input;
+    }
+    function removeMarkdown(match, text) {
+        return text;
+    }
+    return input.replace(MARKDOWN_LINK, removeMarkdown);
+}
+function removeTodoistLinks(input) {
+    if (!input.includes('(') || !input.includes(')')) {
+        return input;
+    }
+    function removeMarkdown(match, url, text) {
+        return text;
+    }
+    return input.replace(TODOIST_LINK, removeMarkdown);
+}
+function removeAppLinks(input) {
+    if (input.includes('gmail')) {
+        input = input.replace(GMAIL_LINK, (match, id, text) => text);
+    }
+    if (input.includes('outlook')) {
+        input = input.replace(OUTLOOK_LINK, (match, id, text) => text);
+    }
+    if (input.includes('thunderbird')) {
+        input = input.replace(THUNDERBIRD_LINK, (match, text) => text);
+    }
+    return input;
+}
+/**
+ * Sanitizes a string by removing Todoist's formatting syntax (e.g. bold, italic, code blocks, links).
+ *
+ * @example
+ * // Removes bold/italic formatting
+ * getSanitizedContent('Some **bold** and *italic*') // 'Some bold and italic'
+ *
+ * // Removes markdown links
+ * getSanitizedContent('A [markdown](http://url.com) link') // 'A markdown link'
+ *
+ * // Removes app-specific links
+ * getSanitizedContent('A [[gmail=id, link from gmail]]') // 'A link from gmail'
+ *
+ * @param input - The string to sanitize
+ * @returns The sanitized string with all formatting removed
+ */
+export function getSanitizedContent(input) {
+    input = removeStyleFormatting(input);
+    input = removeCodeFormatting(input);
+    input = removeFakeSectionFormatting(input);
+    input = removeMarkdownLinks(input);
+    input = removeTodoistLinks(input);
+    input = removeAppLinks(input);
+    return input;
+}
+/**
+ * Takes an array of tasks and returns a new array with sanitized content
+ * added as 'sanitizedContent' property to each task.
+ *
+ * @see {@link getSanitizedContent}
+ *
+ * @example
+ * const tasks = [{ content: '**Bold** task', ... }]
+ * getSanitizedTasks(tasks) // [{ content: '**Bold** task', sanitizedContent: 'Bold task', ... }]
+ *
+ * @param tasks - Array of Task objects to sanitize
+ * @returns Array of tasks with added sanitizedContent property
+ */
+export function getSanitizedTasks(tasks) {
+    return tasks.map((task) => (Object.assign(Object.assign({}, task), { sanitizedContent: getSanitizedContent(task.content) })));
+}

package/dist/esm/utils/url-helpers.js

@@ -0,0 +1,68 @@
+import { TODOIST_WEB_URI } from '../consts/endpoints.js';
+/**
+ * Formats a Date object to YYYY-MM-DD string format.
+ *
+ * @internal
+ * @param date The Date object to format.
+ * @returns The formatted date string in YYYY-MM-DD format.
+ */
+export function formatDateToYYYYMMDD(date) {
+    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.
+ *
+ * @param taskId The ID of the task.
+ * @param content The content of the task.
+ * @returns The URL string for the task view.
+ */
+export function getTaskUrl(taskId, content) {
+    const slug = content ? slugify(content) : undefined;
+    const path = slug ? `${slug}-${taskId}` : taskId;
+    return `${TODOIST_WEB_URI}/task/${path}`;
+}
+/**
+ * Generate the URL for a given project.
+ *
+ * @param projectId The ID of the project.
+ * @param name The name of the project.
+ * @returns The URL string for the project view.
+ */
+export function getProjectUrl(projectId, name) {
+    const slug = name ? slugify(name) : undefined;
+    const path = slug ? `${slug}-${projectId}` : projectId;
+    return `${TODOIST_WEB_URI}/project/${path}`;
+}
+/**
+ * Generate the URL for a given section.
+ *
+ * @param sectionId The ID of the section.
+ * @param name The name of the section.
+ * @returns The URL string for the section view.
+ */
+export function getSectionUrl(sectionId, name) {
+    const slug = name ? slugify(name) : undefined;
+    const path = slug ? `${slug}-${sectionId}` : sectionId;
+    return `${TODOIST_WEB_URI}/section/${path}`;
+}
+/**
+ * Slugify function borrowed from Django.
+ *
+ * @param value The string to slugify.
+ * @returns The slugified string.
+ */
+function slugify(value) {
+    // Convert to ASCII
+    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
+    result = result.toLowerCase().replace(/[^\w\s-]/g, '');
+    // Replace spaces and repeated dashes with single dashes
+    result = result.replace(/[-\s]+/g, '-');
+    // Strip dashes from the beginning and end
+    return result.replace(/^-+|-+$/g, '');
+}