@curl-runner/cli 1.6.0 → 1.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curl-runner/cli",
-  "version": "1.6.0",
+  "version": "1.8.0",
   "description": "A powerful CLI tool for HTTP request management using YAML configuration",
   "type": "module",
   "main": "./dist/cli.js",

package/src/cli.ts

@@ -84,6 +84,13 @@ class CurlRunnerCLI {
         process.env.CURL_RUNNER_CONTINUE_ON_ERROR.toLowerCase() === 'true';
     }
 
+    if (process.env.CURL_RUNNER_MAX_CONCURRENCY) {
+      const maxConcurrency = Number.parseInt(process.env.CURL_RUNNER_MAX_CONCURRENCY, 10);
+      if (maxConcurrency > 0) {
+        envConfig.maxConcurrency = maxConcurrency;
+      }
+    }
+
     if (process.env.CURL_RUNNER_OUTPUT_FORMAT) {
       const format = process.env.CURL_RUNNER_OUTPUT_FORMAT;
       if (['json', 'pretty', 'raw'].includes(format)) {
@@ -200,6 +207,9 @@ class CurlRunnerCLI {
       if (options.execution) {
         globalConfig.execution = options.execution as 'sequential' | 'parallel';
       }
+      if (options.maxConcurrent !== undefined) {
+        globalConfig.maxConcurrency = options.maxConcurrent as number;
+      }
       if (options.continueOnError !== undefined) {
         globalConfig.continueOnError = options.continueOnError;
       }
@@ -367,6 +377,11 @@ class CurlRunnerCLI {
             options.retries = Number.parseInt(nextArg, 10);
           } else if (key === 'retry-delay') {
             options.retryDelay = Number.parseInt(nextArg, 10);
+          } else if (key === 'max-concurrent') {
+            const maxConcurrent = Number.parseInt(nextArg, 10);
+            if (maxConcurrent > 0) {
+              options.maxConcurrent = maxConcurrent;
+            }
           } else if (key === 'fail-on') {
             options.failOn = Number.parseInt(nextArg, 10);
           } else if (key === 'fail-on-percentage') {
@@ -603,6 +618,7 @@ ${this.logger.color('OPTIONS:', 'yellow')}
   -v, --verbose                 Enable verbose output
   -q, --quiet                   Suppress non-error output
   -p, --execution parallel      Execute requests in parallel
+  --max-concurrent <n>          Limit concurrent requests in parallel mode
   -c, --continue-on-error       Continue execution on errors
   -o, --output <file>           Save results to file
   --all                         Find all YAML files recursively
@@ -638,6 +654,9 @@ ${this.logger.color('EXAMPLES:', 'yellow')}
   # Run all files recursively in parallel
   curl-runner --all -p
 
+  # Run in parallel with max 5 concurrent requests
+  curl-runner -p --max-concurrent 5 tests.yaml
+
   # Run directory recursively
   curl-runner --all examples/
 

package/src/executor/max-concurrency.test.ts

@@ -0,0 +1,139 @@
+import { describe, expect, test } from 'bun:test';
+import type { GlobalConfig, RequestConfig } from '../types/config';
+
+/**
+ * Simulates the chunked execution logic from executeParallel
+ * Returns the chunks that would be created based on maxConcurrency
+ */
+function getExecutionChunks(
+  requests: RequestConfig[],
+  maxConcurrency: number | undefined,
+): RequestConfig[][] {
+  if (!maxConcurrency || maxConcurrency >= requests.length) {
+    return [requests]; // All requests in a single batch
+  }
+
+  const chunks: RequestConfig[][] = [];
+  for (let i = 0; i < requests.length; i += maxConcurrency) {
+    chunks.push(requests.slice(i, i + maxConcurrency));
+  }
+  return chunks;
+}
+
+/**
+ * Creates mock requests for testing
+ */
+function createMockRequests(count: number): RequestConfig[] {
+  return Array.from({ length: count }, (_, i) => ({
+    url: `https://api.example.com/request/${i + 1}`,
+    method: 'GET' as const,
+    name: `Request ${i + 1}`,
+  }));
+}
+
+describe('maxConcurrency parallel execution', () => {
+  describe('chunk creation', () => {
+    test('should execute all requests at once when maxConcurrency is not set', () => {
+      const requests = createMockRequests(10);
+      const chunks = getExecutionChunks(requests, undefined);
+      expect(chunks).toHaveLength(1);
+      expect(chunks[0]).toHaveLength(10);
+    });
+
+    test('should execute all requests at once when maxConcurrency >= requests.length', () => {
+      const requests = createMockRequests(5);
+      const chunks = getExecutionChunks(requests, 10);
+      expect(chunks).toHaveLength(1);
+      expect(chunks[0]).toHaveLength(5);
+    });
+
+    test('should create correct chunks when maxConcurrency is 1', () => {
+      const requests = createMockRequests(3);
+      const chunks = getExecutionChunks(requests, 1);
+      expect(chunks).toHaveLength(3);
+      expect(chunks[0]).toHaveLength(1);
+      expect(chunks[1]).toHaveLength(1);
+      expect(chunks[2]).toHaveLength(1);
+    });
+
+    test('should create correct chunks when maxConcurrency is 2', () => {
+      const requests = createMockRequests(5);
+      const chunks = getExecutionChunks(requests, 2);
+      expect(chunks).toHaveLength(3);
+      expect(chunks[0]).toHaveLength(2);
+      expect(chunks[1]).toHaveLength(2);
+      expect(chunks[2]).toHaveLength(1);
+    });
+
+    test('should create correct chunks when maxConcurrency is 3', () => {
+      const requests = createMockRequests(10);
+      const chunks = getExecutionChunks(requests, 3);
+      expect(chunks).toHaveLength(4);
+      expect(chunks[0]).toHaveLength(3);
+      expect(chunks[1]).toHaveLength(3);
+      expect(chunks[2]).toHaveLength(3);
+      expect(chunks[3]).toHaveLength(1);
+    });
+
+    test('should handle edge case with maxConcurrency equal to requests length', () => {
+      const requests = createMockRequests(5);
+      const chunks = getExecutionChunks(requests, 5);
+      expect(chunks).toHaveLength(1);
+      expect(chunks[0]).toHaveLength(5);
+    });
+
+    test('should preserve request order across chunks', () => {
+      const requests = createMockRequests(6);
+      const chunks = getExecutionChunks(requests, 2);
+
+      // Verify order is preserved
+      expect(chunks[0][0].name).toBe('Request 1');
+      expect(chunks[0][1].name).toBe('Request 2');
+      expect(chunks[1][0].name).toBe('Request 3');
+      expect(chunks[1][1].name).toBe('Request 4');
+      expect(chunks[2][0].name).toBe('Request 5');
+      expect(chunks[2][1].name).toBe('Request 6');
+    });
+  });
+
+  describe('GlobalConfig maxConcurrency validation', () => {
+    test('should accept valid maxConcurrency values', () => {
+      const config1: GlobalConfig = { execution: 'parallel', maxConcurrency: 1 };
+      expect(config1.maxConcurrency).toBe(1);
+
+      const config2: GlobalConfig = { execution: 'parallel', maxConcurrency: 5 };
+      expect(config2.maxConcurrency).toBe(5);
+
+      const config3: GlobalConfig = { execution: 'parallel', maxConcurrency: 100 };
+      expect(config3.maxConcurrency).toBe(100);
+    });
+
+    test('should allow undefined maxConcurrency', () => {
+      const config: GlobalConfig = { execution: 'parallel' };
+      expect(config.maxConcurrency).toBeUndefined();
+    });
+  });
+
+  describe('integration with other settings', () => {
+    test('maxConcurrency should coexist with continueOnError', () => {
+      const config: GlobalConfig = {
+        execution: 'parallel',
+        maxConcurrency: 5,
+        continueOnError: true,
+      };
+      expect(config.maxConcurrency).toBe(5);
+      expect(config.continueOnError).toBe(true);
+    });
+
+    test('maxConcurrency should coexist with CI settings', () => {
+      const config: GlobalConfig = {
+        execution: 'parallel',
+        maxConcurrency: 3,
+        ci: { strictExit: true, failOn: 2 },
+      };
+      expect(config.maxConcurrency).toBe(3);
+      expect(config.ci?.strictExit).toBe(true);
+      expect(config.ci?.failOn).toBe(2);
+    });
+  });
+});

package/src/executor/request-executor.ts

@@ -101,7 +101,9 @@ export class RequestExecutor {
       if (attempt > 0) {
         requestLogger.logRetry(attempt, maxAttempts - 1);
         if (config.retry?.delay) {
-          await Bun.sleep(config.retry.delay);
+          const backoff = config.retry.backoff ?? 1;
+          const delay = config.retry.delay * Math.pow(backoff, attempt - 1);
+          await Bun.sleep(delay);
         }
       }
 
@@ -538,10 +540,32 @@ export class RequestExecutor {
 
   async executeParallel(requests: RequestConfig[]): Promise<ExecutionSummary> {
     const startTime = performance.now();
+    const maxConcurrency = this.globalConfig.maxConcurrency;
 
-    const promises = requests.map((request, index) => this.executeRequest(request, index + 1));
+    // If no concurrency limit, execute all requests simultaneously
+    if (!maxConcurrency || maxConcurrency >= requests.length) {
+      const promises = requests.map((request, index) => this.executeRequest(request, index + 1));
+      const results = await Promise.all(promises);
+      return this.createSummary(results, performance.now() - startTime);
+    }
 
-    const results = await Promise.all(promises);
+    // Execute in chunks with limited concurrency
+    const results: ExecutionResult[] = [];
+    for (let i = 0; i < requests.length; i += maxConcurrency) {
+      const chunk = requests.slice(i, i + maxConcurrency);
+      const chunkPromises = chunk.map((request, chunkIndex) =>
+        this.executeRequest(request, i + chunkIndex + 1),
+      );
+      const chunkResults = await Promise.all(chunkPromises);
+      results.push(...chunkResults);
+
+      // Check if we should stop on error
+      const hasError = chunkResults.some((r) => !r.success);
+      if (hasError && !this.globalConfig.continueOnError) {
+        this.logger.logError('Stopping execution due to error');
+        break;
+      }
+    }
 
     return this.createSummary(results, performance.now() - startTime);
   }

package/src/types/config.ts

@@ -92,6 +92,9 @@ export interface RequestConfig {
   retry?: {
     count: number;
     delay?: number;
+    /** Exponential backoff multiplier. Default is 1 (no backoff).
+     * Example: with delay=1000 and backoff=2, delays are: 1000ms, 2000ms, 4000ms, 8000ms... */
+    backoff?: number;
   };
   variables?: Record<string, string>;
   /**
@@ -159,6 +162,12 @@ export interface CIExitConfig {
 
 export interface GlobalConfig {
   execution?: 'sequential' | 'parallel';
+  /**
+   * Maximum number of concurrent requests when using parallel execution.
+   * If not set, all requests will execute simultaneously.
+   * Useful for avoiding rate limiting or overwhelming target servers.
+   */
+  maxConcurrency?: number;
   continueOnError?: boolean;
   /**
    * CI/CD exit code configuration.