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

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

@@ -0,0 +1,88 @@
+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_COMMENTS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateComment, validateCommentArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all comment-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public comment method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class CommentClient extends BaseClient {
+    async getComments(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_COMMENTS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateCommentArray(results),
+            nextCursor,
+        };
+    }
+    async getComment(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_COMMENTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateComment(response.data);
+    }
+    async addComment(args, requestId) {
+        const { uidsToNotify } = args, rest = __rest(args, ["uidsToNotify"]);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_COMMENTS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign({}, rest), (uidsToNotify ? { uidsToNotify: uidsToNotify.join(',') } : {})),
+            requestId: requestId,
+        });
+        return validateComment(response.data);
+    }
+    async updateComment(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_COMMENTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateComment(response.data);
+    }
+    async deleteComment(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_COMMENTS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

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

@@ -0,0 +1,39 @@
+import { ENDPOINT_REST_EMAILS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling email-forwarding endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public email-forwarding method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class EmailClient extends BaseClient {
+    async getOrCreateEmailForwarding(args, requestId) {
+        const { data } = await request({
+            httpMethod: 'PUT',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_EMAILS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return data;
+    }
+    async disableEmailForwarding(args, requestId) {
+        const queryParams = new URLSearchParams({
+            obj_type: args.objType,
+            obj_id: args.objId,
+        });
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: `${ENDPOINT_REST_EMAILS}?${queryParams.toString()}`,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

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

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_FOLDERS } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateFolder, validateFolderArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all folder-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public folder method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class FolderClient extends BaseClient {
+    async getFolders(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_FOLDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateFolderArray(results),
+            nextCursor,
+        };
+    }
+    async getFolder(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_FOLDERS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateFolder(response.data);
+    }
+    async addFolder(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_FOLDERS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateFolder(response.data);
+    }
+    async updateFolder(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_FOLDERS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateFolder(response.data);
+    }
+    async deleteFolder(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_FOLDERS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

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

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_GOALS, ENDPOINT_REST_GOALS_SEARCH, GOAL_COMPLETE, GOAL_TASKS, GOAL_UNCOMPLETE, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateGoal, validateGoalArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all goal-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public goal method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class GoalsClient extends BaseClient {
+    async getGoals(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_GOALS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateGoalArray(results),
+            nextCursor,
+        };
+    }
+    async searchGoals(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_GOALS_SEARCH,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateGoalArray(results),
+            nextCursor,
+        };
+    }
+    async getGoal(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateGoal(response.data);
+    }
+    async addGoal(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_GOALS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async updateGoal(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async deleteGoal(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async completeGoal(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id, GOAL_COMPLETE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async uncompleteGoal(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, id, GOAL_UNCOMPLETE),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async linkTaskToGoal({ goalId, taskId }, requestId) {
+        z.string().parse(goalId);
+        z.string().parse(taskId);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, goalId, GOAL_TASKS),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: { itemId: taskId },
+            requestId: requestId,
+        });
+        return validateGoal(response.data);
+    }
+    async unlinkTaskFromGoal({ goalId, taskId }, requestId) {
+        z.string().parse(goalId);
+        z.string().parse(taskId);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_GOALS, goalId, GOAL_TASKS, taskId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+}

package/dist/esm/clients/id-mapping-client.js

@@ -0,0 +1,35 @@
+import { ENDPOINT_REST_ID_MAPPINGS, ENDPOINT_REST_MOVED_IDS } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateIdMappingArray, validateMovedIdArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling ID-mapping endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public id-mapping method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class IdMappingClient extends BaseClient {
+    async getIdMappings(args) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_ID_MAPPINGS, args.objName, args.objIds.join(',')),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateIdMappingArray(response.data);
+    }
+    async getMovedIds(args) {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_MOVED_IDS, args.objName),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args.oldIds ? { oldIds: args.oldIds.join(',') } : undefined,
+        });
+        return validateMovedIdArray(response.data);
+    }
+}

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

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+import { getProjectInsightsActivityStatsEndpoint, getProjectInsightsHealthAnalyzeEndpoint, getProjectInsightsHealthContextEndpoint, getProjectInsightsHealthEndpoint, getProjectInsightsProgressEndpoint, getWorkspaceInsightsEndpoint, } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { validateProjectActivityStats, validateProjectHealth, validateProjectHealthContext, validateProjectProgress, validateWorkspaceInsights, } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all insights-domain endpoints
+ * (project activity stats, health, progress, workspace insights).
+ *
+ * Instantiated by `TodoistApi`; every public insights method on
+ * `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class InsightsClient extends BaseClient {
+    async getProjectActivityStats(projectId, args = {}) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsActivityStatsEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign({ objectType: 'ITEM', eventType: 'COMPLETED' }, args),
+        });
+        return validateProjectActivityStats(response.data);
+    }
+    async getProjectHealth(projectId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsHealthEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProjectHealth(response.data);
+    }
+    async getProjectHealthContext(projectId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsHealthContextEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProjectHealthContext(response.data);
+    }
+    async getProjectProgress(projectId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsProgressEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProjectProgress(response.data);
+    }
+    async getWorkspaceInsights(workspaceId, args = {}) {
+        z.string().parse(workspaceId);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: getWorkspaceInsightsEndpoint(workspaceId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: Object.assign(Object.assign({}, args), (args.projectIds ? { projectIds: args.projectIds.join(',') } : {})),
+        });
+        return validateWorkspaceInsights(response.data);
+    }
+    async analyzeProjectHealth(projectId, requestId) {
+        z.string().parse(projectId);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: getProjectInsightsHealthAnalyzeEndpoint(projectId),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return validateProjectHealth(response.data);
+    }
+}

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

@@ -0,0 +1,123 @@
+import { z } from 'zod';
+import { ENDPOINT_REST_LABELS, ENDPOINT_REST_LABELS_SEARCH, ENDPOINT_REST_LABELS_SHARED, ENDPOINT_REST_LABELS_SHARED_REMOVE, ENDPOINT_REST_LABELS_SHARED_RENAME, } from '../consts/endpoints.js';
+import { isSuccess, request } from '../transport/http-client.js';
+import { generatePath } from '../utils/request-helpers.js';
+import { validateLabel, validateLabelArray } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling all label-domain endpoints.
+ *
+ * Instantiated by `TodoistApi`; every public label method on `TodoistApi`
+ * delegates here. See `todoist-api.ts` for the user-facing JSDoc.
+ */
+export class LabelClient extends BaseClient {
+    async getLabel(id) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_LABELS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateLabel(response.data);
+    }
+    async getLabels(args = {}) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateLabelArray(results),
+            nextCursor,
+        };
+    }
+    async searchLabels(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SEARCH,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return {
+            results: validateLabelArray(results),
+            nextCursor,
+        };
+    }
+    async addLabel(args, requestId) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateLabel(response.data);
+    }
+    async updateLabel(id, args, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_LABELS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+            requestId: requestId,
+        });
+        return validateLabel(response.data);
+    }
+    async deleteLabel(id, requestId) {
+        z.string().parse(id);
+        const response = await request({
+            httpMethod: 'DELETE',
+            baseUri: this.syncApiBase,
+            relativePath: generatePath(ENDPOINT_REST_LABELS, id),
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            requestId: requestId,
+        });
+        return isSuccess(response);
+    }
+    async getSharedLabels(args) {
+        const { data: { results, nextCursor }, } = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SHARED,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return { results, nextCursor };
+    }
+    async renameSharedLabel(args) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SHARED_RENAME,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return isSuccess(response);
+    }
+    async removeSharedLabel(args) {
+        const response = await request({
+            httpMethod: 'POST',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_LABELS_SHARED_REMOVE,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+            payload: args,
+        });
+        return isSuccess(response);
+    }
+}

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

@@ -0,0 +1,23 @@
+import { ENDPOINT_REST_PRODUCTIVITY } from '../consts/endpoints.js';
+import { request } from '../transport/http-client.js';
+import { validateProductivityStats } from '../utils/validators.js';
+import { BaseClient } from './base-client.js';
+/**
+ * Internal sub-client handling the productivity-stats endpoint.
+ *
+ * Instantiated by `TodoistApi`; the public `getProductivityStats` method
+ * on `TodoistApi` delegates here. See `todoist-api.ts` for user-facing
+ * JSDoc.
+ */
+export class ProductivityClient extends BaseClient {
+    async getProductivityStats() {
+        const response = await request({
+            httpMethod: 'GET',
+            baseUri: this.syncApiBase,
+            relativePath: ENDPOINT_REST_PRODUCTIVITY,
+            apiToken: this.authToken,
+            customFetch: this.customFetch,
+        });
+        return validateProductivityStats(response.data);
+    }
+}