@curl-runner/cli 1.16.0 → 1.16.2

package/src/utils/condition-evaluator.ts

@@ -1,327 +0,0 @@
-import type {
-  ConditionExpression,
-  ConditionOperator,
-  ResponseStoreContext,
-  WhenCondition,
-} from '../types/config';
-import { getValueByPath, valueToString } from './response-store';
-
-/**
- * Result of evaluating a condition.
- */
-export interface ConditionResult {
-  shouldRun: boolean;
-  reason?: string;
-}
-
-/**
- * Parses a string shorthand condition into a ConditionExpression.
- * Supports formats like:
- * - "store.status == 200"
- * - "store.userId exists"
- * - "store.body.type contains user"
- * - "store.version >= 2"
- *
- * @param condition - String condition to parse
- * @returns Parsed ConditionExpression or null if invalid
- */
-export function parseStringCondition(condition: string): ConditionExpression | null {
-  const trimmed = condition.trim();
-
-  // Check for exists/not-exists operators first (unary)
-  const existsMatch = trimmed.match(/^(.+?)\s+(exists|not-exists)$/i);
-  if (existsMatch) {
-    return {
-      left: existsMatch[1].trim(),
-      operator: existsMatch[2].toLowerCase() as ConditionOperator,
-    };
-  }
-
-  // Binary operators pattern
-  const operatorPattern = /^(.+?)\s*(==|!=|>=|<=|>|<|contains|matches)\s*(.+)$/i;
-  const match = trimmed.match(operatorPattern);
-
-  if (!match) {
-    return null;
-  }
-
-  const [, left, operator, right] = match;
-  const rightValue = parseRightValue(right.trim());
-
-  return {
-    left: left.trim(),
-    operator: operator.toLowerCase() as ConditionOperator,
-    right: rightValue,
-  };
-}
-
-/**
- * Parses the right-hand value, converting to appropriate type.
- */
-function parseRightValue(value: string): string | number | boolean {
-  // Boolean
-  if (value === 'true') {
-    return true;
-  }
-  if (value === 'false') {
-    return false;
-  }
-
-  // Number
-  const num = Number(value);
-  if (!Number.isNaN(num) && value !== '') {
-    return num;
-  }
-
-  // String - remove quotes if present
-  if (
-    (value.startsWith('"') && value.endsWith('"')) ||
-    (value.startsWith("'") && value.endsWith("'"))
-  ) {
-    return value.slice(1, -1);
-  }
-
-  return value;
-}
-
-/**
- * Gets a value from the store context using a path.
- * Handles "store.x" prefix by stripping it.
- */
-function getStoreValue(path: string, context: ResponseStoreContext): unknown {
-  // Strip "store." prefix if present
-  const normalizedPath = path.startsWith('store.') ? path.slice(6) : path;
-
-  // First check if it's a direct key in context
-  if (normalizedPath in context) {
-    const value = context[normalizedPath];
-    // Try to parse JSON if it looks like an object/array
-    if (value.startsWith('{') || value.startsWith('[')) {
-      try {
-        return JSON.parse(value);
-      } catch {
-        return value;
-      }
-    }
-    // Try to parse as number
-    const num = Number(value);
-    if (!Number.isNaN(num) && value !== '') {
-      return num;
-    }
-    // Try to parse as boolean
-    if (value === 'true') {
-      return true;
-    }
-    if (value === 'false') {
-      return false;
-    }
-    return value;
-  }
-
-  // Handle nested paths like "body.data.id" where context has "body" as JSON string
-  const parts = normalizedPath.split('.');
-  const rootKey = parts[0];
-
-  if (rootKey in context) {
-    const rootValue = context[rootKey];
-    // Try to parse as JSON and navigate
-    try {
-      const parsed = JSON.parse(rootValue);
-      return getValueByPath(parsed, parts.slice(1).join('.'));
-    } catch {
-      // Not JSON, can't navigate further
-      return undefined;
-    }
-  }
-
-  return undefined;
-}
-
-/**
- * Compares two values based on case sensitivity setting.
- */
-function compareStrings(a: string, b: string, caseSensitive: boolean): boolean {
-  if (caseSensitive) {
-    return a === b;
-  }
-  return a.toLowerCase() === b.toLowerCase();
-}
-
-/**
- * Evaluates a single condition expression against the store context.
- */
-export function evaluateExpression(
-  expr: ConditionExpression,
-  context: ResponseStoreContext,
-): { passed: boolean; description: string } {
-  const leftValue = getStoreValue(expr.left, context);
-  const caseSensitive = expr.caseSensitive ?? false;
-
-  const formatValue = (v: unknown): string => {
-    if (v === undefined) {
-      return 'undefined';
-    }
-    if (v === null) {
-      return 'null';
-    }
-    if (typeof v === 'string') {
-      return `"${v}"`;
-    }
-    return String(v);
-  };
-
-  const description = `${expr.left} ${expr.operator}${expr.right !== undefined ? ` ${formatValue(expr.right)}` : ''}`;
-
-  switch (expr.operator) {
-    case 'exists': {
-      const passed = leftValue !== undefined && leftValue !== null && leftValue !== '';
-      return { passed, description };
-    }
-
-    case 'not-exists': {
-      const passed = leftValue === undefined || leftValue === null || leftValue === '';
-      return { passed, description };
-    }
-
-    case '==': {
-      let passed: boolean;
-      if (typeof leftValue === 'string' && typeof expr.right === 'string') {
-        passed = compareStrings(leftValue, expr.right, caseSensitive);
-      } else {
-        // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for type coercion
-        passed = leftValue == expr.right;
-      }
-      return { passed, description };
-    }
-
-    case '!=': {
-      let passed: boolean;
-      if (typeof leftValue === 'string' && typeof expr.right === 'string') {
-        passed = !compareStrings(leftValue, expr.right, caseSensitive);
-      } else {
-        // biome-ignore lint/suspicious/noDoubleEquals: intentional loose equality for type coercion
-        passed = leftValue != expr.right;
-      }
-      return { passed, description };
-    }
-
-    case '>': {
-      const passed = Number(leftValue) > Number(expr.right);
-      return { passed, description };
-    }
-
-    case '<': {
-      const passed = Number(leftValue) < Number(expr.right);
-      return { passed, description };
-    }
-
-    case '>=': {
-      const passed = Number(leftValue) >= Number(expr.right);
-      return { passed, description };
-    }
-
-    case '<=': {
-      const passed = Number(leftValue) <= Number(expr.right);
-      return { passed, description };
-    }
-
-    case 'contains': {
-      const leftStr = valueToString(leftValue);
-      const rightStr = String(expr.right ?? '');
-      const passed = caseSensitive
-        ? leftStr.includes(rightStr)
-        : leftStr.toLowerCase().includes(rightStr.toLowerCase());
-      return { passed, description };
-    }
-
-    case 'matches': {
-      const leftStr = valueToString(leftValue);
-      const pattern = String(expr.right ?? '');
-      try {
-        const flags = caseSensitive ? '' : 'i';
-        const regex = new RegExp(pattern, flags);
-        const passed = regex.test(leftStr);
-        return { passed, description };
-      } catch {
-        // Invalid regex pattern
-        return { passed: false, description: `${description} (invalid regex)` };
-      }
-    }
-
-    default:
-      return { passed: false, description: `unknown operator: ${expr.operator}` };
-  }
-}
-
-/**
- * Evaluates a WhenCondition against the store context.
- *
- * @param condition - The condition to evaluate
- * @param context - The store context with values from previous requests
- * @returns Result indicating whether the request should run
- */
-export function evaluateCondition(
-  condition: WhenCondition | string,
-  context: ResponseStoreContext,
-): ConditionResult {
-  // Handle string shorthand
-  if (typeof condition === 'string') {
-    const parsed = parseStringCondition(condition);
-    if (!parsed) {
-      return { shouldRun: false, reason: `invalid condition syntax: "${condition}"` };
-    }
-    const result = evaluateExpression(parsed, context);
-    return {
-      shouldRun: result.passed,
-      reason: result.passed ? undefined : `condition not met: ${result.description}`,
-    };
-  }
-
-  // Handle compound "all" condition (AND logic with short-circuit)
-  if (condition.all && condition.all.length > 0) {
-    for (const expr of condition.all) {
-      const result = evaluateExpression(expr, context);
-      if (!result.passed) {
-        return {
-          shouldRun: false,
-          reason: `condition not met: ${result.description}`,
-        };
-      }
-    }
-    return { shouldRun: true };
-  }
-
-  // Handle compound "any" condition (OR logic with short-circuit)
-  if (condition.any && condition.any.length > 0) {
-    const descriptions: string[] = [];
-    for (const expr of condition.any) {
-      const result = evaluateExpression(expr, context);
-      if (result.passed) {
-        return { shouldRun: true };
-      }
-      descriptions.push(result.description);
-    }
-    return {
-      shouldRun: false,
-      reason: `no conditions met: ${descriptions.join(', ')}`,
-    };
-  }
-
-  // Handle single condition (inline left/operator/right)
-  if (condition.left && condition.operator) {
-    const expr: ConditionExpression = {
-      left: condition.left,
-      operator: condition.operator,
-      right: condition.right,
-      caseSensitive: condition.caseSensitive,
-    };
-    const result = evaluateExpression(expr, context);
-    return {
-      shouldRun: result.passed,
-      reason: result.passed ? undefined : `condition not met: ${result.description}`,
-    };
-  }
-
-  // No valid condition found - default to run
-  return { shouldRun: true };
-}

