paymongo-cli 1.4.7 → 1.4.8

package/dist/commands/config/actions.js

@@ -0,0 +1,233 @@
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import { CommandError } from '../../utils/errors.js';
+import { checkConfigConflicts, createConfigContext, handleCommandFailure, loadRequiredConfig, setConfigValue, validateImportedConfig, validateImportedConfigWithSchema, } from './helpers.js';
+export async function showAction(options) {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        spinner.start('Loading configuration...');
+        const config = await configManager.load();
+        if (!config) {
+            spinner.fail('No configuration found');
+            console.log(chalk.yellow('No PayMongo configuration found.'));
+            console.log(chalk.gray("Run 'paymongo init' to set up your project."));
+            return;
+        }
+        spinner.succeed('Configuration loaded');
+        if (options.json) {
+            console.log(JSON.stringify(config, null, 2));
+            return;
+        }
+        console.log('\n' + chalk.bold('Configuration (.paymongo)'));
+        console.log('');
+        console.log(chalk.bold('Project:'), config.projectName);
+        console.log(chalk.bold('Environment:'), config.environment);
+        console.log(chalk.bold('Version:'), config.version);
+        console.log('');
+        console.log(chalk.bold('Webhook URL:'), config.webhooks.url || 'Not set');
+        console.log(chalk.bold('Webhook Events:'), config.webhooks.events.join(', ') || 'None');
+        console.log('');
+        console.log(chalk.bold('Dev Port:'), config.dev.port);
+        console.log(chalk.bold('Auto Register Webhook:'), config.dev.autoRegisterWebhook ? 'Yes' : 'No');
+        console.log(chalk.bold('Verify Webhook Signatures:'), config.dev.verifyWebhookSignatures ? 'Yes' : 'No');
+        console.log('');
+        if (config.rateLimiting) {
+            console.log(chalk.bold('Rate Limiting:'));
+            console.log(chalk.bold('  Enabled:'), config.rateLimiting.enabled ? chalk.green('Yes') : chalk.red('No'));
+            if (config.rateLimiting.enabled) {
+                console.log(`  Max Requests: ${config.rateLimiting.maxRequests} per ${(config.rateLimiting.windowMs || 60000) / 1000}s`);
+                console.log(`  Live Multiplier: ${config.rateLimiting.environmentMultiplier || 0.5}x`);
+                if (config.rateLimiting.endpoints &&
+                    Object.keys(config.rateLimiting.endpoints).length > 0) {
+                    console.log(`  Endpoint Overrides: ${Object.keys(config.rateLimiting.endpoints).length} configured`);
+                }
+            }
+            console.log('');
+        }
+        console.log(chalk.bold('API Keys:'));
+        const env = config.environment;
+        const apiKeys = config.apiKeys[env];
+        if (apiKeys) {
+            if (apiKeys.public) {
+                console.log(`  Public (${env}):`, apiKeys.public.replace(/(.{10}).*/, '$1***'));
+            }
+            if (apiKeys.secret) {
+                console.log(`  Secret (${env}):`, apiKeys.secret.replace(/(.{10}).*/, '$1***'));
+            }
+        }
+        else {
+            console.log(`  No API keys configured for ${env} environment`);
+            console.log(chalk.gray("  Run 'paymongo login' to set API keys"));
+        }
+        console.log('');
+        console.log(chalk.gray("Use 'paymongo config set <key> <value>' to modify"));
+        console.log(chalk.gray("Use 'paymongo config reset' to reset to defaults"));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        if (err.message.includes('No configuration') || err.message.includes('not found')) {
+            console.error(chalk.red('❌ No configuration found:'), err.message);
+            console.log('');
+            console.log(chalk.yellow('💡 Solutions:'));
+            console.log(chalk.gray('• Run "paymongo init" to create a new configuration'));
+            console.log(chalk.gray("• Check if you're in the correct project directory"));
+        }
+        else if (err.message.includes('Failed to load') || err.message.includes('parse')) {
+            console.error(chalk.red('❌ Configuration file corrupted:'), err.message);
+            console.log('');
+            console.log(chalk.yellow('💡 Recovery options:'));
+            console.log(chalk.gray('• Run "paymongo config reset" to create a fresh configuration'));
+            console.log(chalk.gray('• Check the .paymongo file for syntax errors'));
+            console.log(chalk.gray('• Run "paymongo init" to recreate the configuration'));
+        }
+        else {
+            console.error(chalk.red('❌ Failed to load configuration:'), err.message);
+        }
+        throw new CommandError();
+    }
+}
+export async function setAction(key, value) {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        spinner.start('Updating configuration...');
+        setConfigValue(config, key, value);
+        await configManager.save(config);
+        spinner.succeed('Configuration updated');
+        console.log(chalk.green(`✓ Set ${key} = ${value}`));
+    }
+    catch (error) {
+        spinner.stop();
+        handleCommandFailure('❌ Failed to update configuration:', error);
+    }
+}
+export async function backupAction(options) {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager, 'Loading current configuration...');
+        if (!config) {
+            return;
+        }
+        const backupDir = options.directory ? path.resolve(options.directory) : process.cwd();
+        if (options.directory && !fs.existsSync(backupDir)) {
+            fs.mkdirSync(backupDir, { recursive: true });
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, -5);
+        const prefix = options.name || 'paymongo-config';
+        const backupPath = path.join(backupDir, `${prefix}-${timestamp}.json`);
+        spinner.start('Creating backup...');
+        fs.writeFileSync(backupPath, JSON.stringify(config, null, 2), 'utf-8');
+        spinner.succeed('Backup created');
+        console.log(chalk.green(`✓ Configuration backup created: ${backupPath}`));
+        console.log(chalk.gray('To restore this backup, use:'));
+        console.log(chalk.gray(`  paymongo config import ${backupPath} --force`));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        if (err.message.includes('Failed to load') || err.message.includes('parse')) {
+            console.error(chalk.red('❌ Failed to load configuration for backup:'), err.message);
+            console.log('');
+            console.log(chalk.yellow('💡 Check:'));
+            console.log(chalk.gray('• Run "paymongo config show" to verify configuration'));
+            console.log(chalk.gray('• Run "paymongo config reset" to recreate configuration'));
+        }
+        else if (err.message.includes('permission') || err.message.includes('EACCES')) {
+            console.error(chalk.red('❌ Failed to create backup:'), err.message);
+            console.log('');
+            console.log(chalk.yellow('💡 Check:'));
+            console.log(chalk.gray('• File permissions in the backup directory'));
+            console.log(chalk.gray('• Available disk space'));
+            console.log(chalk.gray('• Try running the command with administrator/sudo privileges'));
+        }
+        else {
+            console.error(chalk.red('❌ Failed to create backup:'), err.message);
+        }
+        throw new CommandError();
+    }
+}
+export async function resetAction() {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        spinner.start('Resetting configuration...');
+        await configManager.save(configManager.getDefaultConfig());
+        spinner.succeed('Configuration reset');
+        console.log(chalk.green('✓ Configuration reset to defaults'));
+        console.log(chalk.gray('Note: You will need to reconfigure API keys and other settings'));
+    }
+    catch (error) {
+        spinner.stop();
+        handleCommandFailure('❌ Failed to reset configuration:', error);
+    }
+}
+export async function importAction(filePath, options) {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        spinner.start('Reading import file...');
+        if (!fs.existsSync(filePath)) {
+            spinner.fail('File not found');
+            console.error(chalk.red(`❌ Import file not found: ${filePath}`));
+            throw new CommandError();
+        }
+        let importedConfig;
+        try {
+            importedConfig = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        }
+        catch {
+            spinner.fail('Invalid JSON');
+            console.error(chalk.red('❌ Invalid JSON in import file'));
+            throw new CommandError();
+        }
+        spinner.succeed('File read');
+        spinner.start('Validating configuration...');
+        validateImportedConfig(importedConfig);
+        const validationErrors = validateImportedConfigWithSchema(importedConfig);
+        if (validationErrors.length > 0) {
+            spinner.fail('Invalid configuration');
+            console.error(chalk.red('❌ Configuration validation failed:'));
+            validationErrors.forEach((err) => console.error(chalk.gray(`  • ${err}`)));
+            throw new CommandError();
+        }
+        spinner.succeed('Configuration validated');
+        const existingConfig = await configManager.load();
+        if (existingConfig && !options.force) {
+            spinner.start('Checking for conflicts...');
+            const conflicts = checkConfigConflicts(existingConfig, importedConfig);
+            if (conflicts.length > 0) {
+                spinner.stop();
+                console.log(chalk.yellow('⚠️  Configuration conflicts detected:'));
+                conflicts.forEach((conflict) => console.log(chalk.gray(`  • ${conflict}`)));
+                console.log('');
+                console.log(chalk.bold('Use --force to overwrite existing configuration'));
+                throw new CommandError();
+            }
+            spinner.succeed('No conflicts found');
+        }
+        if (existingConfig) {
+            spinner.start('Creating backup...');
+            const backupPath = `.paymongo.backup.${Date.now()}.json`;
+            fs.writeFileSync(backupPath, JSON.stringify(configManager.mergeConfig(existingConfig, {}), null, 2));
+            spinner.succeed(`Backup created: ${backupPath}`);
+        }
+        spinner.start('Importing configuration...');
+        if (!importedConfig.apiKeys) {
+            importedConfig.apiKeys = {};
+        }
+        if (!importedConfig.webhookSecrets) {
+            importedConfig.webhookSecrets = {};
+        }
+        await configManager.save(importedConfig);
+        spinner.succeed('Configuration imported');
+        console.log(chalk.green('✓ Configuration imported successfully'));
+        console.log(chalk.gray(`Imported from: ${filePath}`));
+    }
+    catch (error) {
+        spinner.stop();
+        handleCommandFailure('❌ Failed to import configuration:', error);
+    }
+}

