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

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/test-utils/test-defaults.js

@@ -277,6 +277,30 @@ export const DEFAULT_COLLABORATOR_STATE = {
     state: 'active',
     isDeleted: false,
 };
+export const DEFAULT_GOAL_ID = '550e8400-e29b-41d4-a716-446655440000';
+export const DEFAULT_GOAL = {
+    id: DEFAULT_GOAL_ID,
+    ownerType: 'USER',
+    ownerId: DEFAULT_USER_ID,
+    name: 'Ship v2',
+    description: 'Launch the new version',
+    deadline: '2026-04-03',
+    parentGoalId: null,
+    childOrder: 0,
+    isCompleted: false,
+    completedAt: null,
+    responsibleUid: null,
+    isDeleted: false,
+    progress: {
+        totalTaskCount: 5,
+        completedTaskCount: 2,
+        percentage: 40,
+    },
+    creatorUid: DEFAULT_USER_ID,
+    createdAt: defaultDate(),
+    updatedAt: defaultDate(),
+};
+export const DEFAULT_GOAL_NO_PROGRESS = Object.assign(Object.assign({}, DEFAULT_GOAL), { id: 'e5f6g7h8-e29b-41d4-a716-446655440001', progress: undefined });
 export const DEFAULT_NOTE = {
     id: DEFAULT_COMMENT_ID,
     projectId: DEFAULT_PROJECT_ID,