@curl-runner/cli 1.0.2 → 1.1.0

package/src/utils/logger.ts

@@ -5,6 +5,64 @@ import type {
   RequestConfig,
 } from '../types/config';
 
+interface TreeNode {
+  label: string;
+  value?: string;
+  children?: TreeNode[];
+  color?: string;
+}
+
+class TreeRenderer {
+  private colors: Record<string, string>;
+
+  constructor(colors: Record<string, string>) {
+    this.colors = colors;
+  }
+
+  private color(text: string, colorName: string): string {
+    if (!colorName || !this.colors[colorName]) {
+      return text;
+    }
+    return `${this.colors[colorName]}${text}${this.colors.reset}`;
+  }
+
+  render(nodes: TreeNode[], basePrefix: string = '   '): void {
+    nodes.forEach((node, index) => {
+      const isLast = index === nodes.length - 1;
+      const prefix = isLast ? `${basePrefix}└─` : `${basePrefix}├─`;
+
+      if (node.label && node.value) {
+        // Regular labeled node with value
+        const displayValue = node.color ? this.color(node.value, node.color) : node.value;
+
+        // Handle multiline values (like Response Body)
+        const lines = displayValue.split('\n');
+        if (lines.length === 1) {
+          console.log(`${prefix} ${node.label}: ${displayValue}`);
+        } else {
+          console.log(`${prefix} ${node.label}:`);
+          const contentPrefix = isLast ? `${basePrefix}   ` : `${basePrefix}│  `;
+          lines.forEach((line) => {
+            console.log(`${contentPrefix}${line}`);
+          });
+        }
+      } else if (node.label && !node.value) {
+        // Section header (like "Headers:" or "Metrics:")
+        console.log(`${prefix} ${node.label}:`);
+      } else if (!node.label && node.value) {
+        // Content line without label (like response body lines)
+        const continuationPrefix = isLast ? `${basePrefix}   ` : `${basePrefix}│  `;
+        console.log(`${continuationPrefix}${node.value}`);
+      }
+
+      if (node.children && node.children.length > 0) {
+        const childPrefix = isLast ? `${basePrefix}   ` : `${basePrefix}│  `;
+        this.render(node.children, childPrefix);
+      }
+    });
+  }
+}
+
 export class Logger {
   private config: GlobalConfig['output'];
 
@@ -40,7 +98,7 @@ export class Logger {
       showBody: true,
       showMetrics: false,
       format: 'pretty',
-      prettyLevel: 'standard',
+      prettyLevel: 'minimal',
       ...config,
     };
   }
@@ -239,56 +297,25 @@ export class Logger {
     return `${(bytes / 1024 ** i).toFixed(2)} ${sizes[i]}`;
   }
 
-  private printSeparator(char: string = '─', length: number = 60): void {
-    console.log(this.color(char.repeat(length), 'dim'));
-  }
-
   logExecutionStart(count: number, mode: string): void {
     if (!this.shouldShowOutput()) {
       return;
     }
 
     if (this.shouldShowSeparators()) {
-      this.printSeparator('═');
-      console.log(this.color('🚀 CURL RUNNER', 'bright'));
-      console.log(this.color(`Executing ${count} request(s) in ${mode} mode`, 'cyan'));
-      this.printSeparator('═');
+      console.log(); // Add spacing before the execution header
+      console.log(this.color(`Executing ${count} request(s) in ${mode} mode`, 'dim'));
+      console.log();
+    } else {
+      // For minimal format, still add spacing after processing info
       console.log();
     }
   }
 
