mpx-api 1.0.0

package/src/commands/load.js

@@ -0,0 +1,161 @@
+import { request } from 'undici';
+import { formatError, formatSuccess, formatInfo } from '../lib/output.js';
+import { requireProLicense } from '../lib/license.js';
+import chalk from 'chalk';
+
+export function registerLoadCommand(program) {
+  program
+    .command('load <url>')
+    .description('Run load test against URL (Pro)')
+    .option('--rps <number>', 'Requests per second', '10')
+    .option('-d, --duration <seconds>', 'Test duration in seconds', '10')
+    .option('-H, --header <header...>', 'Add request headers')
+    .option('--method <method>', 'HTTP method', 'GET')
+    .action(async (url, options) => {
+      try {
+        requireProLicense('Load testing');
+        
+        const rps = parseInt(options.rps);
+        const duration = parseInt(options.duration);
+        const method = options.method.toUpperCase();
+        
+        formatInfo(`Starting load test: ${rps} req/s for ${duration}s`);
+        formatInfo(`Target: ${method} ${url}`);
+        console.log('');
+        
+        const headers = {};
+        if (options.header) {
+          for (const header of options.header) {
+            const [key, ...valueParts] = header.split(':');
+            headers[key.trim()] = valueParts.join(':').trim();
+          }
+        }
+        
+        const results = await runLoadTest(url, {
+          rps,
+          duration,
+          method,
+          headers,
+        });
+        
+        displayLoadTestResults(results);
+        
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+}
+
+async function runLoadTest(url, options) {
+  const { rps, duration, method, headers } = options;
+  const interval = 1000 / rps; // ms between requests
+  const totalRequests = rps * duration;
+  
+  const results = {
+    total: totalRequests,
+    success: 0,
+    failed: 0,
+    responseTimes: [],
+    errors: {},
+    statusCodes: {},
+  };
+  
+  const startTime = Date.now();
+  const promises = [];
+  
+  for (let i = 0; i < totalRequests; i++) {
+    const delay = i * interval;
+    
+    promises.push(
+      new Promise((resolve) => {
+        setTimeout(async () => {
+          const reqStart = Date.now();
+          
+          try {
+            const response = await request(url, { method, headers });
+            const reqTime = Date.now() - reqStart;
+            
+            await response.body.arrayBuffer(); // Consume body
+            
+            results.success++;
+            results.responseTimes.push(reqTime);
+            results.statusCodes[response.statusCode] = (results.statusCodes[response.statusCode] || 0) + 1;
+          } catch (err) {
+            results.failed++;
+            const errorType = err.code || err.message;
+            results.errors[errorType] = (results.errors[errorType] || 0) + 1;
+          }
+          
+          resolve();
+        }, delay);
+      })
+    );
+  }
+  
+  await Promise.all(promises);
+  
+  results.totalTime = Date.now() - startTime;
+  
+  // Calculate percentiles
+  if (results.responseTimes.length > 0) {
+    results.responseTimes.sort((a, b) => a - b);
+    results.p50 = percentile(results.responseTimes, 50);
+    results.p95 = percentile(results.responseTimes, 95);
+    results.p99 = percentile(results.responseTimes, 99);
+    results.min = results.responseTimes[0];
+    results.max = results.responseTimes[results.responseTimes.length - 1];
+    results.avg = results.responseTimes.reduce((a, b) => a + b, 0) / results.responseTimes.length;
+  }
+  
+  return results;
+}
+
+function percentile(arr, p) {
+  const index = Math.ceil((arr.length * p) / 100) - 1;
+  return arr[index];
+}
+
+function displayLoadTestResults(results) {
+  console.log('');
+  console.log(chalk.bold.cyan('Load Test Results:'));
+  console.log('');
+  
+  console.log(chalk.bold('Summary:'));
+  console.log(`  Total requests: ${results.total}`);
+  console.log(`  ${chalk.green('Successful:')} ${results.success}`);
+  if (results.failed > 0) {
+    console.log(`  ${chalk.red('Failed:')} ${results.failed}`);
+  }
+  console.log(`  Duration: ${(results.totalTime / 1000).toFixed(2)}s`);
+  console.log(`  Actual RPS: ${(results.total / (results.totalTime / 1000)).toFixed(2)}`);
+  console.log('');
+  
+  if (results.responseTimes.length > 0) {
+    console.log(chalk.bold('Response Times:'));
+    console.log(`  Min: ${results.min}ms`);
+    console.log(`  Max: ${results.max}ms`);
+    console.log(`  Avg: ${results.avg.toFixed(2)}ms`);
+    console.log(`  P50: ${results.p50}ms`);
+    console.log(`  P95: ${results.p95}ms`);
+    console.log(`  P99: ${results.p99}ms`);
+    console.log('');
+  }
+  
+  if (Object.keys(results.statusCodes).length > 0) {
+    console.log(chalk.bold('Status Codes:'));
+    for (const [code, count] of Object.entries(results.statusCodes)) {
+      const color = code.startsWith('2') ? 'green' : code.startsWith('4') || code.startsWith('5') ? 'red' : 'white';
+      console.log(`  ${chalk[color](code)}: ${count}`);
+    }
+    console.log('');
+  }
+  
+  if (Object.keys(results.errors).length > 0) {
+    console.log(chalk.bold.red('Errors:'));
+    for (const [error, count] of Object.entries(results.errors)) {
+      console.log(`  ${error}: ${count}`);
+    }
+    console.log('');
+  }
+}

package/src/commands/mock.js

@@ -0,0 +1,178 @@
+import { createServer } from 'http';
+import { readFileSync, existsSync } from 'fs';
+import { parse as parseYaml } from 'yaml';
+import { formatError, formatInfo, formatSuccess } from '../lib/output.js';
+import { requireProLicense } from '../lib/license.js';
+import chalk from 'chalk';
+
+export function registerMockCommands(program) {
+  const mock = program
+    .command('mock')
+    .description('Mock server commands');
+
+  mock
+    .command('start [spec]')
+    .description('Start mock server from OpenAPI spec (Pro)')
+    .option('-p, --port <port>', 'Server port', '3000')
+    .option('-d, --delay <ms>', 'Response delay in milliseconds', '0')
+    .option('--cors', 'Enable CORS headers')
+    .action((spec, options) => {
+      try {
+        requireProLicense('Mock server');
+        
+        if (!spec) {
+          formatError(new Error('OpenAPI spec file required'));
+          process.exit(1);
+        }
+        
+        if (!existsSync(spec)) {
+          formatError(new Error(`Spec file not found: ${spec}`));
+          process.exit(1);
+        }
+        
+        const content = readFileSync(spec, 'utf8');
+        let openApiSpec;
+        
+        try {
+          if (spec.endsWith('.yaml') || spec.endsWith('.yml')) {
+            openApiSpec = parseYaml(content);
+          } else {
+            openApiSpec = JSON.parse(content);
+          }
+        } catch (err) {
+          formatError(new Error(`Failed to parse spec: ${err.message}`));
+          process.exit(1);
+        }
+        
+        const port = parseInt(options.port);
+        const delay = parseInt(options.delay);
+        
+        const server = createMockServer(openApiSpec, {
+          delay,
+          cors: options.cors,
+        });
+        
+        server.listen(port, () => {
+          formatSuccess(`Mock server started on http://localhost:${port}`);
+          formatInfo(`Serving from: ${spec}`);
+          if (delay > 0) {
+            formatInfo(`Response delay: ${delay}ms`);
+          }
+          console.log('');
+          console.log(chalk.gray('Press Ctrl+C to stop'));
+          console.log('');
+        });
+        
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+}
+
+function createMockServer(spec, options = {}) {
+  const { delay = 0, cors = false } = options;
+  const paths = spec.paths || {};
+  
+  return createServer((req, res) => {
+    const start = Date.now();
+    
+    // CORS headers
+    if (cors) {
+      res.setHeader('Access-Control-Allow-Origin', '*');
+      res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, PATCH, OPTIONS');
+      res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization');
+      
+      if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+      }
+    }
+    
+    // Find matching path
+    let matchedPath = null;
+    let matchedOperation = null;
+    
+    for (const [path, operations] of Object.entries(paths)) {
+      // Simple path matching (no parameters for now)
+      const pattern = path.replace(/\{[^}]+\}/g, '[^/]+');
+      const regex = new RegExp(`^${pattern}$`);
+      
+      if (regex.test(req.url)) {
+        const method = req.method.toLowerCase();
+        if (operations[method]) {
+          matchedPath = path;
+          matchedOperation = operations[method];
+          break;
+        }
+      }
+    }
+    
+    // Apply delay
+    setTimeout(() => {
+      if (!matchedOperation) {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+        logRequest(req, 404, Date.now() - start);
+        return;
+      }
+      
+      // Get first success response
+      const responses = matchedOperation.responses || {};
+      const successCode = Object.keys(responses).find(code => code.startsWith('2')) || '200';
+      const response = responses[successCode];
+      
+      // Generate mock response
+      const mockData = generateMockFromSchema(response.content?.['application/json']?.schema || {});
+      
+      res.writeHead(parseInt(successCode), { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(mockData, null, 2));
+      
+      logRequest(req, successCode, Date.now() - start);
+    }, delay);
+  });
+}
+
+function generateMockFromSchema(schema) {
+  if (!schema) return {};
+  
+  if (schema.type === 'object') {
+    const obj = {};
+    for (const [key, propSchema] of Object.entries(schema.properties || {})) {
+      obj[key] = generateMockFromSchema(propSchema);
+    }
+    return obj;
+  }
+  
+  if (schema.type === 'array') {
+    return [generateMockFromSchema(schema.items || {})];
+  }
+  
+  if (schema.example !== undefined) {
+    return schema.example;
+  }
+  
+  // Default values by type
+  const defaults = {
+    string: 'example',
+    number: 42,
+    integer: 42,
+    boolean: true,
+    null: null,
+  };
+  
+  return defaults[schema.type] || null;
+}
+
+function logRequest(req, status, duration) {
+  const statusColor = status >= 200 && status < 300 ? 'green' :
+                     status >= 400 ? 'yellow' : 'white';
+  
+  console.log(
+    chalk[statusColor](status.toString().padEnd(4)) +
+    chalk.bold(req.method.padEnd(7)) +
+    chalk.gray(`${duration}ms`.padEnd(8)) +
+    req.url
+  );
+}

package/src/commands/request.js

@@ -0,0 +1,91 @@
+import { HttpClient } from '../lib/http-client.js';
+import { formatResponse, formatError } from '../lib/output.js';
+import { saveToHistory } from '../lib/history.js';
+
+export function registerRequestCommands(program) {
+  const methods = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+
+  for (const method of methods) {
+    program
+      .command(`${method} <url>`)
+      .description(`Send a ${method.toUpperCase()} request`)
+      .option('-H, --header <header...>', 'Add request headers (key:value or "key: value")')
+      .option('-j, --json <data>', 'Send JSON data (automatically sets Content-Type)')
+      .option('-d, --data <data>', 'Send raw request body')
+      .option('-v, --verbose', 'Show response headers')
+      .option('-q, --quiet', 'Only output response body')
+      .option('--no-follow', 'Do not follow redirects')
+      .option('--no-verify', 'Skip SSL certificate verification')
+      .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
+      .action(async (url, options) => {
+        try {
+          const client = new HttpClient({
+            followRedirects: options.follow,
+            verifySsl: options.verify,
+            timeout: parseInt(options.timeout),
+          });
+
+          const requestOptions = {
+            headers: parseHeaders(options.header || []),
+          };
+
+          // Handle JSON data
+          if (options.json) {
+            try {
+              requestOptions.json = JSON.parse(options.json);
+            } catch (err) {
+              formatError(new Error(`Invalid JSON: ${err.message}`));
+              process.exit(1);
+            }
+          } else if (options.data) {
+            requestOptions.body = options.data;
+          }
+
+          const response = await client.request(method, url, requestOptions);
+
+          // Save to history
+          saveToHistory(
+            {
+              method: method.toUpperCase(),
+              url,
+              headers: requestOptions.headers,
+              body: requestOptions.json || requestOptions.body,
+            },
+            response
+          );
+
+          // Format and display response
+          formatResponse(response, {
+            verbose: options.verbose,
+            quiet: options.quiet,
+          });
+
+          // Exit with non-zero code for 4xx/5xx errors
+          if (response.status >= 400) {
+            process.exit(1);
+          }
+        } catch (err) {
+          formatError(err);
+          process.exit(1);
+        }
+      });
+  }
+}
+
+function parseHeaders(headerArray) {
+  const headers = {};
+  
+  for (const header of headerArray) {
+    // Support both "key:value" and "key: value" formats
+    const colonIndex = header.indexOf(':');
+    if (colonIndex === -1) {
+      throw new Error(`Invalid header format: ${header}. Expected "key:value" or "key: value"`);
+    }
+    
+    const key = header.slice(0, colonIndex).trim();
+    const value = header.slice(colonIndex + 1).trim();
+    headers[key] = value;
+  }
+  
+  return headers;
+}

package/src/commands/test.js

@@ -0,0 +1,55 @@
+import { existsSync, readFileSync } from 'fs';
+import { parse } from 'yaml';
+import { formatError } from '../lib/output.js';
+import { runCollection } from '../lib/collection-runner.js';
+import { formatTestResults } from '../lib/output.js';
+import { join } from 'path';
+
+export function registerTestCommand(program) {
+  program
+    .command('test [file]')
+    .description('Run tests from a collection file')
+    .option('-e, --env <name>', 'Environment to use')
+    .option('--base-url <url>', 'Override base URL')
+    .option('--json', 'Output results as JSON')
+    .action(async (file, options) => {
+      try {
+        const collectionPath = file || join('.mpx-api', 'collection.yaml');
+        
+        if (!existsSync(collectionPath)) {
+          formatError(new Error(`Collection not found: ${collectionPath}`));
+          process.exit(1);
+        }
+        
+        const content = readFileSync(collectionPath, 'utf8');
+        const collection = parse(content);
+        
+        // Load environment if specified
+        let env = {};
+        if (options.env) {
+          const envPath = join('.mpx-api', 'environments', `${options.env}.yaml`);
+          if (existsSync(envPath)) {
+            const envContent = readFileSync(envPath, 'utf8');
+            env = parse(envContent);
+            env = env.variables || {};
+          }
+        }
+        
+        const baseUrl = options.baseUrl || collection.baseUrl || '';
+        
+        const results = await runCollection(collection, { env, baseUrl });
+        
+        if (options.json) {
+          console.log(JSON.stringify(results, null, 2));
+          const allPassed = results.every(r => r.passed);
+          process.exit(allPassed ? 0 : 1);
+        } else {
+          const allPassed = formatTestResults(results);
+          process.exit(allPassed ? 0 : 1);
+        }
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+}

package/src/lib/assertion.js

@@ -0,0 +1,170 @@
+// Assertion engine for testing
+
+export function runAssertions(response, assertions) {
+  const results = [];
+  
+  for (const [path, expected] of Object.entries(assertions)) {
+    const result = {
+      path,
+      expected,
+      actual: undefined,
+      passed: false,
+      description: '',
+    };
+    
+    // Special case: status code
+    if (path === 'status') {
+      result.actual = response.status;
+      result.passed = response.status === expected;
+      result.description = `Status code is ${expected}`;
+      results.push(result);
+      continue;
+    }
+    
+    // Special case: responseTime
+    if (path === 'responseTime') {
+      result.actual = response.responseTime;
+      if (typeof expected === 'object') {
+        // Handle operators: { lt: 500, gt: 100 }
+        result.passed = evaluateOperators(response.responseTime, expected);
+        result.description = `Response time ${formatOperators(expected)}`;
+      } else {
+        result.passed = response.responseTime === expected;
+        result.description = `Response time is ${expected}ms`;
+      }
+      results.push(result);
+      continue;
+    }
+    
+    // Handle headers.* paths
+    if (path.startsWith('headers.')) {
+      const headerName = path.slice(8).toLowerCase();
+      const actualValue = response.headers[headerName];
+      result.actual = actualValue;
+      
+      if (typeof expected === 'string') {
+        result.passed = actualValue === expected || (actualValue && actualValue.includes(expected));
+        result.description = `Header ${headerName} contains "${expected}"`;
+      } else if (typeof expected === 'object') {
+        result.passed = evaluateOperators(actualValue, expected);
+        result.description = `Header ${headerName} ${formatOperators(expected)}`;
+      }
+      results.push(result);
+      continue;
+    }
+    
+    // Handle body.* paths
+    if (path.startsWith('body.')) {
+      const bodyPath = path.slice(5);
+      const actualValue = getNestedValue(response.body, bodyPath);
+      result.actual = actualValue;
+      
+      if (typeof expected === 'object' && !Array.isArray(expected)) {
+        // Handle operators
+        result.passed = evaluateOperators(actualValue, expected);
+        result.description = `${path} ${formatOperators(expected)}`;
+      } else {
+        result.passed = deepEqual(actualValue, expected);
+        result.description = `${path} equals ${JSON.stringify(expected)}`;
+      }
+      results.push(result);
+      continue;
+    }
+  }
+  
+  return results;
+}
+
+function getNestedValue(obj, path) {
+  const parts = path.split('.');
+  let current = obj;
+  
+  for (const part of parts) {
+    if (current === null || current === undefined) return undefined;
+    
+    // Handle array indexing
+    const arrayMatch = part.match(/^(.+?)\[(\d+)\]$/);
+    if (arrayMatch) {
+      const [, key, index] = arrayMatch;
+      current = current[key];
+      if (!Array.isArray(current)) return undefined;
+      current = current[parseInt(index)];
+    } else {
+      current = current[part];
+    }
+  }
+  
+  return current;
+}
+
+function evaluateOperators(actual, expected) {
+  for (const [op, value] of Object.entries(expected)) {
+    switch (op) {
+      case 'eq':
+        if (actual !== value) return false;
+        break;
+      case 'ne':
+        if (actual === value) return false;
+        break;
+      case 'gt':
+        if (!(actual > value)) return false;
+        break;
+      case 'gte':
+        if (!(actual >= value)) return false;
+        break;
+      case 'lt':
+        if (!(actual < value)) return false;
+        break;
+      case 'lte':
+        if (!(actual <= value)) return false;
+        break;
+      case 'contains':
+        if (!actual || !actual.includes(value)) return false;
+        break;
+      case 'exists':
+        if (value && actual === undefined) return false;
+        if (!value && actual !== undefined) return false;
+        break;
+      default:
+        return false;
+    }
+  }
+  return true;
+}
+
+function formatOperators(expected) {
+  const parts = [];
+  for (const [op, value] of Object.entries(expected)) {
+    switch (op) {
+      case 'eq': parts.push(`equals ${value}`); break;
+      case 'ne': parts.push(`does not equal ${value}`); break;
+      case 'gt': parts.push(`greater than ${value}`); break;
+      case 'gte': parts.push(`greater than or equal to ${value}`); break;
+      case 'lt': parts.push(`less than ${value}`); break;
+      case 'lte': parts.push(`less than or equal to ${value}`); break;
+      case 'contains': parts.push(`contains "${value}"`); break;
+      case 'exists': parts.push(value ? 'exists' : 'does not exist'); break;
+    }
+  }
+  return parts.join(' and ');
+}
+
+function deepEqual(a, b) {
+  if (a === b) return true;
+  if (a == null || b == null) return false;
+  if (typeof a !== typeof b) return false;
+  
+  if (Array.isArray(a)) {
+    if (!Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, i) => deepEqual(item, b[i]));
+  }
+  
+  if (typeof a === 'object') {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length) return false;
+    return keysA.every(key => deepEqual(a[key], b[key]));
+  }
+  
+  return false;
+}