package/dist/commands/config/helpers.js

@@ -0,0 +1,153 @@
+import chalk from 'chalk';
+import { validateConfig as zodValidateConfig } from '../../types/schemas.js';
+import ConfigManager from '../../services/config/manager.js';
+import Spinner from '../../utils/spinner.js';
+import { CommandError } from '../../utils/errors.js';
+export const CONFIG_KEY_MAPPINGS = {
+    'project.name': 'projectName',
+    'webhook.url': 'webhooks.url',
+    'webhook.events': 'webhooks.events',
+    'dev.port': 'dev.port',
+    'dev.autoRegister': 'dev.autoRegisterWebhook',
+    'dev.verifySignatures': 'dev.verifyWebhookSignatures',
+    'rateLimit.enabled': 'rateLimiting.enabled',
+    'rateLimit.maxRequests': 'rateLimiting.maxRequests',
+    'rateLimit.windowMs': 'rateLimiting.windowMs',
+};
+export function createConfigContext() {
+    return {
+        spinner: new Spinner(),
+        configManager: new ConfigManager(),
+    };
+}
+export function showNoConfigMessage(message = "Run 'paymongo init' to set up your project first.") {
+    console.log(chalk.yellow('No PayMongo configuration found.'));
+    console.log(chalk.gray(message));
+}
+export async function loadRequiredConfig(spinner, configManager, loadingText = 'Loading configuration...') {
+    spinner.start(loadingText);
+    const config = await configManager.load();
+    if (!config) {
+        spinner.fail('No configuration found');
+        showNoConfigMessage();
+        return null;
+    }
+    spinner.succeed('Configuration loaded');
+    return config;
+}
+export function handleCommandFailure(prefix, error) {
+    const err = error;
+    console.error(chalk.red(prefix), err.message);
+    throw new CommandError();
+}
+export function validateImportedConfig(config) {
+    if (typeof config !== 'object' || config === null) {
+        throw new Error('Configuration must be an object');
+    }
+    const cfg = config;
+    const requiredFields = ['version', 'projectName', 'environment', 'apiKeys', 'webhooks', 'dev'];
+    for (const field of requiredFields) {
+        if (!(field in cfg)) {
+            throw new Error(`Missing required field: ${field}`);
+        }
+    }
+    if (typeof cfg.version !== 'string') {
+        throw new Error('Version must be a string');
+    }
+    if (typeof cfg.projectName !== 'string' || cfg.projectName.trim() === '') {
+        throw new Error('Project name must be a non-empty string');
+    }
+    if (cfg.environment !== 'test' && cfg.environment !== 'live') {
+        throw new Error('Environment must be either "test" or "live"');
+    }
+    if (typeof cfg.apiKeys !== 'object' || cfg.apiKeys === null) {
+        throw new Error('API keys must be an object');
+    }
+    if (typeof cfg.webhooks !== 'object' || cfg.webhooks === null) {
+        throw new Error('Webhooks must be an object');
+    }
+    const webhooks = cfg.webhooks;
+    if (!Array.isArray(webhooks.events)) {
+        throw new Error('Webhook events must be an array');
+    }
+    if (typeof cfg.dev !== 'object' || cfg.dev === null) {
+        throw new Error('Dev config must be an object');
+    }
+    const dev = cfg.dev;
+    if (typeof dev.port !== 'number' || dev.port < 1 || dev.port > 65535) {
+        throw new Error('Dev port must be a valid port number (1-65535)');
+    }
+}
+export function validateImportedConfigWithSchema(config) {
+    const validation = zodValidateConfig(config);
+    return validation.success ? [] : (validation.errors ?? []);
+}
+export function checkConfigConflicts(existing, imported) {
+    const conflicts = [];
+    if (existing.apiKeys && imported.apiKeys) {
+        if (existing.apiKeys.test?.public !== imported.apiKeys.test?.public) {
+            conflicts.push('Test environment public API key differs');
+        }
+        if (existing.apiKeys.test?.secret !== imported.apiKeys.test?.secret) {
+            conflicts.push('Test environment secret API key differs');
+        }
+        if (existing.apiKeys.live?.public !== imported.apiKeys.live?.public) {
+            conflicts.push('Live environment public API key differs');
+        }
+        if (existing.apiKeys.live?.secret !== imported.apiKeys.live?.secret) {
+            conflicts.push('Live environment secret API key differs');
+        }
+    }
+    if (existing.webhooks?.url !== imported.webhooks?.url) {
+        conflicts.push('Webhook URL differs');
+    }
+    if (existing.environment !== imported.environment) {
+        conflicts.push('Environment setting differs');
+    }
+    if (existing.projectName !== imported.projectName) {
+        conflicts.push('Project name differs');
+    }
+    return conflicts;
+}
+export function setConfigValue(config, key, value) {
+    const mappedKey = CONFIG_KEY_MAPPINGS[key] || key;
+    const keys = mappedKey.split('.');
+    let current = config;
+    for (let i = 0; i < keys.length - 1; i++) {
+        const segment = keys[i];
+        if (segment && !current[segment]) {
+            current[segment] = {};
+        }
+        if (segment) {
+            current = current[segment];
+        }
+    }
+    const finalKey = keys[keys.length - 1];
+    if (!finalKey) {
+        throw new Error('Invalid key path');
+    }
+    current[finalKey] = coerceConfigValue(value);
+}
+export function coerceConfigValue(value) {
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    if (!isNaN(Number(value))) {
+        return Number(value);
+    }
+    return value;
+}
+export function ensureRateLimitingConfig(config) {
+    if (!config.rateLimiting) {
+        config.rateLimiting = {
+            enabled: true,
+            maxRequests: 100,
+            windowMs: 60000,
+            environmentMultiplier: 0.5,
+        };
+    }
+    return config.rateLimiting;
+}

