mpx-api 1.0.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "mpx-api",
+  "version": "1.0.0",
+  "description": "Developer-first API testing, mocking, and documentation CLI",
+  "main": "src/index.js",
+  "bin": {
+    "mpx-api": "./bin/mpx-api.js"
+  },
+  "keywords": [
+    "api",
+    "testing",
+    "http",
+    "rest",
+    "mock",
+    "cli",
+    "postman",
+    "httpie",
+    "openapi",
+    "swagger"
+  ],
+  "author": "Mesaplex <support@mesaplex.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mesaplexdev/mpx-api.git"
+  },
+  "bugs": {
+    "url": "https://github.com/mesaplexdev/mpx-api/issues"
+  },
+  "homepage": "https://github.com/mesaplexdev/mpx-api#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "type": "module",
+  "scripts": {
+    "test": "node --test test/**/*.test.js",
+    "test:watch": "node --test --watch test/**/*.test.js",
+    "lint": "echo 'TODO: Add eslint'",
+    "prepublishOnly": "npm test"
+  },
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.0.0",
+    "yaml": "^2.3.4",
+    "undici": "^6.6.0",
+    "cli-highlight": "^2.1.11",
+    "tough-cookie": "^4.1.3",
+    "filenamify": "^6.0.0"
+  },
+  "devDependencies": {}
+}

package/src/commands/collection.js

