@curl-runner/cli 1.0.3 → 1.2.0

package/src/executor/request-executor.ts

@@ -1,12 +1,15 @@
+import { YamlParser } from '../parser/yaml';
 import type {
   ExecutionResult,
   ExecutionSummary,
   GlobalConfig,
   JsonValue,
   RequestConfig,
+  ResponseStoreContext,
 } from '../types/config';
 import { CurlBuilder } from '../utils/curl-builder';
 import { Logger } from '../utils/logger';
+import { createStoreContext, extractStoreValues } from '../utils/response-store';
 
 export class RequestExecutor {
   private logger: Logger;
@@ -423,11 +426,21 @@ export class RequestExecutor {
   async executeSequential(requests: RequestConfig[]): Promise<ExecutionSummary> {
     const startTime = performance.now();
     const results: ExecutionResult[] = [];
+    const storeContext = createStoreContext();
 
     for (let i = 0; i < requests.length; i++) {
-      const result = await this.executeRequest(requests[i], i + 1);
+      // Interpolate store variables before execution
+      const interpolatedRequest = this.interpolateStoreVariables(requests[i], storeContext);
+      const result = await this.executeRequest(interpolatedRequest, i + 1);
       results.push(result);
 
+      // Store values from successful responses
+      if (result.success && interpolatedRequest.store) {
+        const storedValues = extractStoreValues(result, interpolatedRequest.store);
+        Object.assign(storeContext, storedValues);
+        this.logStoredValues(storedValues);
+      }
+
       if (!result.success && !this.globalConfig.continueOnError) {
         this.logger.logError('Stopping execution due to error');
         break;
@@ -437,6 +450,39 @@ export class RequestExecutor {
     return this.createSummary(results, performance.now() - startTime);
   }
 
+  /**
+   * Interpolates store variables (${store.variableName}) in a request config.
+   * This is called at execution time to resolve values from previous responses.
+   */
+  private interpolateStoreVariables(
+    request: RequestConfig,
+    storeContext: ResponseStoreContext,
+  ): RequestConfig {
+    // Only interpolate if there are stored values
+    if (Object.keys(storeContext).length === 0) {
+      return request;
+    }
+
+    // Re-interpolate the request with store context
+    // We pass empty variables since static variables were already resolved
+    return YamlParser.interpolateVariables(request, {}, storeContext) as RequestConfig;
+  }
+
+  /**
+   * Logs stored values for debugging purposes.
+   */
+  private logStoredValues(values: ResponseStoreContext): void {
+    if (Object.keys(values).length === 0) {
+      return;
+    }
+
+    const entries = Object.entries(values);
+    for (const [key, value] of entries) {
+      const displayValue = value.length > 50 ? `${value.substring(0, 50)}...` : value;
+      this.logger.logInfo(`Stored: ${key} = "${displayValue}"`);
+    }
+  }
+
   async executeParallel(requests: RequestConfig[]): Promise<ExecutionSummary> {
     const startTime = performance.now();
 

package/src/parser/yaml.test.ts

@@ -0,0 +1,176 @@
+import { describe, expect, test } from 'bun:test';
+import { YamlParser } from './yaml';
+
+describe('YamlParser.interpolateVariables with store context', () => {
+  test('should resolve store variables', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+    const obj = { url: 'https://api.example.com/users/${store.userId}' };
+    const variables = {};
+    const storeContext = { userId: '123' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    expect(result).toEqual({ url: 'https://api.example.com/users/123' });
+  });
+
+  test('should resolve multiple store variables in one string', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+    const obj = { url: 'https://api.example.com/users/${store.userId}/posts/${store.postId}' };
+    const variables = {};
+    const storeContext = { userId: '123', postId: '456' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    expect(result).toEqual({ url: 'https://api.example.com/users/123/posts/456' });
+  });
+
+  test('should resolve store variables in nested objects', () => {
+    const obj = {
+      headers: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+        Authorization: 'Bearer ${store.token}',
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+        'X-User-Id': '${store.userId}',
+      },
+    };
+    const variables = {};
+    const storeContext = { token: 'jwt-token', userId: '123' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    expect(result).toEqual({
+      headers: {
+        Authorization: 'Bearer jwt-token',
+        'X-User-Id': '123',
+      },
+    });
+  });
+
+  test('should resolve store variables in arrays', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+    const obj = { ids: ['${store.id1}', '${store.id2}'] };
+    const variables = {};
+    const storeContext = { id1: '1', id2: '2' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    expect(result).toEqual({ ids: ['1', '2'] });
+  });
+
+  test('should keep unresolved store variables as-is', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+    const obj = { url: 'https://api.example.com/users/${store.missing}' };
+    const variables = {};
+    const storeContext = {};
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+    expect(result).toEqual({ url: 'https://api.example.com/users/${store.missing}' });
+  });
+
+  test('should mix store variables with static variables', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+    const obj = { url: '${BASE_URL}/users/${store.userId}' };
+    const variables = { BASE_URL: 'https://api.example.com' };
+    const storeContext = { userId: '123' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    expect(result).toEqual({ url: 'https://api.example.com/users/123' });
+  });
+
+  test('should work without store context (backwards compatibility)', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing variable interpolation
+    const obj = { url: '${BASE_URL}/users' };
+    const variables = { BASE_URL: 'https://api.example.com' };
+
+    const result = YamlParser.interpolateVariables(obj, variables);
+    expect(result).toEqual({ url: 'https://api.example.com/users' });
+  });
+
+  test('should resolve single store variable as exact value', () => {
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+    const obj = { userId: '${store.userId}' };
+    const variables = {};
+    const storeContext = { userId: '123' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    expect(result).toEqual({ userId: '123' });
+  });
+
+  test('should mix store variables with dynamic variables', () => {
+    const obj = {
+      headers: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing variable interpolation
+        'X-Request-ID': '${UUID}',
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+        Authorization: 'Bearer ${store.token}',
+      },
+    };
+    const variables = {};
+    const storeContext = { token: 'my-token' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext) as typeof obj;
+    // UUID should be a valid UUID string
+    expect(result.headers['X-Request-ID']).toMatch(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+    );
+    expect(result.headers.Authorization).toBe('Bearer my-token');
+  });
+
+  test('should resolve store variables in request body', () => {
+    const obj = {
+      body: {
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+        userId: '${store.userId}',
+        name: 'Test User',
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: Testing ${store.xxx} interpolation
+        parentId: '${store.parentId}',
+      },
+    };
+    const variables = {};
+    const storeContext = { userId: '123', parentId: '456' };
+
+    const result = YamlParser.interpolateVariables(obj, variables, storeContext);
+    expect(result).toEqual({
+      body: {
+        userId: '123',
+        name: 'Test User',
+        parentId: '456',
+      },
+    });
+  });
+});
+
+describe('YamlParser.resolveVariable', () => {
+  test('should resolve store variable', () => {
+    const storeContext = { userId: '123' };
+    const result = YamlParser.resolveVariable('store.userId', {}, storeContext);
+    expect(result).toBe('123');
+  });
+
+  test('should return null for missing store variable', () => {
+    const storeContext = { other: 'value' };
+    const result = YamlParser.resolveVariable('store.missing', {}, storeContext);
+    expect(result).toBeNull();
+  });
+
+  test('should resolve dynamic variable', () => {
+    const result = YamlParser.resolveVariable('UUID', {}, {});
+    expect(result).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i);
+  });
+
+  test('should resolve static variable', () => {
+    const variables = { BASE_URL: 'https://api.example.com' };
+    const result = YamlParser.resolveVariable('BASE_URL', variables, {});
+    expect(result).toBe('https://api.example.com');
+  });
+
+  test('should return null for unknown variable', () => {
+    const result = YamlParser.resolveVariable('UNKNOWN', {}, {});
+    expect(result).toBeNull();
+  });
+
+  test('should prioritize store context over static variables', () => {
+    // This test ensures store.X prefix is properly handled
+    const variables = { 'store.userId': 'static-value' };
+    const storeContext = { userId: 'store-value' };
+    const result = YamlParser.resolveVariable('store.userId', variables, storeContext);
+    expect(result).toBe('store-value');
+  });
+});

package/src/parser/yaml.ts

@@ -1,5 +1,5 @@
 import { YAML } from 'bun';
-import type { RequestConfig, YamlFile } from '../types/config';
+import type { RequestConfig, ResponseStoreContext, YamlFile } from '../types/config';
 
 // Using class for organization, but could be refactored to functions
 export class YamlParser {
@@ -13,31 +13,45 @@ export class YamlParser {
     return YAML.parse(content) as YamlFile;
   }
 
-  static interpolateVariables(obj: unknown, variables: Record<string, string>): unknown {
+  /**
+   * Interpolates variables in an object, supporting:
+   * - Static variables: ${VAR_NAME}
+   * - Dynamic variables: ${UUID}, ${TIMESTAMP}, ${DATE:format}, ${TIME:format}
+   * - Stored response values: ${store.variableName}
+   *
+   * @param obj - The object to interpolate
+   * @param variables - Static variables map
+   * @param storeContext - Optional stored response values from previous requests
+   */
+  static interpolateVariables(
+    obj: unknown,
+    variables: Record<string, string>,
+    storeContext?: ResponseStoreContext,
+  ): unknown {
     if (typeof obj === 'string') {
       // Check if it's a single variable like ${VAR} (no other characters)
       const singleVarMatch = obj.match(/^\$\{([^}]+)\}$/);
       if (singleVarMatch) {
         const varName = singleVarMatch[1];
-        const dynamicValue = YamlParser.resolveDynamicVariable(varName);
-        return dynamicValue !== null ? dynamicValue : variables[varName] || obj;
+        const resolvedValue = YamlParser.resolveVariable(varName, variables, storeContext);
+        return resolvedValue !== null ? resolvedValue : obj;
       }
 
       // Handle multiple variables in the string using regex replacement
       return obj.replace(/\$\{([^}]+)\}/g, (match, varName) => {
-        const dynamicValue = YamlParser.resolveDynamicVariable(varName);
-        return dynamicValue !== null ? dynamicValue : variables[varName] || match;
+        const resolvedValue = YamlParser.resolveVariable(varName, variables, storeContext);
+        return resolvedValue !== null ? resolvedValue : match;
       });
     }
 
     if (Array.isArray(obj)) {
-      return obj.map((item) => YamlParser.interpolateVariables(item, variables));
+      return obj.map((item) => YamlParser.interpolateVariables(item, variables, storeContext));
     }
 
     if (obj && typeof obj === 'object') {
       const result: Record<string, unknown> = {};
       for (const [key, value] of Object.entries(obj)) {
-        result[key] = YamlParser.interpolateVariables(value, variables);
+        result[key] = YamlParser.interpolateVariables(value, variables, storeContext);
       }
       return result;
     }
@@ -45,6 +59,38 @@ export class YamlParser {
     return obj;
   }
 
+  /**
+   * Resolves a single variable reference.
+   * Priority: store context > dynamic variables > static variables
+   */
+  static resolveVariable(
+    varName: string,
+    variables: Record<string, string>,
+    storeContext?: ResponseStoreContext,
+  ): string | null {
+    // Check for store variable (${store.variableName})
+    if (varName.startsWith('store.') && storeContext) {
+      const storeVarName = varName.slice(6); // Remove 'store.' prefix
+      if (storeVarName in storeContext) {
+        return storeContext[storeVarName];
+      }
+      return null; // Store variable not found, return null to keep original
+    }
+
+    // Check for dynamic variable
+    const dynamicValue = YamlParser.resolveDynamicVariable(varName);
+    if (dynamicValue !== null) {
+      return dynamicValue;
+    }
+
+    // Check for static variable
+    if (varName in variables) {
+      return variables[varName];
+    }
+
+    return null;
+  }
+
   static resolveDynamicVariable(varName: string): string | null {
     // UUID generation
     if (varName === 'UUID') {

package/src/types/config.ts

@@ -4,6 +4,18 @@ export interface JsonObject {
 }
 export interface JsonArray extends Array<JsonValue> {}
 
+/**
+ * Configuration for storing response values as variables for subsequent requests.
+ * Maps a variable name to a JSON path in the response.
+ *
+ * Examples:
+ * - `{ "userId": "body.id" }` - Store response body's id field as ${store.userId}
+ * - `{ "token": "body.data.token" }` - Store nested field
+ * - `{ "statusCode": "status" }` - Store HTTP status code
+ * - `{ "contentType": "headers.content-type" }` - Store response header
+ */
+export type StoreConfig = Record<string, string>;
+
 export interface RequestConfig {
   name?: string;
   url: string;
@@ -29,6 +41,18 @@ export interface RequestConfig {
     delay?: number;
   };
   variables?: Record<string, string>;
+  /**
+   * Store response values as variables for subsequent requests.
+   * Use JSON path syntax to extract values from the response.
+   *
+   * @example
+   * store:
+   *   userId: body.id
+   *   token: body.data.accessToken
+   *   statusCode: status
+   *   contentType: headers.content-type
+   */
+  store?: StoreConfig;
   expect?: {
     failure?: boolean; // If true, expect the request to fail (for negative testing)
     status?: number | number[];
@@ -55,9 +79,39 @@ export interface CollectionConfig {
   requests: RequestConfig[];
 }
 
+/**
+ * CI exit code configuration options.
+ * These options control how curl-runner exits in CI/CD pipelines.
+ */
+export interface CIExitConfig {
+  /**
+   * When true, exit with code 1 if any validation failures occur,
+   * regardless of the continueOnError setting.
+   * This is useful for CI/CD pipelines that need strict validation.
+   */
+  strictExit?: boolean;
+  /**
+   * Maximum number of failures allowed before exiting with code 1.
+   * If set to 0, any failure will cause a non-zero exit.
+   * If undefined and strictExit is true, any failure causes non-zero exit.
+   */
+  failOn?: number;
+  /**
+   * Maximum percentage of failures allowed before exiting with code 1.
+   * Value should be between 0 and 100.
+   * If set to 10, up to 10% of requests can fail without causing a non-zero exit.
+   */
+  failOnPercentage?: number;
+}
+
 export interface GlobalConfig {
   execution?: 'sequential' | 'parallel';
   continueOnError?: boolean;
+  /**
+   * CI/CD exit code configuration.
+   * Controls when curl-runner should exit with non-zero status codes.
+   */
+  ci?: CIExitConfig;
   variables?: Record<string, string>;
   output?: {
     verbose?: boolean;
@@ -104,3 +158,9 @@ export interface ExecutionSummary {
   duration: number;
   results: ExecutionResult[];
 }
+
+/**
+ * Context for storing response values between sequential requests.
+ * Values are stored as strings and can be referenced using ${store.variableName} syntax.
+ */
+export type ResponseStoreContext = Record<string, string>;

package/src/utils/response-store.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, test } from 'bun:test';
+import type { ExecutionResult } from '../types/config';
+import {
+  createStoreContext,
+  extractStoreValues,
+  getValueByPath,
+  mergeStoreContext,
+  valueToString,
+} from './response-store';
+
+describe('getValueByPath', () => {
+  const testObj = {
+    status: 200,
+    body: {
+      id: 123,
+      user: {
+        name: 'John',
+        email: 'john@example.com',
+      },
+      items: [
+        { id: 1, name: 'Item 1' },
+        { id: 2, name: 'Item 2' },
+      ],
+    },
+    headers: {
+      'content-type': 'application/json',
+      'x-request-id': 'abc123',
+    },
+  };
+
+  test('should get top-level value', () => {
+    expect(getValueByPath(testObj, 'status')).toBe(200);
+  });
+
+  test('should get nested value', () => {
+    expect(getValueByPath(testObj, 'body.id')).toBe(123);
+    expect(getValueByPath(testObj, 'body.user.name')).toBe('John');
+    expect(getValueByPath(testObj, 'body.user.email')).toBe('john@example.com');
+  });
+
+  test('should get header value', () => {
+    expect(getValueByPath(testObj, 'headers.content-type')).toBe('application/json');
+    expect(getValueByPath(testObj, 'headers.x-request-id')).toBe('abc123');
+  });
+
+  test('should get array element by index', () => {
+    expect(getValueByPath(testObj, 'body.items.0.id')).toBe(1);
+    expect(getValueByPath(testObj, 'body.items.1.name')).toBe('Item 2');
+  });
+
+  test('should get array element using bracket notation', () => {
+    expect(getValueByPath(testObj, 'body.items[0].id')).toBe(1);
+    expect(getValueByPath(testObj, 'body.items[1].name')).toBe('Item 2');
+  });
+
+  test('should return undefined for non-existent path', () => {
+    expect(getValueByPath(testObj, 'body.nonexistent')).toBeUndefined();
+    expect(getValueByPath(testObj, 'body.user.age')).toBeUndefined();
+    expect(getValueByPath(testObj, 'nonexistent.path')).toBeUndefined();
+  });
+
+  test('should return undefined for null or undefined object', () => {
+    expect(getValueByPath(null, 'any.path')).toBeUndefined();
+    expect(getValueByPath(undefined, 'any.path')).toBeUndefined();
+  });
+
+  test('should handle primitive values correctly', () => {
+    expect(getValueByPath('string', 'length')).toBeUndefined();
+    expect(getValueByPath(123, 'toString')).toBeUndefined();
+  });
+});
+
+describe('valueToString', () => {
+  test('should convert string to string', () => {
+    expect(valueToString('hello')).toBe('hello');
+  });
+
+  test('should convert number to string', () => {
+    expect(valueToString(123)).toBe('123');
+    expect(valueToString(45.67)).toBe('45.67');
+  });
+
+  test('should convert boolean to string', () => {
+    expect(valueToString(true)).toBe('true');
+    expect(valueToString(false)).toBe('false');
+  });
+
+  test('should convert null and undefined to empty string', () => {
+    expect(valueToString(null)).toBe('');
+    expect(valueToString(undefined)).toBe('');
+  });
+
+  test('should JSON stringify objects', () => {
+    expect(valueToString({ a: 1 })).toBe('{"a":1}');
+  });
+
+  test('should JSON stringify arrays', () => {
+    expect(valueToString([1, 2, 3])).toBe('[1,2,3]');
+  });
+});
+
+describe('extractStoreValues', () => {
+  const mockResult: ExecutionResult = {
+    request: {
+      url: 'https://api.example.com/users',
+      method: 'POST',
+    },
+    success: true,
+    status: 201,
+    headers: {
+      'content-type': 'application/json',
+      'x-request-id': 'req-12345',
+    },
+    body: {
+      id: 456,
+      data: {
+        token: 'jwt-token-here',
+        user: {
+          id: 789,
+          name: 'Test User',
+        },
+      },
+    },
+    metrics: {
+      duration: 150,
+      size: 1024,
+    },
+  };
+
+  test('should extract status', () => {
+    const result = extractStoreValues(mockResult, {
+      statusCode: 'status',
+    });
+    expect(result.statusCode).toBe('201');
+  });
+
+  test('should extract body fields', () => {
+    const result = extractStoreValues(mockResult, {
+      userId: 'body.id',
+      token: 'body.data.token',
+      userName: 'body.data.user.name',
+    });
+    expect(result.userId).toBe('456');
+    expect(result.token).toBe('jwt-token-here');
+    expect(result.userName).toBe('Test User');
+  });
+
+  test('should extract header values', () => {
+    const result = extractStoreValues(mockResult, {
+      contentType: 'headers.content-type',
+      requestId: 'headers.x-request-id',
+    });
+    expect(result.contentType).toBe('application/json');
+    expect(result.requestId).toBe('req-12345');
+  });
+
+  test('should extract metrics', () => {
+    const result = extractStoreValues(mockResult, {
+      duration: 'metrics.duration',
+    });
+    expect(result.duration).toBe('150');
+  });
+
+  test('should handle non-existent paths', () => {
+    const result = extractStoreValues(mockResult, {
+      missing: 'body.nonexistent',
+    });
+    expect(result.missing).toBe('');
+  });
+
+  test('should extract multiple values', () => {
+    const result = extractStoreValues(mockResult, {
+      id: 'body.id',
+      status: 'status',
+      contentType: 'headers.content-type',
+    });
+    expect(result.id).toBe('456');
+    expect(result.status).toBe('201');
+    expect(result.contentType).toBe('application/json');
+  });
+});
+
+describe('createStoreContext', () => {
+  test('should create empty context', () => {
+    const context = createStoreContext();
+    expect(context).toEqual({});
+  });
+});
+
+describe('mergeStoreContext', () => {
+  test('should merge contexts', () => {
+    const existing = { a: '1', b: '2' };
+    const newValues = { c: '3', d: '4' };
+    const merged = mergeStoreContext(existing, newValues);
+    expect(merged).toEqual({ a: '1', b: '2', c: '3', d: '4' });
+  });
+
+  test('should override existing values', () => {
+    const existing = { a: '1', b: '2' };
+    const newValues = { b: 'new', c: '3' };
+    const merged = mergeStoreContext(existing, newValues);
+    expect(merged).toEqual({ a: '1', b: 'new', c: '3' });
+  });
+
+  test('should not mutate original contexts', () => {
+    const existing = { a: '1' };
+    const newValues = { b: '2' };
+    const merged = mergeStoreContext(existing, newValues);
+    expect(existing).toEqual({ a: '1' });
+    expect(newValues).toEqual({ b: '2' });
+    expect(merged).toEqual({ a: '1', b: '2' });
+  });
+});