@bloque/payments 0.0.1

package/dist/index.cjs

@@ -0,0 +1,312 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    Bloque: ()=>Bloque
+});
+var package_namespaceObject = JSON.parse('{"UU":"@bloque/payments","rE":"0.0.1"}');
+class BloqueError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'BloqueError';
+        Object.setPrototypeOf(this, BloqueError.prototype);
+    }
+}
+class APIError extends BloqueError {
+    status;
+    code;
+    constructor(message, status, code){
+        super(message), this.status = status, this.code = code;
+        this.name = 'APIError';
+        Object.setPrototypeOf(this, APIError.prototype);
+    }
+}
+class AuthenticationError extends APIError {
+    constructor(message, code){
+        super(message, 401, code);
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+class RateLimitError extends APIError {
+    constructor(message, code){
+        super(message, 429, code);
+        this.name = 'RateLimitError';
+        Object.setPrototypeOf(this, RateLimitError.prototype);
+    }
+}
+const SDK_NAME = package_namespaceObject.UU;
+const SDK_VERSION = package_namespaceObject.rE;
+class HttpClient {
+    baseURL;
+    apiKey;
+    timeout;
+    maxRetries;
+    userAgent;
+    constructor(config){
+        this.baseURL = config.baseURL;
+        this.apiKey = config.apiKey;
+        this.timeout = config.timeout ?? 10000;
+        this.maxRetries = config.maxRetries ?? 2;
+        this.userAgent = `${SDK_NAME}/${SDK_VERSION}`;
+    }
+    async request(options) {
+        const url = this.buildURL(options.path, options.params);
+        const headers = this.buildHeaders(options.headers, options.idempotencyKey);
+        let lastError;
+        for(let attempt = 0; attempt <= this.maxRetries; attempt++)try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(()=>controller.abort(), this.timeout);
+            const response = await fetch(url, {
+                method: options.method,
+                headers,
+                body: options.body ? JSON.stringify(options.body) : void 0,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const error = await this.parseError(response);
+                this.isRetryableHttpStatus(response.status);
+                throw error;
+            }
+            if (204 === response.status) return;
+            return await response.json();
+        } catch (error) {
+            lastError = error;
+            if (!this.isRetryableError(error)) throw error;
+            if (attempt === this.maxRetries) break;
+            await this.sleep(this.backoff(attempt));
+        }
+        throw lastError ?? new BloqueError('Request failed after retries');
+    }
+    buildURL(path, params) {
+        const url = new URL(path, this.baseURL);
+        if (params) {
+            for (const [key, value] of Object.entries(params))if (null != value) url.searchParams.append(key, String(value));
+        }
+        return url.toString();
+    }
+    buildHeaders(customHeaders, idempotencyKey) {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            'User-Agent': this.userAgent,
+            ...idempotencyKey ? {
+                'Idempotency-Key': idempotencyKey
+            } : {},
+            ...customHeaders
+        };
+    }
+    async parseError(response) {
+        let payload;
+        try {
+            payload = await response.json();
+        } catch  {
+            payload = {
+                message: response.statusText
+            };
+        }
+        const message = payload.message || 'Request failed';
+        const code = payload.code;
+        switch(response.status){
+            case 401:
+                return new AuthenticationError(message, code);
+            case 429:
+                return new RateLimitError(message, code);
+            case 400:
+            case 404:
+            case 409:
+            case 422:
+                return new APIError(message, response.status, code);
+            default:
+                return new APIError(message, response.status, code);
+        }
+    }
+    isRetryableHttpStatus(status) {
+        return status >= 500 || 429 === status;
+    }
+    isRetryableError(error) {
+        if (error instanceof AuthenticationError || error instanceof APIError || error instanceof BloqueError) return false;
+        if (error instanceof RateLimitError) return true;
+        error instanceof DOMException && error.name;
+        return true;
+    }
+    backoff(attempt) {
+        const base = 300;
+        const max = 5000;
+        return Math.min(base * 2 ** attempt, max);
+    }
+    sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    get(path, params) {
+        return this.request({
+            method: 'GET',
+            path,
+            params
+        });
+    }
+    post(path, body, options) {
+        return this.request({
+            method: 'POST',
+            path,
+            body,
+            idempotencyKey: options?.idempotencyKey
+        });
+    }
+    patch(path, body) {
+        return this.request({
+            method: 'PATCH',
+            path,
+            body
+        });
+    }
+    delete(path) {
+        return this.request({
+            method: 'DELETE',
+            path
+        });
+    }
+}
+class BaseResource {
+    http;
+    constructor(http){
+        this.http = http;
+    }
+}
+class CheckoutResource extends BaseResource {
+    async create(params) {
+        const items = params.items.map((item)=>({
+                name: item.name,
+                price: item.amount.toString(),
+                units: item.quantity,
+                image_url: item.image_url
+            }));
+        const payload = {
+            name: params.name,
+            description: params.description,
+            asset: 'dUSD/6',
+            payment_type: 'shopping_cart',
+            image_url: params.image_url,
+            items: items,
+            redirect_url: params.success_url,
+            expires_at: params.expires_at,
+            metadata: params.metadata
+        };
+        const response = await this.http.post('/checkout', payload);
+        return {
+            id: response.payment.urn,
+            object: 'checkout',
+            url: response.payment.url,
+            status: response.payment.summary.status,
+            amount_total: response.payment.price,
+            amount_subtotal: response.payment.price,
+            currency: 'USD',
+            items: params.items,
+            created_at: response.payment.created_at,
+            updated_at: response.payment.updated_at,
+            expires_at: response.payment.expires_at,
+            metadata: response.payment.metadata
+        };
+    }
+    async retrieve(checkoutId) {
+        return this.http.get(`/checkout/${checkoutId}`);
+    }
+    async cancel(checkoutId) {
+        return this.http.post(`/checkout/${checkoutId}/cancel`);
+    }
+}
+class PaymentResource extends BaseResource {
+    async create(params) {
+        const paymentPayload = this.buildPaymentPayload(params.payment);
+        const paymentResponse = await this.http.post(`/checkout/${params.checkoutId}/pay/${params.payment.type}`, paymentPayload);
+        return paymentResponse;
+    }
+    buildPaymentPayload(payment) {
+        switch(payment.type){
+            case 'card':
+                return this.buildCardPayload(payment.data);
+            case 'pse':
+                return this.buildPSEPayload(payment.data);
+            case 'cash':
+                return this.buildCashPayload(payment.data);
+        }
+    }
+    buildCardPayload(data) {
+        return {
+            customer_email: data.email || '',
+            number: data.cardNumber,
+            cvc: data.cvv,
+            exp_month: data.expiryMonth,
+            exp_year: data.expiryYear,
+            card_holder: data.cardholderName
+        };
+    }
+    buildPSEPayload(data) {
+        return {
+            customer_email: data.email,
+            person_type: data.personType,
+            document_type: data.documentType,
+            document_number: data.documentNumber,
+            bank_code: data.bankCode
+        };
+    }
+    buildCashPayload(data) {
+        return {
+            customer_email: data.email,
+            document_type: data.documentType,
+            document_number: data.documentNumber,
+            full_name: data.fullName
+        };
+    }
+}
+class Bloque {
+    #httpClient;
+    #config;
+    checkout;
+    payments;
+    constructor(config){
+        if (!config.apiKey) throw new Error('API key is required');
+        this.#config = config;
+        this.#httpClient = new HttpClient({
+            baseURL: 'https: //api.bloque.app/api/payments',
+            apiKey: this.#config.apiKey,
+            timeout: this.#config.timeout,
+            maxRetries: this.#config.maxRetries
+        });
+        this.initializeResources();
+    }
+    initializeResources() {
+        this.checkout = new CheckoutResource(this.#httpClient);
+        this.payments = new PaymentResource(this.#httpClient);
+    }
+}
+exports.Bloque = __webpack_exports__.Bloque;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "Bloque"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { CreatePaymentParams, PaymentResponse, PaymentSubmitPayload, } from '@bloque/payments-core';
+export { Bloque, type BloqueConfig } from './client';
+export type { Checkout, CheckoutItem, CheckoutParams, CheckoutStatus, } from './types/checkout';

package/dist/index.js

@@ -0,0 +1,278 @@
+var package_namespaceObject = JSON.parse('{"UU":"@bloque/payments","rE":"0.0.1"}');
+class BloqueError extends Error {
+    constructor(message){
+        super(message);
+        this.name = 'BloqueError';
+        Object.setPrototypeOf(this, BloqueError.prototype);
+    }
+}
+class APIError extends BloqueError {
+    status;
+    code;
+    constructor(message, status, code){
+        super(message), this.status = status, this.code = code;
+        this.name = 'APIError';
+        Object.setPrototypeOf(this, APIError.prototype);
+    }
+}
+class AuthenticationError extends APIError {
+    constructor(message, code){
+        super(message, 401, code);
+        this.name = 'AuthenticationError';
+        Object.setPrototypeOf(this, AuthenticationError.prototype);
+    }
+}
+class RateLimitError extends APIError {
+    constructor(message, code){
+        super(message, 429, code);
+        this.name = 'RateLimitError';
+        Object.setPrototypeOf(this, RateLimitError.prototype);
+    }
+}
+const SDK_NAME = package_namespaceObject.UU;
+const SDK_VERSION = package_namespaceObject.rE;
+class HttpClient {
+    baseURL;
+    apiKey;
+    timeout;
+    maxRetries;
+    userAgent;
+    constructor(config){
+        this.baseURL = config.baseURL;
+        this.apiKey = config.apiKey;
+        this.timeout = config.timeout ?? 10000;
+        this.maxRetries = config.maxRetries ?? 2;
+        this.userAgent = `${SDK_NAME}/${SDK_VERSION}`;
+    }
+    async request(options) {
+        const url = this.buildURL(options.path, options.params);
+        const headers = this.buildHeaders(options.headers, options.idempotencyKey);
+        let lastError;
+        for(let attempt = 0; attempt <= this.maxRetries; attempt++)try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(()=>controller.abort(), this.timeout);
+            const response = await fetch(url, {
+                method: options.method,
+                headers,
+                body: options.body ? JSON.stringify(options.body) : void 0,
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            if (!response.ok) {
+                const error = await this.parseError(response);
+                this.isRetryableHttpStatus(response.status);
+                throw error;
+            }
+            if (204 === response.status) return;
+            return await response.json();
+        } catch (error) {
+            lastError = error;
+            if (!this.isRetryableError(error)) throw error;
+            if (attempt === this.maxRetries) break;
+            await this.sleep(this.backoff(attempt));
+        }
+        throw lastError ?? new BloqueError('Request failed after retries');
+    }
+    buildURL(path, params) {
+        const url = new URL(path, this.baseURL);
+        if (params) {
+            for (const [key, value] of Object.entries(params))if (null != value) url.searchParams.append(key, String(value));
+        }
+        return url.toString();
+    }
+    buildHeaders(customHeaders, idempotencyKey) {
+        return {
+            Authorization: `Bearer ${this.apiKey}`,
+            'Content-Type': 'application/json',
+            'User-Agent': this.userAgent,
+            ...idempotencyKey ? {
+                'Idempotency-Key': idempotencyKey
+            } : {},
+            ...customHeaders
+        };
+    }
+    async parseError(response) {
+        let payload;
+        try {
+            payload = await response.json();
+        } catch  {
+            payload = {
+                message: response.statusText
+            };
+        }
+        const message = payload.message || 'Request failed';
+        const code = payload.code;
+        switch(response.status){
+            case 401:
+                return new AuthenticationError(message, code);
+            case 429:
+                return new RateLimitError(message, code);
+            case 400:
+            case 404:
+            case 409:
+            case 422:
+                return new APIError(message, response.status, code);
+            default:
+                return new APIError(message, response.status, code);
+        }
+    }
+    isRetryableHttpStatus(status) {
+        return status >= 500 || 429 === status;
+    }
+    isRetryableError(error) {
+        if (error instanceof AuthenticationError || error instanceof APIError || error instanceof BloqueError) return false;
+        if (error instanceof RateLimitError) return true;
+        error instanceof DOMException && error.name;
+        return true;
+    }
+    backoff(attempt) {
+        const base = 300;
+        const max = 5000;
+        return Math.min(base * 2 ** attempt, max);
+    }
+    sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    get(path, params) {
+        return this.request({
+            method: 'GET',
+            path,
+            params
+        });
+    }
+    post(path, body, options) {
+        return this.request({
+            method: 'POST',
+            path,
+            body,
+            idempotencyKey: options?.idempotencyKey
+        });
+    }
+    patch(path, body) {
+        return this.request({
+            method: 'PATCH',
+            path,
+            body
+        });
+    }
+    delete(path) {
+        return this.request({
+            method: 'DELETE',
+            path
+        });
+    }
+}
+class BaseResource {
+    http;
+    constructor(http){
+        this.http = http;
+    }
+}
+class CheckoutResource extends BaseResource {
+    async create(params) {
+        const items = params.items.map((item)=>({
+                name: item.name,
+                price: item.amount.toString(),
+                units: item.quantity,
+                image_url: item.image_url
+            }));
+        const payload = {
+            name: params.name,
+            description: params.description,
+            asset: 'dUSD/6',
+            payment_type: 'shopping_cart',
+            image_url: params.image_url,
+            items: items,
+            redirect_url: params.success_url,
+            expires_at: params.expires_at,
+            metadata: params.metadata
+        };
+        const response = await this.http.post('/checkout', payload);
+        return {
+            id: response.payment.urn,
+            object: 'checkout',
+            url: response.payment.url,
+            status: response.payment.summary.status,
+            amount_total: response.payment.price,
+            amount_subtotal: response.payment.price,
+            currency: 'USD',
+            items: params.items,
+            created_at: response.payment.created_at,
+            updated_at: response.payment.updated_at,
+            expires_at: response.payment.expires_at,
+            metadata: response.payment.metadata
+        };
+    }
+    async retrieve(checkoutId) {
+        return this.http.get(`/checkout/${checkoutId}`);
+    }
+    async cancel(checkoutId) {
+        return this.http.post(`/checkout/${checkoutId}/cancel`);
+    }
+}
+class PaymentResource extends BaseResource {
+    async create(params) {
+        const paymentPayload = this.buildPaymentPayload(params.payment);
+        const paymentResponse = await this.http.post(`/checkout/${params.checkoutId}/pay/${params.payment.type}`, paymentPayload);
+        return paymentResponse;
+    }
+    buildPaymentPayload(payment) {
+        switch(payment.type){
+            case 'card':
+                return this.buildCardPayload(payment.data);
+            case 'pse':
+                return this.buildPSEPayload(payment.data);
+            case 'cash':
+                return this.buildCashPayload(payment.data);
+        }
+    }
+    buildCardPayload(data) {
+        return {
+            customer_email: data.email || '',
+            number: data.cardNumber,
+            cvc: data.cvv,
+            exp_month: data.expiryMonth,
+            exp_year: data.expiryYear,
+            card_holder: data.cardholderName
+        };
+    }
+    buildPSEPayload(data) {
+        return {
+            customer_email: data.email,
+            person_type: data.personType,
+            document_type: data.documentType,
+            document_number: data.documentNumber,
+            bank_code: data.bankCode
+        };
+    }
+    buildCashPayload(data) {
+        return {
+            customer_email: data.email,
+            document_type: data.documentType,
+            document_number: data.documentNumber,
+            full_name: data.fullName
+        };
+    }
+}
+class Bloque {
+    #httpClient;
+    #config;
+    checkout;
+    payments;
+    constructor(config){
+        if (!config.apiKey) throw new Error('API key is required');
+        this.#config = config;
+        this.#httpClient = new HttpClient({
+            baseURL: 'https: //api.bloque.app/api/payments',
+            apiKey: this.#config.apiKey,
+            timeout: this.#config.timeout,
+            maxRetries: this.#config.maxRetries
+        });
+        this.initializeResources();
+    }
+    initializeResources() {
+        this.checkout = new CheckoutResource(this.#httpClient);
+        this.payments = new PaymentResource(this.#httpClient);
+    }
+}
+export { Bloque };

package/dist/resources/base.d.ts

@@ -0,0 +1,5 @@
+import type { HttpClient } from '../http/http-client';
+export declare abstract class BaseResource {
+    protected http: HttpClient;
+    constructor(http: HttpClient);
+}

package/dist/resources/checkout.d.ts

@@ -0,0 +1,7 @@
+import type { Checkout, CheckoutParams } from '../types/checkout';
+import { BaseResource } from './base';
+export declare class CheckoutResource extends BaseResource {
+    create(params: CheckoutParams): Promise<Checkout>;
+    retrieve(checkoutId: string): Promise<Checkout>;
+    cancel(checkoutId: string): Promise<Checkout>;
+}

package/dist/resources/payment.d.ts

@@ -0,0 +1,33 @@
+import type { CreatePaymentParams, PaymentResponse } from '@bloque/payments-core';
+import { BaseResource } from './base';
+export declare class PaymentResource extends BaseResource {
+    /**
+     * Create a payment for an existing checkout session
+     *
+     * @param params - Checkout ID and payment data
+     * @returns Payment response
+     *
+     * @example
+     * ```typescript
+     * const payment = await bloque.payments.create({
+     *   checkoutId: 'checkout_abc123',
+     *   payment: {
+     *     type: 'card',
+     *     data: {
+     *       cardNumber: '4111111111111111',
+     *       cardholderName: 'John Doe',
+     *       expiryMonth: '12',
+     *       expiryYear: '2025',
+     *       cvv: '123',
+     *       email: 'john@example.com'
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    create(params: CreatePaymentParams): Promise<PaymentResponse>;
+    private buildPaymentPayload;
+    private buildCardPayload;
+    private buildPSEPayload;
+    private buildCashPayload;
+}