@@ -0,0 +1,175 @@
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'fs';
+import { parse, stringify } from 'yaml';
+import { ensureLocalDir } from '../lib/config.js';
+import { formatSuccess, formatError, formatInfo } from '../lib/output.js';
+import { runCollection } from '../lib/collection-runner.js';
+import { formatTestResults } from '../lib/output.js';
+import { join } from 'path';
+
+export function registerCollectionCommands(program) {
+  const collection = program
+    .command('collection')
+    .description('Manage request collections');
+
+  collection
+    .command('init')
+    .description('Initialize a new collection in current directory')
+    .option('-n, --name <name>', 'Collection name', 'API Collection')
+    .action((options) => {
+      try {
+        ensureLocalDir();
+        
+        const collectionData = {
+          name: options.name,
+          baseUrl: '',
+          requests: [],
+        };
+        
+        const yamlPath = join('.mpx-api', 'collection.yaml');
+        writeFileSync(yamlPath, stringify(collectionData));
+        
+        formatSuccess(`Collection initialized at ${yamlPath}`);
+        formatInfo('Add requests with: mpx-api collection add <name> <method> <url>');
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+
+  collection
+    .command('add <name> <method> <url>')
+    .description('Add a request to the collection')
+    .option('-H, --header <header...>', 'Add request headers')
+    .option('-j, --json <data>', 'JSON body')
+    .option('-d, --data <data>', 'Request body')
+    .action((name, method, url, options) => {
+      try {
+        const yamlPath = join('.mpx-api', 'collection.yaml');
+        
+        if (!existsSync(yamlPath)) {
+          formatError(new Error('No collection found. Run "mpx-api collection init" first.'));
+          process.exit(1);
+        }
+        
+        const content = readFileSync(yamlPath, 'utf8');
+        const data = parse(content);
+        
+        const request = {
+          name,
+          method: method.toUpperCase(),
+          url,
+        };
+        
+        if (options.header && options.header.length > 0) {
+          request.headers = {};
+          for (const header of options.header) {
+            const [key, ...valueParts] = header.split(':');
+            request.headers[key.trim()] = valueParts.join(':').trim();
+          }
+        }
+        
+        if (options.json) {
+          try {
+            request.json = JSON.parse(options.json);
+          } catch (err) {
+            formatError(new Error(`Invalid JSON: ${err.message}`));
+            process.exit(1);
+          }
+        } else if (options.data) {
+          request.body = options.data;
+        }
+        
+        data.requests = data.requests || [];
+        data.requests.push(request);
+        
+        writeFileSync(yamlPath, stringify(data));
+        formatSuccess(`Added request "${name}" to collection`);
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+
+  collection
+    .command('run [file]')
+    .description('Run a collection')
+    .option('-e, --env <name>', 'Environment to use')
+    .option('--base-url <url>', 'Override base URL')
+    .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);
+          } else {
+            formatWarning(`Environment "${options.env}" not found, continuing without it`);
+          }
+        }
+        
+        const baseUrl = options.baseUrl || collection.baseUrl || '';
+        
+        const results = await runCollection(collection, { env, baseUrl });
+        
+        const allPassed = formatTestResults(results);
+        
+        process.exit(allPassed ? 0 : 1);
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+
+  collection
+    .command('list')
+    .description('List all requests in collection')
+    .action(() => {
+      try {
+        const yamlPath = join('.mpx-api', 'collection.yaml');
+        
+        if (!existsSync(yamlPath)) {
+          formatError(new Error('No collection found.'));
+          process.exit(1);
+        }
+        
+        const content = readFileSync(yamlPath, 'utf8');
+        const data = parse(content);
+        
+        console.log('');
+        console.log(`Collection: ${data.name || 'Unnamed'}`);
+        if (data.baseUrl) {
+          console.log(`Base URL: ${data.baseUrl}`);
+        }
+        console.log('');
+        console.log('Requests:');
+        
+        if (!data.requests || data.requests.length === 0) {
+          console.log('  (none)');
+        } else {
+          for (const req of data.requests) {
+            console.log(`  ${req.name}: ${req.method} ${req.url}`);
+          }
+        }
+        console.log('');
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+}
+
+function formatWarning(message) {
+  console.log(chalk.yellow('⚠'), message);
+}

package/src/commands/docs.js

@@ -0,0 +1,140 @@
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { parse } from 'yaml';
+import { formatError, formatSuccess } from '../lib/output.js';
+import { requireProLicense } from '../lib/license.js';
+
+export function registerDocsCommand(program) {
+  program
+    .command('docs <collection>')
+    .description('Generate API documentation from collection (Pro)')
+    .option('-o, --output <file>', 'Output file', 'API.md')
+    .option('--format <format>', 'Output format (markdown, html)', 'markdown')
+    .action((collection, options) => {
+      try {
+        requireProLicense('Documentation generation');
+        
+        if (!existsSync(collection)) {
+          formatError(new Error(`Collection not found: ${collection}`));
+          process.exit(1);
+        }
+        
+        const content = readFileSync(collection, 'utf8');
+        const data = parse(content);
+        
+        const markdown = generateMarkdownDocs(data);
+        
+        writeFileSync(options.output, markdown);
+        formatSuccess(`Documentation generated: ${options.output}`);
+        
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+}
+
+function generateMarkdownDocs(collection) {
+  const lines = [];
+  
+  // Header
+  lines.push(`# ${collection.name || 'API Documentation'}`);
+  lines.push('');
+  
+  if (collection.description) {
+    lines.push(collection.description);
+    lines.push('');
+  }
+  
+  if (collection.baseUrl) {
+    lines.push(`**Base URL:** \`${collection.baseUrl}\``);
+    lines.push('');
+  }
+  
+  lines.push('---');
+  lines.push('');
+  
+  // Table of Contents
+  lines.push('## Table of Contents');
+  lines.push('');
+  
+  for (const request of collection.requests || []) {
+    const anchor = request.name.toLowerCase().replace(/\s+/g, '-');
+    lines.push(`- [${request.name}](#${anchor})`);
+  }
+  
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+  
+  // Requests
+  for (const request of collection.requests || []) {
+    lines.push(`## ${request.name}`);
+    lines.push('');
+    
+    if (request.description) {
+      lines.push(request.description);
+      lines.push('');
+    }
+    
+    // Request details
+    lines.push('```');
+    lines.push(`${request.method} ${request.url}`);
+    lines.push('```');
+    lines.push('');
+    
+    // Headers
+    if (request.headers && Object.keys(request.headers).length > 0) {
+      lines.push('**Headers:**');
+      lines.push('');
+      lines.push('```');
+      for (const [key, value] of Object.entries(request.headers)) {
+        lines.push(`${key}: ${value}`);
+      }
+      lines.push('```');
+      lines.push('');
+    }
+    
+    // Body
+    if (request.json) {
+      lines.push('**Request Body:**');
+      lines.push('');
+      lines.push('```json');
+      lines.push(JSON.stringify(request.json, null, 2));
+      lines.push('```');
+      lines.push('');
+    } else if (request.body) {
+      lines.push('**Request Body:**');
+      lines.push('');
+      lines.push('```');
+      lines.push(request.body);
+      lines.push('```');
+      lines.push('');
+    }
+    
+    // Assertions
+    if (request.assert) {
+      lines.push('**Expected Response:**');
+      lines.push('');
+      
+      for (const [key, value] of Object.entries(request.assert)) {
+        if (key === 'status') {
+          lines.push(`- Status Code: ${value}`);
+        } else {
+          lines.push(`- ${key}: ${JSON.stringify(value)}`);
+        }
+      }
+      lines.push('');
+    }
+    
+    lines.push('---');
+    lines.push('');
+  }
+  
+  // Footer
+  lines.push('---');
+  lines.push('');
+  lines.push('*Generated with [mpx-api](https://mpx-api.dev)*');
+  lines.push('');
+  
+  return lines.join('\n');
+}

package/src/commands/env.js

@@ -0,0 +1,152 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from 'fs';
+import { parse, stringify } from 'yaml';
+import { join } from 'path';
+import { ensureLocalDir } from '../lib/config.js';
+import { formatSuccess, formatError, formatInfo } from '../lib/output.js';
+import chalk from 'chalk';
+
+export function registerEnvCommands(program) {
+  const env = program
+    .command('env')
+    .description('Manage environments');
+
+  env
+    .command('init')
+    .description('Initialize environments directory')
+    .action(() => {
+      try {
+        ensureLocalDir();
+        const envDir = join('.mpx-api', 'environments');
+        
+        if (!existsSync(envDir)) {
+          mkdirSync(envDir, { recursive: true });
+        }
+        
+        // Create default environments
+        const environments = ['dev', 'staging', 'production'];
+        
+        for (const envName of environments) {
+          const envPath = join(envDir, `${envName}.yaml`);
+          if (!existsSync(envPath)) {
+            const envData = {
+              name: envName,
+              variables: {},
+            };
+            writeFileSync(envPath, stringify(envData));
+          }
+        }
+        
+        formatSuccess('Environments initialized');
+        formatInfo(`Created: ${environments.join(', ')}`);
+        formatInfo('Set variables with: mpx-api env set <env> <key>=<value>');
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+
+  env
+    .command('set <environment> <variable>')
+    .description('Set an environment variable (KEY=value)')
+    .action((environment, variable) => {
+      try {
+        ensureLocalDir();
+        const envDir = join('.mpx-api', 'environments');
+        
+        if (!existsSync(envDir)) {
+          formatError(new Error('Environments not initialized. Run "mpx-api env init" first.'));
+          process.exit(1);
+        }
+        
+        const envPath = join(envDir, `${environment}.yaml`);
+        
+        // Parse variable
+        const [key, ...valueParts] = variable.split('=');
+        const value = valueParts.join('=');
+        
+        if (!key || !value) {
+          formatError(new Error('Invalid format. Use: KEY=value'));
+          process.exit(1);
+        }
+        
+        let envData = { name: environment, variables: {} };
+        
+        if (existsSync(envPath)) {
+          const content = readFileSync(envPath, 'utf8');
+          envData = parse(content) || envData;
+        }
+        
+        envData.variables = envData.variables || {};
+        envData.variables[key] = value;
+        
+        writeFileSync(envPath, stringify(envData));
+        formatSuccess(`Set ${key}=${value} in ${environment} environment`);
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+
+  env
+    .command('list [environment]')
+    .description('List all environments or variables in an environment')
+    .action((environment) => {
+      try {
+        const envDir = join('.mpx-api', 'environments');
+        
+        if (!existsSync(envDir)) {
+          formatError(new Error('Environments not initialized.'));
+          process.exit(1);
+        }
+        
+        if (environment) {
+          // List variables in specific environment
+          const envPath = join(envDir, `${environment}.yaml`);
+          
+          if (!existsSync(envPath)) {
+            formatError(new Error(`Environment "${environment}" not found.`));
+            process.exit(1);
+          }
+          
+          const content = readFileSync(envPath, 'utf8');
+          const data = parse(content);
+          
+          console.log('');
+          console.log(chalk.bold(`Environment: ${environment}`));
+          console.log('');
+          
+          if (!data.variables || Object.keys(data.variables).length === 0) {
+            console.log('  (no variables)');
+          } else {
+            for (const [key, value] of Object.entries(data.variables)) {
+              console.log(`  ${chalk.cyan(key)}: ${value}`);
+            }
+          }
+          console.log('');
+        } else {
+          // List all environments
+          const files = readdirSync(envDir).filter(f => f.endsWith('.yaml'));
+          
+          console.log('');
+          console.log(chalk.bold('Environments:'));
+          console.log('');
+          
+          if (files.length === 0) {
+            console.log('  (none)');
+          } else {
+            for (const file of files) {
+              const envName = file.replace('.yaml', '');
+              const content = readFileSync(join(envDir, file), 'utf8');
+              const data = parse(content);
+              const varCount = Object.keys(data.variables || {}).length;
+              console.log(`  ${chalk.cyan(envName)} (${varCount} variable${varCount !== 1 ? 's' : ''})`);
+            }
+          }
+          console.log('');
+        }
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/history.js

@@ -0,0 +1,46 @@
+import chalk from 'chalk';
+import { loadHistory } from '../lib/history.js';
+import { formatError } from '../lib/output.js';
+
+export function registerHistoryCommand(program) {
+  program
+    .command('history')
+    .description('Show request history')
+    .option('-n, --limit <number>', 'Number of entries to show', '20')
+    .action((options) => {
+      try {
+        const limit = parseInt(options.limit);
+        const history = loadHistory(limit);
+        
+        if (history.length === 0) {
+          console.log('');
+          console.log(chalk.gray('No history found.'));
+          console.log('');
+          return;
+        }
+        
+        console.log('');
+        console.log(chalk.bold('Request History:'));
+        console.log('');
+        
+        for (const entry of history) {
+          const timestamp = new Date(entry.timestamp).toLocaleString();
+          const statusColor = entry.status >= 200 && entry.status < 300 ? 'green' :
+                             entry.status >= 400 ? 'yellow' : 'white';
+          
+          console.log(
+            chalk.gray(timestamp) + ' ' +
+            chalk.bold(entry.method.padEnd(6)) +
+            chalk[statusColor](entry.status.toString().padEnd(4)) +
+            chalk.gray(`${entry.responseTime}ms`.padEnd(8)) +
+            entry.url
+          );
+        }
+        
+        console.log('');
+      } catch (err) {
+        formatError(err);
+        process.exit(1);
+      }
+    });
+}