@doist/todoist-sdk 9.1.0-next.1 → 9.1.0

package/dist/esm/clients/workspace-client.js

@@ -0,0 +1,363 @@
+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 { z } from 'zod';
+import { ENDPOINT_REST_WORKSPACES, ENDPOINT_WORKSPACE_INVITATIONS, ENDPOINT_WORKSPACE_INVITATIONS_ALL, ENDPOINT_WORKSPACE_INVITATIONS_DELETE, ENDPOINT_WORKSPACE_JOIN, ENDPOINT_WORKSPACE_LOGO, ENDPOINT_WORKSPACE_MEMBERS, ENDPOINT_WORKSPACE_PLAN_DETAILS, ENDPOINT_WORKSPACE_USERS, getWorkspaceActiveProjectsEndpoint, getWorkspaceArchivedProjectsEndpoint, getWorkspaceInvitationAcceptEndpoint, getWorkspaceInvitationRejectEndpoint, getWorkspaceInviteUsersEndpoint, getWorkspaceUserEndpoint, getWorkspaceUserTasksEndpoint, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { uploadMultipartFile } from '../utils/multipart-upload.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateJoinWorkspaceResult, validateMemberActivityInfoArray, validateProject, validateWorkspace, validateWorkspaceArray, validateWorkspaceInvitation, validateWorkspaceInvitationArray, validateWorkspacePlanDetails, validateWorkspaceUserArray, validateWorkspaceUserTaskArray, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all workspace-domain endpoints —
+ * workspaces, invitations, users, plans, logos, and workspace project
+ * pagination.
+ *
+ * Instantiated by `TodoistApi`; every public workspace method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class WorkspaceClient extends BaseClient {
+    async getWorkspaceInvitations(args, requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: { workspace_id: args.workspaceId },
+            requestId: requestId,
+        });
+        return response.data;
+    }
+    async getAllWorkspaceInvitations(args = {}, requestId) {
+        const queryParams = {};
+        if (args.workspaceId) {
+            queryParams.workspace_id = args.workspaceId;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS_ALL,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitationArray(response.data);
+    }
+    async deleteWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_INVITATIONS_DELETE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: {
+                workspace_id: args.workspaceId,
+                user_email: args.userEmail,
+            },
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async acceptWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInvitationAcceptEndpoint(args.inviteCode),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async rejectWorkspaceInvitation(args, requestId) {
+        const response = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInvitationRejectEndpoint(args.inviteCode),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspaceInvitation(response.data);
+    }
+    async joinWorkspace(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_JOIN,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: {
+                invite_code: args.inviteCode,
+                workspace_id: args.workspaceId,
+            },
+            requestId: requestId,
+        });
+        return validateJoinWorkspaceResult(response.data);
+    }
+    async uploadWorkspaceLogo(args, requestId) {
+        if (args.delete) {
+            // Delete logo
+            const data = await uploadMultipartFile({
+                baseUrl: this.syncApiBase,
+                authToken: this.authToken,
+                endpoint: ENDPOINT_WORKSPACE_LOGO,
+                file: Buffer.alloc(0), // Empty buffer for delete
+                fileName: 'delete',
+                additionalFields: {
+                    workspace_id: args.workspaceId,
+                    delete: true,
+                },
+                requestId: requestId,
+                customFetch: this.customFetch,
+            });
+            return data;
+        }
+        if (!args.file) {
+            throw new Error('file is required when not deleting logo');
+        }
+        // Validate buffer is not empty if it's a Buffer
+        if (Buffer.isBuffer(args.file) && args.file.length === 0) {
+            throw new Error('Cannot upload empty image file');
+        }
+        const additionalFields = {
+            workspace_id: args.workspaceId,
+        };
+        const data = await uploadMultipartFile({
+            baseUrl: this.syncApiBase,
+            authToken: this.authToken,
+            endpoint: ENDPOINT_WORKSPACE_LOGO,
+            file: args.file,
+            fileName: args.fileName,
+            additionalFields: additionalFields,
+            requestId: requestId,
+            customFetch: this.customFetch,
+        });
+        return data;
+    }
+    async getWorkspacePlanDetails(args, requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_PLAN_DETAILS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: { workspace_id: args.workspaceId },
+            requestId: requestId,
+        });
+        return validateWorkspacePlanDetails(response.data);
+    }
+    async getWorkspaceUsers(args = {}, requestId) {
+        const queryParams = {};
+        if (args.workspaceId !== undefined && args.workspaceId !== null) {
+            queryParams.workspace_id = args.workspaceId;
+        }
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_USERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return {
+            hasMore: response.data.hasMore || false,
+            nextCursor: response.data.nextCursor,
+            workspaceUsers: validateWorkspaceUserArray(response.data.workspaceUsers || []),
+        };
+    }
+    async getWorkspaces(requestId) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_WORKSPACES,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspaceArray(response.data);
+    }
+    async getWorkspace(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async addWorkspace(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_WORKSPACES,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async updateWorkspace(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateWorkspace(response.data);
+    }
+    async deleteWorkspace(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_WORKSPACES, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getWorkspaceMembersActivity(args, requestId) {
+        const { workspaceId } = args, queryParams = __rest(args, ["workspaceId"]);
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_WORKSPACE_MEMBERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign({ workspaceId }, queryParams),
+            requestId: requestId,
+        });
+        return {
+            members: validateMemberActivityInfoArray(data.members),
+        };
+    }
+    async getWorkspaceUserTasks(args, requestId) {
+        const { workspaceId, userId } = args, queryParams = __rest(args, ["workspaceId", "userId"]);
+        const { data } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserTasksEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        return {
+            tasks: validateWorkspaceUserTaskArray(data.tasks),
+        };
+    }
+    async inviteWorkspaceUsers(args, requestId) {
+        const { workspaceId } = args, payload = __rest(args, ["workspaceId"]);
+        const { data } = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInviteUsersEndpoint(workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: payload,
+            requestId: requestId,
+        });
+        return data;
+    }
+    async updateWorkspaceUser(args, requestId) {
+        const { workspaceId, userId } = args, payload = __rest(args, ["workspaceId", "userId"]);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: payload,
+            requestId: requestId,
+        });
+        return validateJoinWorkspaceResult(response.data);
+    }
+    async removeWorkspaceUser(args, requestId) {
+        const { workspaceId, userId } = args;
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceUserEndpoint(workspaceId, userId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getWorkspaceActiveProjects(args, requestId) {
+        var _a;
+        const queryParams = {};
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceActiveProjectsEndpoint(args.workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        // oxlint-disable-next-line no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access
+        const validatedProjects = (_a = response.data.results) === null || _a === void 0 ? void 0 : _a.map((project) => validateProject(project));
+        return Object.assign(Object.assign({}, response.data), { 
+            // oxlint-disable-next-line no-unsafe-assignment
+            results: validatedProjects || [] });
+    }
+    async getWorkspaceArchivedProjects(args, requestId) {
+        var _a;
+        const queryParams = {};
+        if (args.cursor) {
+            queryParams.cursor = args.cursor;
+        }
+        if (args.limit) {
+            queryParams.limit = args.limit;
+        }
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceArchivedProjectsEndpoint(args.workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: queryParams,
+            requestId: requestId,
+        });
+        // oxlint-disable-next-line no-unsafe-assignment, no-unsafe-call, no-unsafe-member-access
+        const validatedProjects = (_a = response.data.results) === null || _a === void 0 ? void 0 : _a.map((project) => validateProject(project));
+        return Object.assign(Object.assign({}, response.data), { 
+            // oxlint-disable-next-line no-unsafe-assignment
+            results: validatedProjects || [] });
+    }
+}

package/dist/esm/consts/endpoints.js

@@ -67,11 +67,6 @@ export const ENDPOINT_GET_TOKEN = 'access_token';
 export const ENDPOINT_REVOKE = 'revoke';
 export const ENDPOINT_REGISTER = 'register';
 export const ENDPOINT_REST_FOLDERS = 'folders';
-export const ENDPOINT_REST_GOALS = 'goals';
-export const ENDPOINT_REST_GOALS_SEARCH = ENDPOINT_REST_GOALS + '/search';
-export const GOAL_COMPLETE = 'complete';
-export const GOAL_UNCOMPLETE = 'uncomplete';
-export const GOAL_TASKS = 'items';
 // Workspace endpoints
 export const ENDPOINT_REST_WORKSPACES = 'workspaces';
 export const ENDPOINT_WORKSPACE_INVITATIONS = 'workspaces/invitations';
@@ -126,3 +121,54 @@ export function getWorkspaceActiveProjectsEndpoint(workspaceId) {
 export function getWorkspaceArchivedProjectsEndpoint(workspaceId) {
     return `workspaces/${workspaceId}/projects/archived`;
 }
+// App management endpoints (dev:app_console scope)
+export const ENDPOINT_REST_APPS = 'apps';
+export const ENDPOINT_REST_APPS_INSTALLATIONS = 'apps/installations';
+export const ENDPOINT_REST_APPS_UI_EXTENSIONS = 'apps/ui_extensions';
+export const ENDPOINT_REST_APPS_UI_EXTENSIONS_INSTALLED = 'apps/ui_extensions/installed';
+export const ENDPOINT_REST_USER_AUTHORIZATIONS = 'user/authorizations';
+export const ENDPOINT_REST_USER_AUTHORIZATIONS_DELETE = 'user/authorizations/delete';
+/** Available app icon sizes (small 60x60, medium 300x300, large 600x600). */
+export const APP_ICON_SIZES = ['small', 'medium', 'large'];
+export function getAppEndpoint(appId) {
+    return `apps/${appId}`;
+}
+export function getAppSecretsEndpoint(appId) {
+    return `apps/${appId}/secrets`;
+}
+export function getAppClientSecretEndpoint(appId) {
+    return `apps/${appId}/client_secret`;
+}
+export function getAppTokensEndpoint(appId) {
+    return `apps/${appId}/tokens`;
+}
+export function getAppTestTokenEndpoint(appId) {
+    return `apps/${appId}/test_token`;
+}
+export function getAppDistributionTokenEndpoint(appId) {
+    return `apps/${appId}/distribution_token`;
+}
+export function getAppVerificationTokenEndpoint(appId) {
+    return `apps/${appId}/verification_token`;
+}
+export function getAppWebhookEndpoint(appId) {
+    return `apps/${appId}/webhook`;
+}
+export function getAppIconEndpoint(appId, size) {
+    return size === 'medium' ? `apps/${appId}/icon` : `apps/${appId}/icon/${size}`;
+}
+export function getAppInstallationEndpoint(installationId) {
+    return `apps/installations/${installationId}`;
+}
+export function getAppByDistributionTokenEndpoint(distributionToken) {
+    return `apps/by_distribution_token/${distributionToken}`;
+}
+export function getUiExtensionEndpoint(uiExtensionId) {
+    return `apps/ui_extensions/${uiExtensionId}`;
+}
+export function getUiExtensionIconEndpoint(uiExtensionId) {
+    return `apps/ui_extensions/${uiExtensionId}/icon`;
+}
+export function getUiExtensionsByIntegrationEndpoint(integrationId) {
+    return `apps/ui_extensions/integration/${integrationId}`;
+}

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

@@ -277,6 +277,81 @@ export const DEFAULT_COLLABORATOR_STATE = {
     state: 'active',
     isDeleted: false,
 };
+export const DEFAULT_APP_ID = '42';
+export const DEFAULT_INSTALLATION_ID = '1001';
+export const DEFAULT_UI_EXTENSION_ID = '2002';
+export const DEFAULT_DISTRIBUTION_TOKEN = 'dist-token-abc';
+export const DEFAULT_ACCESS_TOKEN_ID = '3003';
+export const DEFAULT_APP = {
+    id: DEFAULT_APP_ID,
+    status: 'public',
+    displayName: 'Sample App',
+    userId: DEFAULT_USER_ID,
+    createdAt: defaultDate(),
+    serviceUrl: 'https://example.com',
+    oauthRedirectUri: 'https://example.com/callback',
+    description: 'A sample app',
+    iconSm: 'https://example.com/icon-sm.png',
+    iconMd: 'https://example.com/icon-md.png',
+    iconLg: 'https://example.com/icon-lg.png',
+    appTokenScopes: ['data:read', 'task:add'],
+};
+export const DEFAULT_APP_WITH_USER_COUNT = Object.assign(Object.assign({}, DEFAULT_APP), { userCount: 12 });
+export const DEFAULT_APP_SECRETS = {
+    clientId: 'client-id-xyz',
+    clientSecret: 'client-secret-xyz',
+};
+export const DEFAULT_APP_VERIFICATION_TOKEN = {
+    verificationToken: 'verif-token-abc',
+};
+export const DEFAULT_APP_TEST_TOKEN = {
+    accessToken: 'test-token-xyz',
+};
+export const DEFAULT_APP_DISTRIBUTION_TOKEN = {
+    distributionToken: DEFAULT_DISTRIBUTION_TOKEN,
+};
+export const DEFAULT_APP_WEBHOOK = {
+    status: 'active',
+    callbackUrl: 'https://example.com/webhook',
+    version: '1',
+    events: ['item:added', 'item:completed'],
+};
+export const DEFAULT_APP_INSTALLATION = {
+    id: DEFAULT_INSTALLATION_ID,
+    creator: DEFAULT_USER_ID,
+    createdTs: 1700000000,
+    installationType: 'user',
+    appTokenScopesValidated: true,
+    integration: DEFAULT_APP,
+};
+export const DEFAULT_USER_AUTHORIZATION = {
+    accessTokenId: DEFAULT_ACCESS_TOKEN_ID,
+    scope: ['data:read', 'task:add'],
+    scopeDescriptions: ['Read data', 'Add tasks'],
+    createdAt: new Date('2025-01-01T00:00:00Z'),
+    app: {
+        id: DEFAULT_APP_ID,
+        displayName: 'Sample App',
+        description: 'A sample app',
+        serviceUrl: 'https://example.com',
+        iconMd: 'https://example.com/icon-md.png',
+    },
+};
+export const DEFAULT_UI_EXTENSION = {
+    id: DEFAULT_UI_EXTENSION_ID,
+    integrationId: DEFAULT_APP_ID,
+    extensionId: 'ext-guid-1',
+    extensionType: 'context-menu',
+    contextType: 'task',
+    url: 'https://example.com/extension',
+    icon: 'https://example.com/icon.png',
+    name: 'My Extension',
+    description: 'Does things in the task context menu',
+    width: 400,
+    height: 600,
+    defVersion: 2,
+    minimumCardistVersion: '0.60',
+};
 export const DEFAULT_NOTE = {
     id: DEFAULT_COMMENT_ID,
     projectId: DEFAULT_PROJECT_ID,