-  logRequestStart(config: RequestConfig, index: number): void {
-    if (!this.shouldShowOutput()) {
-      return;
-    }
-
-    const name = config.name || `Request #${index}`;
-    const sourceFile = config.sourceFile
-      ? ` ${this.color(`[${this.getShortFilename(config.sourceFile)}]`, 'cyan')}`
-      : '';
-    console.log(this.color(`▶ ${name}`, 'bright') + sourceFile);
-    console.log(
-      `  ${this.color(config.method || 'GET', 'yellow')} ${this.color(config.url, 'blue')}`,
-    );
-
-    if (
-      this.shouldShowRequestDetails() &&
-      config.headers &&
-      Object.keys(config.headers).length > 0
-    ) {
-      console.log(this.color('  Headers:', 'dim'));
-      for (const [key, value] of Object.entries(config.headers)) {
-        console.log(`    ${key}: ${value}`);
-      }
-    }
-
-    if (this.shouldShowRequestDetails() && config.body) {
-      console.log(this.color('  Body:', 'dim'));
-      const bodyStr = this.formatJson(config.body);
-      for (const line of bodyStr.split('\n')) {
-        console.log(`    ${line}`);
-      }
-    }
+  logRequestStart(_config: RequestConfig, _index: number): void {
+    // In the new format, we show everything in logRequestComplete
+    // This method is kept for compatibility but simplified
+    return;
   }
 
   logCommand(command: string): void {
@@ -336,62 +363,173 @@ export class Logger {
       return;
     }
 
+    const level = this.config.prettyLevel || 'minimal';
     const statusColor = result.success ? 'green' : 'red';
-    const statusIcon = result.success ? '✓' : '✗';
+    const statusIcon = result.success ? '✓' : 'x';
+    const name = result.request.name || 'Request';
+
+    if (level === 'minimal') {
+      // Minimal format: clean tree structure but compact
+      const fileTag = result.request.sourceFile
+        ? this.getShortFilename(result.request.sourceFile)
+        : 'inline';
+      console.log(
+        `${this.color(statusIcon, statusColor)} ${this.color(name, 'bright')} [${fileTag}]`,
+      );
+
+      const treeNodes: TreeNode[] = [];
+      const renderer = new TreeRenderer(this.colors);
+
+      treeNodes.push({
+        label: result.request.method || 'GET',
+        value: result.request.url,
+        color: 'blue',
+      });
+
+      const statusText = result.status ? `${result.status}` : 'ERROR';
+      treeNodes.push({
+        label: `${statusIcon} Status`,
+        value: statusText,
+        color: statusColor,
+      });
+
+      if (result.metrics) {
+        const durationSize = `${this.formatDuration(result.metrics.duration)} | ${this.formatSize(result.metrics.size)}`;
+        treeNodes.push({
+          label: 'Duration',
+          value: durationSize,
+          color: 'cyan',
+        });
+      }
 
-    console.log(
-      `  ${this.color(statusIcon, statusColor)} ` +
-        `Status: ${this.color(String(result.status || 'ERROR'), statusColor)}`,
-    );
+      renderer.render(treeNodes);
 
-    if (result.error) {
-      this.logValidationErrors(result.error);
+      if (result.error) {
+        console.log();
+        this.logValidationErrors(result.error);
+      }
+
+      console.log();
+      return;
     }
 
-    if (this.shouldShowMetrics() && result.metrics) {
-      const metrics = result.metrics;
-      const parts = [`Duration: ${this.color(this.formatDuration(metrics.duration), 'cyan')}`];
+    // Standard and detailed formats: use clean tree structure
+    console.log(`${this.color(statusIcon, statusColor)} ${this.color(name, 'bright')}`);
 
-      if (metrics.size !== undefined) {
-        parts.push(`Size: ${this.color(this.formatSize(metrics.size), 'cyan')}`);
-      }
+    // Build tree structure
+    const treeNodes: TreeNode[] = [];
+    const renderer = new TreeRenderer(this.colors);
 
-      if (this.shouldShowRequestDetails()) {
-        if (metrics.dnsLookup) {
-          parts.push(`DNS: ${this.formatDuration(metrics.dnsLookup)}`);
-        }
-        if (metrics.tcpConnection) {
-          parts.push(`TCP: ${this.formatDuration(metrics.tcpConnection)}`);
-        }
-        if (metrics.tlsHandshake) {
-          parts.push(`TLS: ${this.formatDuration(metrics.tlsHandshake)}`);
-        }
-        if (metrics.firstByte) {
-          parts.push(`TTFB: ${this.formatDuration(metrics.firstByte)}`);
-        }
-      }
+    // Main info nodes
+    treeNodes.push({ label: 'URL', value: result.request.url, color: 'blue' });
+    treeNodes.push({ label: 'Method', value: result.request.method || 'GET', color: 'yellow' });
+    treeNodes.push({
+      label: 'Status',
+      value: String(result.status || 'ERROR'),
+      color: statusColor,
+    });
 
-      console.log(`  ${parts.join(' | ')}`);
+    if (result.metrics) {
+      treeNodes.push({
+        label: 'Duration',
+        value: this.formatDuration(result.metrics.duration),
+        color: 'cyan',
+      });
     }
 
+    // Add headers section if needed
     if (this.shouldShowHeaders() && result.headers && Object.keys(result.headers).length > 0) {
-      console.log(this.color('  Response Headers:', 'dim'));
-      for (const [key, value] of Object.entries(result.headers)) {
-        console.log(`    ${key}: ${value}`);
-      }
+      const headerChildren: TreeNode[] = Object.entries(result.headers).map(([key, value]) => ({
+        label: this.color(key, 'dim'),
+        value: String(value),
+      }));
+
+      treeNodes.push({
+        label: 'Headers',
+        children: headerChildren,
+      });
     }
 
+    // Add body section if needed
     if (this.shouldShowBody() && result.body) {
-      console.log(this.color('  Response Body:', 'dim'));
       const bodyStr = this.formatJson(result.body);
       const lines = bodyStr.split('\n');
       const maxLines = this.shouldShowRequestDetails() ? Infinity : 10;
-      for (const line of lines.slice(0, maxLines)) {
-        console.log(`    ${line}`);
-      }
+      const bodyLines = lines.slice(0, maxLines);
+
       if (lines.length > maxLines) {
-        console.log(this.color(`    ... (${lines.length - maxLines} more lines)`, 'dim'));
+        bodyLines.push(this.color(`... (${lines.length - maxLines} more lines)`, 'dim'));
       }
+
+      treeNodes.push({
+        label: 'Response Body',
+        value: bodyLines.join('\n'),
+      });
+    }
+
+    // Add detailed metrics section if needed
+    if (this.shouldShowMetrics() && result.metrics && level === 'detailed') {
+      const metrics = result.metrics;
+      const metricChildren: TreeNode[] = [];
+
+      metricChildren.push({
+        label: 'Request Duration',
+        value: this.formatDuration(metrics.duration),
+        color: 'cyan',
+      });
+
+      if (metrics.size !== undefined) {
+        metricChildren.push({
+          label: 'Response Size',
+          value: this.formatSize(metrics.size),
+          color: 'cyan',
+        });
+      }
+
+      if (metrics.dnsLookup) {
+        metricChildren.push({
+          label: 'DNS Lookup',
+          value: this.formatDuration(metrics.dnsLookup),
+          color: 'cyan',
+        });
+      }
+
+      if (metrics.tcpConnection) {
+        metricChildren.push({
+          label: 'TCP Connection',
+          value: this.formatDuration(metrics.tcpConnection),
+          color: 'cyan',
+        });
+      }
+
+      if (metrics.tlsHandshake) {
+        metricChildren.push({
+          label: 'TLS Handshake',
+          value: this.formatDuration(metrics.tlsHandshake),
+          color: 'cyan',
+        });
+      }
+
+      if (metrics.firstByte) {
+        metricChildren.push({
+          label: 'Time to First Byte',
+          value: this.formatDuration(metrics.firstByte),
+          color: 'cyan',
+        });
+      }
+
+      treeNodes.push({
+        label: 'Metrics',
+        children: metricChildren,
+      });
+    }
+
+    // Render the tree
+    renderer.render(treeNodes);
+
+    if (result.error) {
+      console.log();
+      this.logValidationErrors(result.error);
     }
 
     console.log();
@@ -435,53 +573,64 @@ export class Logger {
       return;
     }
 
-    if (this.shouldShowSeparators()) {
-      this.printSeparator('═');
-      const title = isGlobal ? '🎯 OVERALL SUMMARY' : '📊 EXECUTION SUMMARY';
-      console.log(this.color(title, 'bright'));
-      this.printSeparator();
+    const level = this.config.prettyLevel || 'minimal';
+
+    // Add spacing for global summary
+    if (isGlobal) {
+      console.log(); // Extra spacing before global summary
     }
 
-    const successRate = ((summary.successful / summary.total) * 100).toFixed(1);
-    const statusColor =
-      summary.failed === 0 ? 'green' : summary.successful === 0 ? 'red' : 'yellow';
+    if (level === 'minimal') {
+      // Simple one-line summary for minimal, similar to docs example
+      const statusColor = summary.failed === 0 ? 'green' : 'red';
+      const successText =
+        summary.failed === 0
+          ? `${summary.total} request${summary.total === 1 ? '' : 's'} completed successfully`
+          : `${summary.successful}/${summary.total} request${summary.total === 1 ? '' : 's'} completed, ${summary.failed} failed`;
 
-    console.log(`  Total Requests: ${this.color(String(summary.total), 'cyan')}`);
-    console.log(`  Successful: ${this.color(String(summary.successful), 'green')}`);
-    console.log(`  Failed: ${this.color(String(summary.failed), 'red')}`);
-    console.log(`  Success Rate: ${this.color(`${successRate}%`, statusColor)}`);
-    console.log(`  Total Duration: ${this.color(this.formatDuration(summary.duration), 'cyan')}`);
+      const summaryPrefix = isGlobal ? '◆ Global Summary' : 'Summary';
+      console.log(`${summaryPrefix}: ${this.color(successText, statusColor)}`);
+      return;
+    }
+
+    // Compact summary for standard/detailed - much simpler
+    const _successRate = ((summary.successful / summary.total) * 100).toFixed(1);
+    const statusColor = summary.failed === 0 ? 'green' : 'red';
+    const successText =
+      summary.failed === 0
+        ? `${summary.total} request${summary.total === 1 ? '' : 's'} completed successfully`
+        : `${summary.successful}/${summary.total} request${summary.total === 1 ? '' : 's'} completed, ${summary.failed} failed`;
+
+    const summaryPrefix = isGlobal ? '◆ Global Summary' : 'Summary';
+    console.log();
+    console.log(
+      `${summaryPrefix}: ${this.color(successText, statusColor)} (${this.color(this.formatDuration(summary.duration), 'cyan')})`,
+    );
 
     if (summary.failed > 0 && this.shouldShowRequestDetails()) {
-      console.log();
-      console.log(this.color('  Failed Requests:', 'red'));
       summary.results
         .filter((r) => !r.success)
         .forEach((r) => {
           const name = r.request.name || r.request.url;
-          console.log(`    • ${name}: ${r.error}`);
+          console.log(`  ${this.color('•', 'red')} ${name}: ${r.error}`);
         });
     }
-
-    if (this.shouldShowSeparators()) {
-      this.printSeparator('═');
-    }
   }
 
   logError(message: string): void {
-    console.error(this.color(`❌ ${message}`, 'red'));
+    console.error(this.color(`✗ ${message}`, 'red'));
   }
 
   logWarning(message: string): void {
-    console.warn(this.color(`⚠️  ${message}`, 'yellow'));
+    console.warn(this.color(`⚠ ${message}`, 'yellow'));
   }
 
   logInfo(message: string): void {
-    console.log(this.color(`ℹ️  ${message}`, 'blue'));
+    console.log(this.color(`ℹ ${message}`, 'blue'));
   }
 
   logSuccess(message: string): void {
-    console.log(this.color(`✅ ${message}`, 'green'));
+    console.log(this.color(`✓ ${message}`, 'green'));
   }
 
   logFileHeader(fileName: string, requestCount: number): void {
@@ -491,11 +640,9 @@ export class Logger {
 
     const shortName = fileName.replace(/.*\//, '').replace('.yaml', '');
     console.log();
-    this.printSeparator('─');
     console.log(
-      this.color(`📄 ${shortName}.yaml`, 'bright') +
+      this.color(`▶ ${shortName}.yaml`, 'bright') +
         this.color(` (${requestCount} request${requestCount === 1 ? '' : 's'})`, 'dim'),
     );
-    this.printSeparator('─');
   }
 }

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' });
+  });
+});