package/src/utils/curl-builder.test.ts

@@ -1,165 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { CurlBuilder } from './curl-builder';
-
-describe('CurlBuilder', () => {
-  describe('buildCommand', () => {
-    test('should build basic GET request', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/api',
-        method: 'GET',
-      });
-
-      expect(command).toContain('curl');
-      expect(command).toContain('-X GET');
-      expect(command).toContain('"https://example.com/api"');
-    });
-
-    test('should build POST request with JSON body', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/api',
-        method: 'POST',
-        body: { name: 'test' },
-      });
-
-      expect(command).toContain('-X POST');
-      expect(command).toContain('-d \'{"name":"test"}\'');
-      expect(command).toContain('Content-Type: application/json');
-    });
-
-    test('should build POST request with form data', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/upload',
-        method: 'POST',
-        formData: {
-          username: 'john',
-          age: 30,
-        },
-      });
-
-      expect(command).toContain('-X POST');
-      expect(command).toContain("-F 'username=john'");
-      expect(command).toContain("-F 'age=30'");
-      expect(command).not.toContain('-d');
-    });
-
-    test('should build POST request with file attachment', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/upload',
-        method: 'POST',
-        formData: {
-          document: {
-            file: './test.pdf',
-          },
-        },
-      });
-
-      expect(command).toContain("-F 'document=@./test.pdf'");
-    });
-
-    test('should build POST request with file attachment and custom filename', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/upload',
-        method: 'POST',
-        formData: {
-          document: {
-            file: './test.pdf',
-            filename: 'report.pdf',
-          },
-        },
-      });
-
-      expect(command).toContain("-F 'document=@./test.pdf;filename=report.pdf'");
-    });
-
-    test('should build POST request with file attachment and content type', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/upload',
-        method: 'POST',
-        formData: {
-          data: {
-            file: './data.json',
-            contentType: 'application/json',
-          },
-        },
-      });
-
-      expect(command).toContain("-F 'data=@./data.json;type=application/json'");
-    });
-
-    test('should build POST request with file attachment including all options', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/upload',
-        method: 'POST',
-        formData: {
-          document: {
-            file: './report.pdf',
-            filename: 'quarterly-report.pdf',
-            contentType: 'application/pdf',
-          },
-        },
-      });
-
-      expect(command).toContain(
-        "-F 'document=@./report.pdf;filename=quarterly-report.pdf;type=application/pdf'",
-      );
-    });
-
-    test('should build POST request with mixed form data and files', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/upload',
-        method: 'POST',
-        formData: {
-          title: 'My Document',
-          description: 'Test upload',
-          file: {
-            file: './document.pdf',
-          },
-        },
-      });
-
-      expect(command).toContain("-F 'title=My Document'");
-      expect(command).toContain("-F 'description=Test upload'");
-      expect(command).toContain("-F 'file=@./document.pdf'");
-    });
-
-    test('should escape single quotes in form field values', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/upload',
-        method: 'POST',
-        formData: {
-          message: "It's a test",
-        },
-      });
-
-      expect(command).toContain("-F 'message=It'\\''s a test'");
-    });
-
-    test('should prefer formData over body when both are present', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/api',
-        method: 'POST',
-        formData: {
-          field: 'value',
-        },
-        body: { name: 'test' },
-      });
-
-      expect(command).toContain("-F 'field=value'");
-      expect(command).not.toContain('-d');
-    });
-
-    test('should handle boolean form field values', () => {
-      const command = CurlBuilder.buildCommand({
-        url: 'https://example.com/api',
-        method: 'POST',
-        formData: {
-          active: true,
-          disabled: false,
-        },
-      });
-
-      expect(command).toContain("-F 'active=true'");
-      expect(command).toContain("-F 'disabled=false'");
-    });
-  });
-});

