paymongo-cli 1.4.3 → 1.4.6

package/dist/services/api/undici-client.js

@@ -1,288 +0,0 @@
-import { request } from 'undici';
-import { NetworkError, ApiKeyError, PayMongoError, withRetry } from '../../utils/errors.js';
-import Cache from '../../utils/cache.js';
-import RateLimiter from './rate-limiter.js';
-const REQUEST_TIMEOUT = 30000;
-export class ApiClient {
-    config;
-    baseUrl;
-    defaultHeaders;
-    timeout;
-    cache;
-    rateLimiter;
-    constructor(options) {
-        this.config = options.config;
-        this.baseUrl = 'https://api.paymongo.com';
-        this.timeout = options.timeout || REQUEST_TIMEOUT;
-        this.defaultHeaders = {
-            'Content-Type': 'application/json',
-            'User-Agent': 'paymongo-cli/1.0.0',
-        };
-        this.cache = new Cache({ ttl: 2 * 60 * 1000 });
-        const rateLimitEnabled = options.enableRateLimiting !== false && this.config.rateLimiting?.enabled !== false;
-        if (rateLimitEnabled) {
-            const rateLimitConfig = options.rateLimitConfig || this.getDefaultRateLimitConfig();
-            if (this.config.rateLimiting) {
-                rateLimitConfig.default.maxRequests = this.config.rateLimiting.maxRequests;
-                rateLimitConfig.default.windowMs = this.config.rateLimiting.windowMs;
-                if (this.config.rateLimiting.environmentMultiplier !== undefined) {
-                    rateLimitConfig.default.environmentMultiplier =
-                        this.config.rateLimiting.environmentMultiplier;
-                }
-                if (this.config.rateLimiting.endpoints) {
-                    rateLimitConfig.endpoints = {
-                        ...rateLimitConfig.endpoints,
-                        ...this.config.rateLimiting.endpoints,
-                    };
-                }
-            }
-            this.rateLimiter = new RateLimiter(this.config, rateLimitConfig);
-        }
-    }
-    getDefaultRateLimitConfig() {
-        return {
-            default: {
-                maxRequests: 100,
-                windowMs: 60 * 1000,
-                environmentMultiplier: 0.5,
-            },
-            endpoints: {
-                '/webhooks': {
-                    maxRequests: 30,
-                    windowMs: 60 * 1000,
-                },
-                '/payments': {
-                    maxRequests: 60,
-                    windowMs: 60 * 1000,
-                },
-                '/payment_intents': {
-                    maxRequests: 60,
-                    windowMs: 60 * 1000,
-                },
-                '/refunds': {
-                    maxRequests: 20,
-                    windowMs: 60 * 1000,
-                },
-            },
-            environments: {
-                test: {},
-                live: {},
-            },
-        };
-    }
-    async makeRequest(method, path, options = {}) {
-        const url = new URL(path, this.baseUrl);
-        if (options.params) {
-            Object.entries(options.params).forEach(([key, value]) => {
-                url.searchParams.append(key, value.toString());
-            });
-        }
-        if (this.rateLimiter) {
-            const endpoint = path.replace('/v1', '') || '/unknown';
-            const limitCheck = this.rateLimiter.checkLimit(endpoint);
-            if (!limitCheck.allowed) {
-                const backoffMs = limitCheck.backoffMs;
-                if (backoffMs === undefined) {
-                    throw new PayMongoError('Rate limit exceeded but no backoff time available.', 'RATE_LIMIT_ERROR', 429);
-                }
-                const waitTime = Math.ceil(backoffMs / 1000);
-                throw new PayMongoError(`Rate limit exceeded. Next request available in ${waitTime} seconds. ` +
-                    `Consider using --rate-limit-max-requests to increase limits or wait before retrying.`, 'RATE_LIMIT_EXCEEDED', 429);
-            }
-        }
-        const env = this.config.environment;
-        const secretKey = this.config.apiKeys[env]?.secret;
-        if (!secretKey) {
-            throw new Error('Secret API key not found');
-        }
-        const headers = {
-            ...this.defaultHeaders,
-            ...options.headers,
-            Authorization: `Basic ${Buffer.from(`${secretKey}:`).toString('base64')}`,
-        };
-        let body = null;
-        if (options.body) {
-            body = JSON.stringify(options.body);
-        }
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-            const response = await request(url.toString(), {
-                method,
-                headers,
-                body,
-                signal: controller.signal,
-            });
-            clearTimeout(timeoutId);
-            if (this.rateLimiter && path) {
-                const endpoint = path.replace('/v1', '');
-                this.rateLimiter.recordCall(endpoint);
-            }
-            let data;
-            const contentType = response.headers['content-type'];
-            if (contentType && contentType.includes('application/json')) {
-                data = await response.body.json();
-            }
-            else {
-                data = await response.body.text();
-            }
-            if (response.statusCode >= 400) {
-                this.handleHttpError(response.statusCode, data);
-            }
-            return {
-                statusCode: response.statusCode,
-                data,
-            };
-        }
-        catch (error) {
-            clearTimeout(timeoutId);
-            if (error instanceof Error && error.name === 'AbortError') {
-                throw new NetworkError(`Request timeout after ${this.timeout}ms`, error);
-            }
-            if (error instanceof Error && error.code === 'UND_ERR_CONNECT_TIMEOUT') {
-                throw new NetworkError(`Connection timeout: ${error.message}`, error);
-            }
-            if (error instanceof Error && error.code === 'ENOTFOUND') {
-                throw new NetworkError(`DNS resolution failed: ${error.message}`, error);
-            }
-            throw new NetworkError(`Network error: ${error instanceof Error ? error.message : 'Unknown error'}`, error instanceof Error ? error : undefined);
-        }
-    }
-    handleHttpError(statusCode, data) {
-        if (statusCode === 401) {
-            throw new ApiKeyError('Invalid API key or unauthorized', 'secret');
-        }
-        if (statusCode === 404) {
-            throw new PayMongoError('Resource not found', 'RESOURCE_NOT_FOUND', statusCode);
-        }
-        if (statusCode >= 500) {
-            throw new PayMongoError(`Server error: ${statusCode}`, `SERVER_${statusCode}`, statusCode);
-        }
-        if (data && typeof data === 'object' && 'errors' in data) {
-            const errorResponse = data;
-            if (Array.isArray(errorResponse.errors) && errorResponse.errors.length > 0) {
-                const error = errorResponse.errors[0];
-                if (error) {
-                    const message = error.detail || error.title || `API error: ${statusCode}`;
-                    const code = error.code || `API_${statusCode}`;
-                    throw new PayMongoError(message, code, statusCode);
-                }
-            }
-        }
-        throw new PayMongoError(`HTTP ${statusCode}`, `HTTP_${statusCode}`, statusCode);
-    }
-    async validateApiKey() {
-        await withRetry(() => this.makeRequest('GET', '/v1/webhooks'));
-    }
-    async createWebhook(url, events) {
-        const result = await withRetry(() => this.makeRequest('POST', '/v1/webhooks', {
-            body: {
-                data: {
-                    attributes: {
-                        url,
-                        events,
-                    },
-                },
-            },
-        }).then((response) => response.data.data));
-        await this.cache.invalidate(`webhooks_${this.config.environment}`);
-        return result;
-    }
-    async listWebhooks() {
-        const cacheKey = `webhooks_${this.config.environment}`;
-        const cached = await this.cache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        const result = await withRetry(() => this.makeRequest('GET', '/v1/webhooks').then((response) => response.data.data));
-        await this.cache.set(cacheKey, result);
-        return result;
-    }
-    async getWebhook(id) {
-        const cacheKey = `webhook_${id}`;
-        const cached = await this.cache.get(cacheKey);
-        if (cached) {
-            return cached;
-        }
-        const result = await withRetry(() => this.makeRequest('GET', `/v1/webhooks/${id}`).then((response) => response.data.data));
-        await this.cache.set(cacheKey, result);
-        return result;
-    }
-    async updateWebhook(id, updates) {
-        await this.cache.invalidate(`webhook_${id}`);
-        await this.cache.invalidate(`webhooks_${this.config.environment}`);
-        return withRetry(() => this.makeRequest('PUT', `/v1/webhooks/${id}`, {
-            body: {
-                data: {
-                    attributes: updates,
-                },
-            },
-        }).then((response) => response.data.data));
-    }
-    async deleteWebhook(id) {
-        await this.cache.invalidate(`webhook_${id}`);
-        await this.cache.invalidate(`webhooks_${this.config.environment}`);
-        return withRetry(async () => {
-            await this.makeRequest('DELETE', `/v1/webhooks/${id}`);
-        });
-    }
-    async getPayment(id) {
-        return withRetry(() => this.makeRequest('GET', `/v1/payments/${id}`).then((response) => response.data.data));
-    }
-    async listPayments(limit = 10) {
-        const validLimit = Math.max(1, Math.min(100, limit));
-        const result = await withRetry(() => this.makeRequest('GET', '/v1/payments', {
-            params: { limit: validLimit },
-        }).then((response) => response.data.data));
-        return result;
-    }
-    async createPaymentIntent(amount, currency = 'PHP', description, paymentMethods = ['card', 'gcash', 'paymaya']) {
-        return withRetry(() => this.makeRequest('POST', '/v1/payment_intents', {
-            body: {
-                data: {
-                    attributes: {
-                        amount,
-                        payment_method_allowed: paymentMethods,
-                        currency,
-                        description,
-                    },
-                },
-            },
-        }).then((response) => response.data.data));
-    }
-    async confirmPaymentIntent(id, paymentMethodId, returnUrl) {
-        return withRetry(() => this.makeRequest('POST', `/v1/payment_intents/${id}/confirm`, {
-            body: {
-                data: {
-                    attributes: {
-                        payment_method: paymentMethodId,
-                        return_url: returnUrl,
-                    },
-                },
-            },
-        }).then((response) => response.data.data));
-    }
-    async capturePaymentIntent(id) {
-        return withRetry(() => this.makeRequest('POST', `/v1/payment_intents/${id}/capture`).then((response) => response.data.data));
-    }
-    async createRefund(paymentId, amount, reason) {
-        const attributes = {};
-        if (amount !== undefined) {
-            attributes.amount = amount;
-        }
-        if (reason) {
-            attributes.reason = reason;
-        }
-        return withRetry(() => this.makeRequest('POST', '/v1/refunds', {
-            body: {
-                data: {
-                    attributes: {
-                        payment_id: paymentId,
-                        ...attributes,
-                    },
-                },
-            },
-        }).then((response) => response.data.data));
-    }
-}
-export default ApiClient;