package/dist/commands/config/rate-limit.js

@@ -0,0 +1,138 @@
+import chalk from 'chalk';
+import { CommandError } from '../../utils/errors.js';
+import { createConfigContext, ensureRateLimitingConfig, loadRequiredConfig } from './helpers.js';
+function parsePositiveInt(value, message) {
+    const parsed = parseInt(value, 10);
+    if (isNaN(parsed) || parsed < 1) {
+        console.error(chalk.red(message));
+        throw new CommandError();
+    }
+    return parsed;
+}
+export async function rateLimitEnableAction() {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        ensureRateLimitingConfig(config).enabled = true;
+        spinner.start('Enabling rate limiting...');
+        await configManager.save(config);
+        spinner.succeed('Rate limiting enabled');
+        console.log(chalk.green('✓ Rate limiting enabled'));
+        console.log(chalk.gray('Default limits: 100 requests/minute (live: 50)'));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to enable rate limiting:'), err.message);
+        throw new CommandError();
+    }
+}
+export async function rateLimitDisableAction() {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        if (config.rateLimiting) {
+            config.rateLimiting.enabled = false;
+        }
+        spinner.start('Disabling rate limiting...');
+        await configManager.save(config);
+        spinner.succeed('Rate limiting disabled');
+        console.log(chalk.green('✓ Rate limiting disabled'));
+        console.log(chalk.gray('API calls will no longer be rate limited'));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to disable rate limiting:'), err.message);
+        throw new CommandError();
+    }
+}
+export async function rateLimitSetMaxRequestsAction(requestsStr) {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const requests = parsePositiveInt(requestsStr, '❌ Invalid number of requests. Must be a positive integer.');
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        ensureRateLimitingConfig(config).maxRequests = requests;
+        spinner.start('Updating rate limit...');
+        await configManager.save(config);
+        spinner.succeed('Rate limit updated');
+        console.log(chalk.green(`✓ Maximum requests set to ${requests} per minute`));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to update rate limit:'), err.message);
+        throw new CommandError();
+    }
+}
+export async function rateLimitSetWindowAction(secondsStr) {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const seconds = parsePositiveInt(secondsStr, '❌ Invalid time window. Must be a positive integer (seconds).');
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        ensureRateLimitingConfig(config).windowMs = seconds * 1000;
+        spinner.start('Updating rate limit window...');
+        await configManager.save(config);
+        spinner.succeed('Rate limit window updated');
+        console.log(chalk.green(`✓ Rate limit window set to ${seconds} seconds`));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to update rate limit window:'), err.message);
+        throw new CommandError();
+    }
+}
+export async function rateLimitStatusAction() {
+    const { spinner, configManager } = createConfigContext();
+    try {
+        const config = await loadRequiredConfig(spinner, configManager);
+        if (!config) {
+            return;
+        }
+        console.log('\n' + chalk.bold('Rate Limiting Status'));
+        console.log('');
+        if (!config.rateLimiting || !config.rateLimiting.enabled) {
+            console.log(chalk.yellow('Status: Disabled'));
+            console.log(chalk.gray('Rate limiting is not currently active'));
+            console.log('');
+            console.log(chalk.gray("Run 'paymongo config rate-limit enable' to enable"));
+            return;
+        }
+        console.log(chalk.green('Status: Enabled'));
+        console.log('');
+        console.log(chalk.bold('Global Settings:'));
+        console.log(`  Max Requests: ${config.rateLimiting.maxRequests} per ${(config.rateLimiting.windowMs || 60000) / 1000}s`);
+        console.log(`  Live Environment Multiplier: ${config.rateLimiting.environmentMultiplier || 0.5}x`);
+        if (config.rateLimiting.endpoints && Object.keys(config.rateLimiting.endpoints).length > 0) {
+            console.log('');
+            console.log(chalk.bold('Endpoint Overrides:'));
+            Object.entries(config.rateLimiting.endpoints).forEach(([endpoint, limits]) => {
+                console.log(`  ${endpoint}: ${limits.maxRequests} per ${limits.windowMs / 1000}s`);
+            });
+        }
+        console.log('');
+        console.log(chalk.gray('Commands:'));
+        console.log(chalk.gray("• 'paymongo config rate-limit disable' - Disable rate limiting"));
+        console.log(chalk.gray("• 'paymongo config rate-limit set-max-requests <n>' - Set max requests"));
+        console.log(chalk.gray("• 'paymongo config rate-limit set-window <seconds>' - Set time window"));
+    }
+    catch (error) {
+        spinner.stop();
+        const err = error;
+        console.error(chalk.red('❌ Failed to check rate limiting status:'), err.message);
+        throw new CommandError();
+    }
+}