@curl-runner/cli 1.5.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curl-runner/cli",
-  "version": "1.5.0",
+  "version": "1.7.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

@@ -538,10 +538,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/parser/yaml.test.ts

@@ -175,6 +175,84 @@ describe('YamlParser.resolveVariable', () => {
   });
 });
 
+describe('YamlParser string transforms', () => {
+  test('should transform variable to uppercase with :upper', () => {
+    const variables = { ENV: 'production' };
+    const result = YamlParser.resolveVariable('ENV:upper', variables, {});
+    expect(result).toBe('PRODUCTION');
+  });
+
+  test('should transform variable to lowercase with :lower', () => {
+    const variables = { RESOURCE: 'USERS' };
+    const result = YamlParser.resolveVariable('RESOURCE:lower', variables, {});
+    expect(result).toBe('users');
+  });
+
+  test('should return null for transform on missing variable', () => {
+    const result = YamlParser.resolveVariable('MISSING:upper', {}, {});
+    expect(result).toBeNull();
+  });
+
+  test('should work with interpolateVariables for :upper transform', () => {
+    const obj = {
+      headers: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing string transform
+        'X-Environment': '${ENV:upper}',
+      },
+    };
+    const variables = { ENV: 'production' };
+    const result = YamlParser.interpolateVariables(obj, variables);
+    expect(result).toEqual({
+      headers: {
+        'X-Environment': 'PRODUCTION',
+      },
+    });
+  });
+
+  test('should work with interpolateVariables for :lower transform', () => {
+    const obj = {
+      headers: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing string transform
+        'X-Resource': '${RESOURCE:lower}',
+      },
+    };
+    const variables = { RESOURCE: 'USERS' };
+    const result = YamlParser.interpolateVariables(obj, variables);
+    expect(result).toEqual({
+      headers: {
+        'X-Resource': 'users',
+      },
+    });
+  });
+
+  test('should mix transforms with regular variables', () => {
+    const obj = {
+      // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing string transform
+      url: '${BASE_URL}/${RESOURCE:lower}',
+      headers: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing string transform
+        'X-Environment': '${ENV:upper}',
+      },
+    };
+    const variables = { BASE_URL: 'https://api.example.com', RESOURCE: 'Users', ENV: 'staging' };
+    const result = YamlParser.interpolateVariables(obj, variables);
+    expect(result).toEqual({
+      url: 'https://api.example.com/users',
+      headers: {
+        'X-Environment': 'STAGING',
+      },
+    });
+  });
+
+  test('should keep unresolved transforms as-is', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing string transform
+    const obj = { value: '${MISSING:upper}' };
+    const result = YamlParser.interpolateVariables(obj, {});
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing string transform
+    expect(result).toEqual({ value: '${MISSING:upper}' });
+  });
+});
+
 describe('YamlParser.resolveVariable with default values', () => {
   test('should use default value when variable is not set', () => {
     const result = YamlParser.resolveVariable('API_TIMEOUT:5000', {}, {});
@@ -189,17 +267,20 @@ describe('YamlParser.resolveVariable with default values', () => {
 
   test('should handle nested default with first variable set', () => {
     const variables = { DATABASE_HOST: 'prod-db.example.com' };
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing variable interpolation
     const result = YamlParser.resolveVariable('DATABASE_HOST:${DB_HOST:localhost}', variables, {});
     expect(result).toBe('prod-db.example.com');
   });
 
   test('should handle nested default with second variable set', () => {
     const variables = { DB_HOST: 'staging-db.example.com' };
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing variable interpolation
     const result = YamlParser.resolveVariable('DATABASE_HOST:${DB_HOST:localhost}', variables, {});
     expect(result).toBe('staging-db.example.com');
   });
 
   test('should use final fallback when no variables are set', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing variable interpolation
     const result = YamlParser.resolveVariable('DATABASE_HOST:${DB_HOST:localhost}', {}, {});
     expect(result).toBe('localhost');
   });

package/src/parser/yaml.ts

@@ -39,7 +39,11 @@ export class YamlParser {
       }
 
       // Check if it's a single variable that spans the entire string
-      if (extractedVars.length === 1 && extractedVars[0].start === 0 && extractedVars[0].end === obj.length) {
+      if (
+        extractedVars.length === 1 &&
+        extractedVars[0].start === 0 &&
+        extractedVars[0].end === obj.length
+      ) {
         const varName = extractedVars[0].name;
         const resolvedValue = YamlParser.resolveVariable(varName, variables, storeContext);
         return resolvedValue !== null ? resolvedValue : obj;
@@ -75,7 +79,7 @@ export class YamlParser {
 
   /**
    * Resolves a single variable reference.
-   * Priority: store context > dynamic variables > static variables > default values
+   * Priority: store context > string transforms > dynamic variables > static variables > default values
    */
   static resolveVariable(
     varName: string,
@@ -91,6 +95,19 @@ export class YamlParser {
       return null; // Store variable not found, return null to keep original
     }
 
+    // Check for string transforms: ${VAR:upper} or ${VAR:lower}
+    const transformMatch = varName.match(/^([^:]+):(upper|lower)$/);
+    if (transformMatch) {
+      const baseVarName = transformMatch[1];
+      const transform = transformMatch[2];
+      const baseValue = variables[baseVarName] || process.env[baseVarName];
+
+      if (baseValue) {
+        return transform === 'upper' ? baseValue.toUpperCase() : baseValue.toLowerCase();
+      }
+      return null; // Base variable not found
+    }
+
     // Check for default value syntax: ${VAR:default}
     // Must check before dynamic variables to properly handle defaults
     const colonIndex = varName.indexOf(':');

package/src/types/config.ts

@@ -159,6 +159,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.