chore: address comments

Author: ninja-shreyash

src/models/orchestrator/jobs.models.ts

@@ -144,20 +144,18 @@ export interface JobServiceModel {
    *
    * @example
    * ```typescript
-   * import { Jobs } from '@uipath/uipath-typescript/jobs';
-   *
-   * const jobs = new Jobs(sdk);
-   *
    * // Stop a single job with default soft stop
-   * const result = await jobs.stop(
-   *   ['c80c3b30-f010-4eb8-82d4-b67bc615e137'],
-   *   123
-   * );
+   * const result = await jobs.stop([<jobKey>], <folderId>);
+   * ```
+   *
+   * @example
+   * ```typescript
+   * import { StopStrategy } from '@uipath/uipath-typescript/jobs';
    *
    * // Force-kill multiple jobs
-   * const killResult = await jobs.stop(
-   *   ['c80c3b30-f010-4eb8-82d4-b67bc615e137', '24ef1040-454d-4184-b994-c641ee32318d'],
-   *   123,
+   * const result = await jobs.stop(
+   *   [<jobKey1>, <jobKey2>],
+   *   <folderId>,
    *   { strategy: StopStrategy.Kill }
    * );
    * ```

src/services/orchestrator/jobs/index.ts

@@ -23,3 +23,4 @@ export { JobService as Jobs, JobService } from './jobs';
 export * from '../../../models/orchestrator/jobs.types';
 export * from '../../../models/orchestrator/jobs.models';
 export { JobState } from '../../../models/common/types';
+export { StopStrategy } from '../../../models/orchestrator/processes.types';

src/services/orchestrator/jobs/jobs.ts

@@ -219,13 +219,31 @@ export class JobService extends FolderScopedService implements JobServiceModel {
   /**
    * Stops one or more jobs by their UUID keys.
    *
-   * Resolves job UUID keys to integer IDs, then calls the StopJobs OData action.
-   * Keys are resolved in chunks of 50 to avoid URL length limits.
+   * Resolves the provided job UUID keys to integer IDs, then sends a stop request to the Orchestrator.
+   * Keys are processed in chunks of 50 to avoid URL length limits. Throws if any keys cannot be resolved.
    *
-   * @param jobKeys - Array of job UUID keys to stop
-   * @param folderId - The folder ID where the jobs reside (required by the API)
-   * @param options - Optional stop options including strategy
-   * @returns Promise resolving to an OperationResponse with the resolved job IDs
+   * @param jobKeys - Array of job UUID keys to stop (e.g., from {@link JobGetResponse}.key)
+   * @param folderId - The folder ID where the jobs reside (required)
+   * @param options - Optional {@link JobStopOptions} including stop strategy
+   * @returns Promise resolving to an {@link OperationResponse}<{@link JobStopData}> with the resolved job IDs
+   *
+   * @example
+   * ```typescript
+   * // Stop a single job with default soft stop
+   * const result = await jobs.stop([<jobKey>], <folderId>);
+   * ```
+   *
+   * @example
+   * ```typescript
+   * import { StopStrategy } from '@uipath/uipath-typescript/jobs';
+   *
+   * // Force-kill multiple jobs
+   * const result = await jobs.stop(
+   *   [<jobKey1>, <jobKey2>],
+   *   <folderId>,
+   *   { strategy: StopStrategy.Kill }
+   * );
+   * ```
    */
   @track('Jobs.Stop')
   async stop(
@@ -308,7 +326,7 @@ export class JobService extends FolderScopedService implements JobServiceModel {
       const response = await this.get<CollectionResponse<{ Key: string; Id: number }>>(
         JOB_ENDPOINTS.GET_ALL,
         {
-          params: { $filter: filter, $select: 'Id,Key' },
+          params: { $filter: filter, $select: 'Id,Key', $top: chunk.length },
           headers,
         }
       );
@@ -320,7 +338,7 @@ export class JobService extends FolderScopedService implements JobServiceModel {
 
     const missingKeys = uniqueKeys.filter((key) => !keyToIdMap.has(key));
     if (missingKeys.length > 0) {
-      throw new Error(`Jobs not found for keys: ${missingKeys.join(', ')}`);
+      throw new ValidationError({ message: `Jobs not found for keys: ${missingKeys.join(', ')}` });
     }
 
     return jobKeys.map((key) => keyToIdMap.get(key)!);

tests/integration/shared/orchestrator/jobs.integration.test.ts

@@ -193,8 +193,7 @@ describe.each(modes)('Orchestrator Jobs - Integration Tests [%s]', (mode) => {
       const { jobs, folderId } = getJobsService();
 
       if (!folderId) {
-        console.warn('INTEGRATION_TEST_FOLDER_ID not configured, skipping stop test.');
-        return;
+        throw new Error('INTEGRATION_TEST_FOLDER_ID not configured — cannot run stop test.');
       }
 
       // Find a running job to stop
@@ -223,14 +222,10 @@ describe.each(modes)('Orchestrator Jobs - Integration Tests [%s]', (mode) => {
     });
 
     it('should return empty result when called with empty array', async () => {
-      const { jobs, folderId } = getJobsService();
-
-      if (!folderId) {
-        console.warn('INTEGRATION_TEST_FOLDER_ID not configured, skipping stop test.');
-        return;
-      }
+      const { jobs } = getJobsService();
 
-      const result = await jobs.stop([], folderId);
+      // folderId is unused for empty-array inputs — stop() returns early before reading it
+      const result = await jobs.stop([], 0);
 
       expect(result).toBeDefined();
       expect(result.success).toBe(true);

tests/unit/services/orchestrator/jobs.test.ts

@@ -519,6 +519,7 @@ describe('JobService Unit Tests', () => {
           params: {
             $filter: `Key in ('${JOB_TEST_CONSTANTS.JOB_KEY}')`,
             $select: 'Id,Key',
+            $top: 1,
           },
         })
       );
@@ -604,6 +605,33 @@ describe('JobService Unit Tests', () => {
       expect(keyMatches).toHaveLength(2); // One key, two quotes
     });
 
+    it('should resolve keys in multiple chunks when count exceeds chunk size', async () => {
+      const chunkSize = JOB_TEST_CONSTANTS.KEY_RESOLUTION_CHUNK_SIZE;
+      const keys = Array.from(
+        { length: chunkSize + 1 },
+        (_, i) => `${i.toString().padStart(8, '0')}-bbbb-cccc-dddd-eeeeeeeeeeee`
+      );
+      const ids = keys.map((_, i) => i + 1);
+
+      // Chunk 1: first 50 keys
+      mockApiClient.get.mockResolvedValueOnce({
+        value: keys.slice(0, chunkSize).map((k, i) => ({ Key: k, Id: ids[i] })),
+      });
+      // Chunk 2: remaining 1 key
+      mockApiClient.get.mockResolvedValueOnce({
+        value: [{ Key: keys[chunkSize], Id: ids[chunkSize] }],
+      });
+      mockApiClient.post.mockResolvedValueOnce(undefined);
+
+      const result = await jobService.stop(keys, TEST_CONSTANTS.FOLDER_ID);
+
+      expect(mockApiClient.get).toHaveBeenCalledTimes(2);
+      expect(mockApiClient.get.mock.calls[0][1].params.$top).toBe(chunkSize);
+      expect(mockApiClient.get.mock.calls[1][1].params.$top).toBe(1);
+      expect(result.data.jobIds).toHaveLength(chunkSize + 1);
+      expect(result.data.jobIds).toEqual(ids);
+    });
+
     it('should propagate resolution API errors', async () => {
       const error = createMockError(JOB_TEST_CONSTANTS.ERROR_JOB_NOT_FOUND);
       mockApiClient.get.mockRejectedValueOnce(error);

tests/utils/constants/jobs.ts

@@ -32,4 +32,7 @@ export const JOB_TEST_CONSTANTS = {
   // Error Messages
   ERROR_JOB_NOT_FOUND: 'Job not found',
   ERROR_JOBS_NOT_FOUND_FOR_KEYS: 'Jobs not found for keys',
+
+  // Stop resolution
+  KEY_RESOLUTION_CHUNK_SIZE: 50,
 } as const;