feat(tasks): added GetTaskDataById API for DU-VS (#323)

* feat(tasks): added GetTaskDataById API for DU-VS

* feat(tasks): added getAppTaskById API

* test(tasks): fixed sonar issues

* fix(tasks): taskGetFormOptions extends BaseOptions & removed SUPPORTED_TASK_TYPES

Author: maninder-uipath

package.json

@@ -152,6 +152,7 @@
         "README.md"
     ],
     "scripts": {
+        "prepack": "rimraf *.tgz",
         "prebuild": "rimraf dist",
         "build": "rollup -c",
         "build:watch": "rollup -c -w",

src/models/action-center/tasks.internal-types.ts

@@ -1,5 +1,15 @@
-import { CollectionResponse } from "../common/types";
-import { TaskAssignmentOptions, TaskAssignmentResponse } from "./tasks.types";
+import { BaseOptions, CollectionResponse } from "../common/types";
+import { TaskAssignmentOptions, TaskAssignmentResponse, TaskType } from "./tasks.types";
+import { TASK_ENDPOINTS } from "../../utils/constants/endpoints";
+
+export const TASK_TYPE_ENDPOINTS: Record<TaskType, string> = {
+  [TaskType.Form]: TASK_ENDPOINTS.GET_TASK_FORM_BY_ID,
+  [TaskType.App]: TASK_ENDPOINTS.GET_APP_TASK_BY_ID,
+  [TaskType.DocumentValidation]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+  [TaskType.DocumentClassification]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+  [TaskType.External]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+  [TaskType.DataLabeling]: TASK_ENDPOINTS.GET_GENERIC_TASK_BY_ID,
+};
 
 export enum ActionCenterEventNames {
   TOKENREFRESHED = 'AC.tokenRefreshed',
@@ -29,6 +39,6 @@ export type TaskAssignmentResponseCollection = CollectionResponse<TaskAssignment
 /**
  * Options for getting a form task by ID
  */
-export interface TaskGetFormOptions {
-    expandOnFormLayout?: boolean;
-  }
+export interface TaskGetFormOptions extends BaseOptions {
+  expandOnFormLayout?: boolean;
+}

src/models/action-center/tasks.models.ts

@@ -85,10 +85,9 @@ export interface TaskServiceModel {
 
   /**
    * Gets a task by ID
-   * IMPORTANT: For form tasks, folderId must be provided.
    * @param id - The ID of the task to retrieve
-   * @param options - Optional query parameters
-   * @param folderId - Optional folder ID (REQUIRED for form tasks)
+   * @param options - Optional query parameters including taskType for faster retrieval {@link TaskGetByIdOptions}
+   * @param folderId - Optional folder ID (REQUIRED when options.taskType is provided)
    * @returns Promise resolving to the task
    * {@link TaskGetResponse}
    * @example
@@ -97,10 +96,13 @@ export interface TaskServiceModel {
    * const task = await tasks.getById(<taskId>);
    *
    * // Get a form task by ID
-   * const formTask = await tasks.getById(<taskId>, <folderId>);
+   * const formTask = await tasks.getById(<taskId>, {}, <folderId>);
    *
    * // Access form task properties
    * console.log(formTask.formLayout);
+   *
+   * // Get a document validation task by ID (faster with taskType provided in the options)
+   * const dvTask = await tasks.getById(<taskId>, { taskType: TaskType.DocumentValidation }, <folderId>);
    * ```
    */
   getById(id: number, options?: TaskGetByIdOptions, folderId?: number): Promise<TaskGetResponse>;

src/models/action-center/tasks.types.ts

@@ -11,10 +11,23 @@ export interface UserLoginInfo {
   id: number;
 }
 
+/**
+ * Types of tasks available in Action Center.
+ * Each type determines the task's behavior, UI rendering, and completion requirements.
+ */
 export enum TaskType {
+  /** A form-based task that renders a UiPath form layout for user input */
   Form = 'FormTask',
+  /** An externally managed task handled outside of Action Center */
   External = 'ExternalTask',
-  App = 'AppTask'
+  /** A task powered by a UiPath App */
+  App = 'AppTask',
+  /** A document validation task for reviewing and correcting extracted document data */
+  DocumentValidation = 'DocumentValidationTask',
+  /** A document classification task for categorizing documents */
+  DocumentClassification = 'DocumentClassificationTask',
+  /** A data labeling task for annotating training data */
+  DataLabeling = 'DataLabelingTask'
 }
 
 export enum TaskPriority {
@@ -209,7 +222,11 @@ export interface TaskAssignmentResponse {
  */
 export type TaskCompleteOptions =
   | { type: TaskType.External; data?: any; action?: string }
-  | { type: Exclude<TaskType, TaskType.External>; data: any; action: string };
+  | { type: TaskType.DocumentValidation; data?: any; action?: string }
+  | { type: TaskType.DocumentClassification; data?: any; action?: string }
+  | { type: TaskType.DataLabeling; data?: any; action?: string }
+  | { type: TaskType.Form; data: any; action: string }
+  | { type: TaskType.App; data: any; action: string }
 
 /**
  * Options for completing a task when called from the service
@@ -236,9 +253,16 @@ export type TaskGetAllOptions = RequestOptions & PaginationOptions & {
 }
 
 /**
- * Query options for getting a task by ID 
+ * Query options for getting a task by ID
  */
-export interface TaskGetByIdOptions extends BaseOptions {}
+export interface TaskGetByIdOptions extends BaseOptions {
+  /**
+   * Optional task type. When not provided, method will automatically identify the 
+   * task type and resolve accordingly, but it will be slower.
+   * When provided, it will skip the step to identify the task type, so it will be faster.
+   */
+  taskType?: TaskType;
+}
 
 /**
  * Options for getting users with task permissions

src/services/action-center/tasks.ts

@@ -1,35 +1,36 @@
-import { BaseService } from '../base';
-import { 
-  TaskCreateOptions, 
+import { ValidationError } from '../../core/errors';
+import { track } from '../../core/telemetry';
+import { DEFAULT_TASK_EXPAND, TaskMap, TaskStatusMap } from '../../models/action-center/tasks.constants';
+import { TASK_TYPE_ENDPOINTS, TaskAssignmentResponseCollection, TaskGetFormOptions, TasksAssignOptions } from '../../models/action-center/tasks.internal-types';
+import {
+  TaskCreateResponse,
+  TaskGetResponse,
+  TaskServiceModel,
+  createTaskWithMethods
+} from '../../models/action-center/tasks.models';
+import {
   TaskAssignmentOptions,
   TaskAssignmentResponse,
-  TasksUnassignOptions,
   TaskCompletionOptions,
-  TaskType,
+  TaskCreateOptions,
   TaskGetAllOptions,
   TaskGetByIdOptions,
-  UserLoginInfo,
   TaskGetUsersOptions,
+  TaskType,
+  TasksUnassignOptions,
+  UserLoginInfo,
 } from '../../models/action-center/tasks.types';
-import {
-  TaskServiceModel,
-  TaskGetResponse,
-  TaskCreateResponse,
-  createTaskWithMethods
-} from '../../models/action-center/tasks.models';
-import { OperationResponse } from '../../models/common/types';
-import { pascalToCamelCaseKeys, camelToPascalCaseKeys, transformData, applyDataTransforms, addPrefixToKeys } from '../../utils/transform';
-import { TaskStatusMap, TaskMap, DEFAULT_TASK_EXPAND } from '../../models/action-center/tasks.constants';
-import { createHeaders } from '../../utils/http/headers';
-import { FOLDER_ID } from '../../utils/constants/headers';
+import { BaseOptions, OperationResponse } from '../../models/common/types';
+import { ODATA_OFFSET_PARAMS, ODATA_PAGINATION, ODATA_PREFIX } from '../../utils/constants/common';
 import { TASK_ENDPOINTS } from '../../utils/constants/endpoints';
-import { ODATA_PREFIX, ODATA_PAGINATION, ODATA_OFFSET_PARAMS } from '../../utils/constants/common';
-import { PaginatedResponse, NonPaginatedResponse, HasPaginationOptions } from '../../utils/pagination';
+import { FOLDER_ID } from '../../utils/constants/headers';
+import { createHeaders } from '../../utils/http/headers';
+import { processODataArrayResponse } from '../../utils/object';
+import { HasPaginationOptions, NonPaginatedResponse, PaginatedResponse } from '../../utils/pagination';
 import { PaginationHelpers } from '../../utils/pagination/helpers';
 import { PaginationType } from '../../utils/pagination/internal-types';
-import { TaskAssignmentResponseCollection, TaskGetFormOptions, TasksAssignOptions } from '../../models/action-center/tasks.internal-types';
-import { track } from '../../core/telemetry';
-import { processODataArrayResponse } from '../../utils/object';
+import { addPrefixToKeys, applyDataTransforms, camelToPascalCaseKeys, pascalToCamelCaseKeys, transformData } from '../../utils/transform';
+import { BaseService } from '../base';
 
 /**
  * Service for interacting with UiPath Tasks API
@@ -234,52 +235,63 @@ export class TaskService extends BaseService implements TaskServiceModel {
 
   /**
    * Gets a task by ID
-   * IMPORTANT: For form tasks, folderId must be provided.
-   * 
    * @param id - The ID of the task to retrieve
-   * @param options - Optional query parameters
-   * @param folderId - Optional folder ID (REQUIRED for form tasks)
-   * @returns Promise resolving to the task (form tasks will return form-specific data)
-   * 
+   * @param options - Optional query parameters including taskType for faster retrieval {@link TaskGetByIdOptions}
+   * @param folderId - Optional folder ID (REQUIRED when options.taskType is provided)
+   * @returns Promise resolving to the task
+   * {@link TaskGetResponse}
    * @example
    * ```typescript
-   * import { Tasks } from '@uipath/uipath-typescript/tasks';
+   * // Get a task by ID
+   * const task = await tasks.getById(<taskId>);
    *
-   * const tasks = new Tasks(sdk);
+   * // Get a form task by ID
+   * const formTask = await tasks.getById(<taskId>, {}, <folderId>);
    *
-   * // Get task by ID
-   * const task = await tasks.getById(123);
+   * // Access form task properties
+   * console.log(formTask.formLayout);
    *
-   * // If the task is a form task, it will automatically return form-specific data
+   * // Get a document validation task by ID (faster with taskType provided in the options)
+   * const dvTask = await tasks.getById(<taskId>, { taskType: TaskType.DocumentValidation }, <folderId>);
    * ```
    */
   @track('Tasks.GetById')
   async getById(id: number, options: TaskGetByIdOptions = {}, folderId?: number): Promise<TaskGetResponse> {
+    const { taskType, ...restOptions } = options;
+
+    // If taskType is provided, skip the generic GET_BY_ID call and go directly to the type-specific endpoint
+    if (taskType && taskType in TASK_TYPE_ENDPOINTS) {
+      if (!folderId) {
+        throw new ValidationError({ message: 'folderId is required when taskType is provided' });
+      }
+      return this.getByTaskType(id, folderId, taskType, restOptions);
+    }
+
     const headers = createHeaders({ [FOLDER_ID]: folderId });
-    
+
     // Add default expand parameters
-    const modifiedOptions = this.addDefaultExpand(options);
-    
+    const modifiedOptions = this.addDefaultExpand(restOptions);
+
     // prefix all keys in options
     const keysToPrefix = Object.keys(modifiedOptions);
     const apiOptions = addPrefixToKeys(modifiedOptions, ODATA_PREFIX, keysToPrefix);
     const response = await this.get<TaskGetResponse>(
       TASK_ENDPOINTS.GET_BY_ID(id),
-      { 
+      {
         params: apiOptions,
         headers
       }
     );
-    
+
     // Transform response from PascalCase to camelCase and normalize time fields
     const transformedTask = transformData(pascalToCamelCaseKeys(response.data) as TaskGetResponse, TaskMap);
-    
-    // Check if this is a form task and get form-specific data if it is
-    if (transformedTask.type === TaskType.Form) {
-      const formOptions: TaskGetFormOptions = { expandOnFormLayout: true };
-      return this.getFormTaskById(id, folderId || transformedTask.folderId, formOptions);
+
+    // Get task type from response and fetch type-specific data
+    const resolvedFolderId = folderId || transformedTask.folderId;
+    if (transformedTask.type in TASK_TYPE_ENDPOINTS) {
+      return this.getByTaskType(id, resolvedFolderId, transformedTask.type, restOptions);
     }
-    
+
     return createTaskWithMethods(
       applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }),
       this
@@ -506,29 +518,39 @@ export class TaskService extends BaseService implements TaskServiceModel {
   }
 
   /**
-   * Gets a form task by ID (private method)
-   * 
-   * @param id - The ID of the form task to retrieve
+   * Routes to the type-specific endpoint based on task type.
+   */
+  private getByTaskType(id: number, folderId: number, taskType: TaskType, options: BaseOptions = {}): Promise<TaskGetResponse> {
+    const endpoint = TASK_TYPE_ENDPOINTS[taskType];
+    const extraParams: TaskGetFormOptions = taskType === TaskType.Form ? { expandOnFormLayout: true, ...options } : options;
+    return this.getTaskByTypeEndpoint(id, folderId, endpoint, extraParams);
+  }
+
+  /**
+   * Fetches a task from a type-specific endpoint.
+   *
+   * @param id - The task ID
    * @param folderId - Required folder ID
-   * @param options - Optional query parameters
-   * @returns Promise resolving to the form task
+   * @param endpoint - The type-specific endpoint to call
+   * @param extraParams - Additional query parameters (e.g. form options)
+   * @returns Promise resolving to the task
    */
-  private async getFormTaskById(id: number, folderId: number, options: TaskGetFormOptions = {}): Promise<TaskGetResponse> {
+  private async getTaskByTypeEndpoint(id: number, folderId: number, endpoint: string, extraParams: TaskGetFormOptions = {}): Promise<TaskGetResponse> {
     const headers = createHeaders({ [FOLDER_ID]: folderId });
-    
+
     const response = await this.get<TaskGetResponse>(
-      TASK_ENDPOINTS.GET_TASK_FORM_BY_ID,
-      { 
+      endpoint,
+      {
         params: {
           taskId: id,
-          ...options
+          ...extraParams
         },
         headers
       }
     );
-    const transformedFormTask = transformData(response.data, TaskMap);
+    const transformedTask = transformData(response.data, TaskMap);
     return createTaskWithMethods(
-      applyDataTransforms(transformedFormTask, { field: 'status', valueMap: TaskStatusMap }),
+      applyDataTransforms(transformedTask, { field: 'status', valueMap: TaskStatusMap }),
       this
     ) as TaskGetResponse;
   }

src/utils/constants/endpoints/orchestrator.ts

@@ -20,6 +20,8 @@ export const TASK_ENDPOINTS = {
   COMPLETE_APP_TASK: `${ORCHESTRATOR_BASE}/tasks/AppTasks/CompleteAppTask`,
   COMPLETE_GENERIC_TASK: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/CompleteTask`,
   GET_TASK_FORM_BY_ID: `${ORCHESTRATOR_BASE}/forms/TaskForms/GetTaskFormById`,
+  GET_GENERIC_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/GenericTasks/GetTaskDataById`,
+  GET_APP_TASK_BY_ID: `${ORCHESTRATOR_BASE}/tasks/AppTasks/GetAppTaskById`,
 } as const;
 
 /**