package/src/utils/curl-builder.ts

@@ -1,209 +0,0 @@
-import type { FileAttachment, FormFieldValue, RequestConfig } from '../types/config';
-
-interface CurlMetrics {
-  response_code?: number;
-  http_code?: number;
-  time_total?: number;
-  size_download?: number;
-  time_namelookup?: number;
-  time_connect?: number;
-  time_appconnect?: number;
-  time_starttransfer?: number;
-}
-
-/**
- * Checks if a form field value is a file attachment.
- */
-function isFileAttachment(value: FormFieldValue): value is FileAttachment {
-  return typeof value === 'object' && value !== null && 'file' in value;
-}
-
-/**
- * Escapes a string value for use in curl -F flag.
- */
-function escapeFormValue(value: string): string {
-  return value.replace(/'/g, "'\\''");
-}
-
-// Using class for organization, but could be refactored to functions
-export class CurlBuilder {
-  static buildCommand(config: RequestConfig): string {
-    const parts: string[] = ['curl'];
-
-    parts.push('-X', config.method || 'GET');
-
-    parts.push('-w', '"\\n__CURL_METRICS_START__%{json}__CURL_METRICS_END__"');
-
-    if (config.headers) {
-      for (const [key, value] of Object.entries(config.headers)) {
-        parts.push('-H', `"${key}: ${value}"`);
-      }
-    }
-
-    if (config.auth) {
-      if (config.auth.type === 'basic' && config.auth.username && config.auth.password) {
-        parts.push('-u', `"${config.auth.username}:${config.auth.password}"`);
-      } else if (config.auth.type === 'bearer' && config.auth.token) {
-        parts.push('-H', `"Authorization: Bearer ${config.auth.token}"`);
-      }
-    }
-
-    if (config.formData) {
-      // Use -F flags for multipart/form-data
-      for (const [fieldName, fieldValue] of Object.entries(config.formData)) {
-        if (isFileAttachment(fieldValue)) {
-          // File attachment: -F "field=@filepath;filename=name;type=mimetype"
-          let fileSpec = `@${fieldValue.file}`;
-          if (fieldValue.filename) {
-            fileSpec += `;filename=${fieldValue.filename}`;
-          }
-          if (fieldValue.contentType) {
-            fileSpec += `;type=${fieldValue.contentType}`;
-          }
-          parts.push('-F', `'${fieldName}=${escapeFormValue(fileSpec)}'`);
-        } else {
-          // Regular form field: -F "field=value"
-          const strValue = String(fieldValue);
-          parts.push('-F', `'${fieldName}=${escapeFormValue(strValue)}'`);
-        }
-      }
-    } else if (config.body) {
-      const bodyStr = typeof config.body === 'string' ? config.body : JSON.stringify(config.body);
-      parts.push('-d', `'${bodyStr.replace(/'/g, "'\\''")}'`);
-
-      if (!config.headers?.['Content-Type']) {
-        parts.push('-H', '"Content-Type: application/json"');
-      }
-    }
-
-    if (config.timeout) {
-      parts.push('--max-time', config.timeout.toString());
-    }
-
-    if (config.followRedirects !== false) {
-      parts.push('-L');
-      if (config.maxRedirects) {
-        parts.push('--max-redirs', config.maxRedirects.toString());
-      }
-    }
-
-    if (config.proxy) {
-      parts.push('-x', config.proxy);
-    }
-
-    // SSL/TLS configuration
-    // insecure: true takes precedence (backwards compatibility)
-    // ssl.verify: false is equivalent to insecure: true
-    if (config.insecure || config.ssl?.verify === false) {
-      parts.push('-k');
-    }
-
-    // SSL certificate options
-    if (config.ssl) {
-      if (config.ssl.ca) {
-        parts.push('--cacert', `"${config.ssl.ca}"`);
-      }
-      if (config.ssl.cert) {
-        parts.push('--cert', `"${config.ssl.cert}"`);
-      }
-      if (config.ssl.key) {
-        parts.push('--key', `"${config.ssl.key}"`);
-      }
-    }
-
-    if (config.output) {
-      parts.push('-o', config.output);
-    }
-
-    parts.push('-s', '-S');
-
-    let url = config.url;
-    if (config.params && Object.keys(config.params).length > 0) {
-      const queryString = new URLSearchParams(config.params).toString();
-      url += (url.includes('?') ? '&' : '?') + queryString;
-    }
-
-    parts.push(`"${url}"`);
-
-    return parts.join(' ');
-  }
-
-  static async executeCurl(command: string): Promise<{
-    success: boolean;
-    status?: number;
-    headers?: Record<string, string>;
-    body?: string;
-    metrics?: {
-      duration: number;
-      size?: number;
-      dnsLookup?: number;
-      tcpConnection?: number;
-      tlsHandshake?: number;
-      firstByte?: number;
-      download?: number;
-    };
-    error?: string;
-  }> {
-    try {
-      const proc = Bun.spawn(['sh', '-c', command], {
-        stdout: 'pipe',
-        stderr: 'pipe',
-      });
-
-      const stdout = await new Response(proc.stdout).text();
-      const stderr = await new Response(proc.stderr).text();
-
-      await proc.exited;
-
-      if (proc.exitCode !== 0 && !stdout) {
-        return {
-          success: false,
-          error: stderr || `Command failed with exit code ${proc.exitCode}`,
-        };
-      }
-
-      let responseBody = stdout;
-      let metrics: CurlMetrics = {};
-
-      const metricsMatch = stdout.match(/__CURL_METRICS_START__(.+?)__CURL_METRICS_END__/);
-      if (metricsMatch) {
-        responseBody = stdout.replace(/__CURL_METRICS_START__.+?__CURL_METRICS_END__/, '').trim();
-        try {
-          metrics = JSON.parse(metricsMatch[1]);
-        } catch (_e) {}
-      }
-
-      const responseHeaders: Record<string, string> = {};
-      if (metrics.response_code) {
-        const headerLines = stderr.split('\n').filter((line) => line.includes(':'));
-        for (const line of headerLines) {
-          const [key, ...valueParts] = line.split(':');
-          if (key && valueParts.length > 0) {
-            responseHeaders[key.trim()] = valueParts.join(':').trim();
-          }
-        }
-      }
-
-      return {
-        success: true,
-        status: metrics.response_code || metrics.http_code,
-        headers: responseHeaders,
-        body: responseBody,
-        metrics: {
-          duration: (metrics.time_total || 0) * 1000,
-          size: metrics.size_download,
-          dnsLookup: (metrics.time_namelookup || 0) * 1000,
-          tcpConnection: (metrics.time_connect || 0) * 1000,
-          tlsHandshake: (metrics.time_appconnect || 0) * 1000,
-          firstByte: (metrics.time_starttransfer || 0) * 1000,
-          download: (metrics.time_total || 0) * 1000,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: error instanceof Error ? error.message : String(error),
-      };
-    }
-  }
-}