@blocklet/payment-broker-client 1.20.17

package/lib/node/index.js

@@ -0,0 +1,984 @@
+'use strict';
+
+/* eslint-disable import/prefer-default-export */
+// Deployment step constants
+const STEPS = {
+    PAYMENT_PENDING: 'payment_pending',
+    PAYMENT_COMPLETED: 'payment_completed',
+    INSTALLATION_STARTING: 'installation_starting',
+    INSTALLATION_COMPLETED: 'installation_completed',
+    SERVICE_STARTING: 'service_starting',
+    SERVICE_READY: 'service_ready',
+    ACCESS_PREPARING: 'access_preparing',
+    ACCESS_READY: 'access_ready',
+};
+const DEFAULT_CONFIG = {
+    timeout: 300000, // 5 minutes
+    polling: {
+        interval: 3000, // 3 seconds
+        maxAttempts: 100,
+        backoffStrategy: 'linear',
+    },
+};
+const API_ENDPOINTS = {
+    createCheckout: '/api/checkout-sessions/start',
+    paymentPage: '/checkout/pay/{id}',
+    orderStatus: '/api/vendors/order/{id}/status',
+    orderDetail: '/api/vendors/order/{id}/detail',
+    vendors: '/api/sessions/{id}/vendors',
+};
+const DEPLOYMENT_STEPS = {
+    CREATING_SESSION: 'creating_session',
+    WAITING_PAYMENT: 'waiting_payment',
+    INSTALLING: 'installing',
+    STARTING_SERVICE: 'starting_service',
+    GETTING_URLS: 'getting_urls',
+    COMPLETED: 'completed',
+};
+const ERROR_CODES = {
+    NETWORK_ERROR: 'NETWORK_ERROR',
+    TIMEOUT_ERROR: 'TIMEOUT_ERROR',
+    PAYMENT_ERROR: 'PAYMENT_ERROR',
+    VALIDATION_ERROR: 'VALIDATION_ERROR',
+    SESSION_ERROR: 'SESSION_ERROR',
+    DEPLOYMENT_ERROR: 'DEPLOYMENT_ERROR',
+    UNKNOWN_ERROR: 'UNKNOWN_ERROR',
+};
+
+/* eslint-disable import/prefer-default-export */
+function createDeploymentError(message, code, options) {
+    const error = new Error(message);
+    error.code = code;
+    error.step = options?.step;
+    error.sessionId = options?.sessionId;
+    error.paymentUrl = options?.paymentUrl;
+    error.linkId = options?.linkId;
+    error.timestamp = new Date().toISOString();
+    error.details = options?.details;
+    error.recovery = options?.recovery;
+    return error;
+}
+function isDeploymentError(error) {
+    return error && typeof error === 'object' && 'code' in error;
+}
+
+/* eslint-disable import/prefer-default-export */
+const httpUtils = {
+    async request(url, options = {}) {
+        const response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers,
+            },
+        });
+        if (!response.ok) {
+            throw createDeploymentError(`HTTP ${response.status}: ${response.statusText}`, 'NETWORK_ERROR', {
+                details: { status: response.status, statusText: response.statusText },
+                recovery: {
+                    canRetry: response.status >= 500, // Server errors can be retried
+                    suggestions: response.status === 404
+                        ? ['Check if the URL is correct', 'Verify the service is running']
+                        : ['Check your network connection', 'Try again later'],
+                },
+            });
+        }
+        return response.json();
+    },
+    get(url, headers) {
+        return this.request(url, { method: 'GET', headers });
+    },
+    post(url, data, headers) {
+        return this.request(url, {
+            method: 'POST',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    },
+    put(url, data, headers) {
+        return this.request(url, {
+            method: 'PUT',
+            body: data ? JSON.stringify(data) : undefined,
+            headers,
+        });
+    },
+    delete(url, headers) {
+        return this.request(url, { method: 'DELETE', headers });
+    },
+};
+const urlUtils = {
+    join(...parts) {
+        return parts
+            .map((part, index) => {
+            if (index === 0) {
+                return part.replace(/\/+$/, '');
+            }
+            return part.replace(/^\/+/, '').replace(/\/+$/, '');
+        })
+            .filter(Boolean)
+            .join('/');
+    },
+    addParams(url, params) {
+        const urlObj = new URL(url);
+        Object.entries(params).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                urlObj.searchParams.set(key, String(value));
+            }
+        });
+        return urlObj.toString();
+    },
+    replaceParams(url, params) {
+        let result = url;
+        Object.entries(params).forEach(([key, value]) => {
+            result = result.replace(`:${key}`, value);
+        });
+        return result;
+    },
+    isValidUrl(url) {
+        try {
+            // eslint-disable-next-line no-new
+            new URL(url);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+};
+const timeUtils = {
+    formatDuration(ms) {
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            return `${hours}h ${minutes % 60}m ${seconds % 60}s`;
+        }
+        if (minutes > 0) {
+            return `${minutes}m ${seconds % 60}s`;
+        }
+        return `${seconds}s`;
+    },
+    sleep(ms) {
+        return new Promise((resolve) => {
+            setTimeout(resolve, ms);
+        });
+    },
+    timeout(promise, ms) {
+        return Promise.race([
+            promise,
+            new Promise((_, reject) => {
+                setTimeout(() => reject(createDeploymentError('Operation timed out', 'TIMEOUT_ERROR', {
+                    recovery: {
+                        canRetry: true,
+                        suggestions: ['Try again with a longer timeout', 'Check your network connection'],
+                    },
+                })), ms);
+            }),
+        ]);
+    },
+    now() {
+        return new Date().toISOString();
+    },
+};
+const objectUtils = {
+    deepMerge(target, ...sources) {
+        if (!sources.length)
+            return target;
+        const source = sources.shift();
+        if (this.isObject(target) && this.isObject(source)) {
+            Object.keys(source).forEach((key) => {
+                if (this.isObject(source[key])) {
+                    if (!target[key])
+                        Object.assign(target, { [key]: {} });
+                    this.deepMerge(target[key], source[key]);
+                }
+                else {
+                    Object.assign(target, { [key]: source[key] });
+                }
+            });
+        }
+        return this.deepMerge(target, ...sources);
+    },
+    isObject(item) {
+        return item && typeof item === 'object' && !Array.isArray(item);
+    },
+    pick(obj, keys) {
+        const result = {};
+        keys.forEach((key) => {
+            if (key in obj) {
+                result[key] = obj[key];
+            }
+        });
+        return result;
+    },
+    omit(obj, keys) {
+        const result = { ...obj };
+        keys.forEach((key) => {
+            delete result[key];
+        });
+        return result;
+    },
+    deepClone(obj) {
+        if (obj === null || typeof obj !== 'object') {
+            return obj;
+        }
+        if (obj instanceof Date) {
+            return new Date(obj.getTime());
+        }
+        if (obj instanceof Array) {
+            return obj.map((item) => this.deepClone(item));
+        }
+        if (typeof obj === 'object') {
+            const cloned = {};
+            Object.keys(obj).forEach((key) => {
+                cloned[key] = this.deepClone(obj[key]);
+            });
+            return cloned;
+        }
+        return obj;
+    },
+};
+
+/* eslint-disable import/prefer-default-export */
+// Internal debug logger - only logs when BROKER_CLIENT_DEBUG=true
+const isDebugEnabled = (() => {
+    try {
+        return typeof process !== 'undefined' && process.env?.BROKER_CLIENT_DEBUG === 'true';
+    }
+    catch {
+        // In browser environments, check localStorage or global variables
+        return typeof window !== 'undefined' && window.BROKER_CLIENT_DEBUG === 'true';
+    }
+})();
+const logger = {
+    debug: (message, data) => {
+        if (isDebugEnabled) {
+            // eslint-disable-next-line no-console
+            console.log(`[BROKER-CLIENT-DEBUG] ${message}`, data ? JSON.stringify(data) : '');
+        }
+    },
+    info: (message, data) => {
+        if (isDebugEnabled) {
+            // eslint-disable-next-line no-console
+            console.log(`[BROKER-CLIENT-DEBUG] ${message}`, data ? JSON.stringify(data) : '');
+        }
+    },
+    warn: (message, data) => {
+        if (isDebugEnabled) {
+            console.warn(`[BROKER-CLIENT-DEBUG] ${message}`, data ? JSON.stringify(data) : '');
+        }
+    },
+    error: (message, data) => {
+        if (isDebugEnabled) {
+            console.error(`[BROKER-CLIENT-DEBUG] ${message}`, data ? JSON.stringify(data) : '');
+        }
+    },
+};
+
+/* eslint-disable import/prefer-default-export */
+class SessionManager {
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+    }
+    async getConfigInfo() {
+        if (this.cachedConfig) {
+            return this.cachedConfig;
+        }
+        const blockletInfo = await this.deps.configProvider.getBlockletInfo();
+        const paymentLinkKey = this.config.paymentLinkKey || 'PAYMENT_LINK_ID';
+        const linkId = blockletInfo[paymentLinkKey];
+        if (!linkId) {
+            throw createDeploymentError(`Payment link ID not found using key '${paymentLinkKey}' in blocklet configuration`, 'VALIDATION_ERROR', {
+                step: 'creating_session',
+                recovery: {
+                    canRetry: false,
+                    suggestions: [
+                        `Make sure ${paymentLinkKey} is set in the environment`,
+                        'Check if the Payment Kit is properly configured',
+                        'Verify the paymentLinkKey configuration is correct',
+                    ],
+                },
+            });
+        }
+        const paymentKitDid = 'z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk';
+        let mountPoint = '/';
+        if (blockletInfo.componentMountPoints && Array.isArray(blockletInfo.componentMountPoints)) {
+            const paymentKitComponent = blockletInfo.componentMountPoints.find((component) => component.did === paymentKitDid || component.appId === paymentKitDid);
+            if (paymentKitComponent?.mountPoint) {
+                mountPoint = paymentKitComponent.mountPoint;
+            }
+        }
+        this.cachedConfig = { linkId, mountPoint, paymentKitDid };
+        logger.info('Configuration processed', this.cachedConfig);
+        return this.cachedConfig;
+    }
+    /**
+     * Get linkId
+     */
+    async getLinkId() {
+        const { linkId } = await this.getConfigInfo();
+        return linkId;
+    }
+    /**
+     * Get mountPoint
+     */
+    async getMountPoint() {
+        const { mountPoint } = await this.getConfigInfo();
+        return mountPoint;
+    }
+    /**
+     * Get paymentKitDid
+     */
+    async getPaymentKitDid() {
+        const { paymentKitDid } = await this.getConfigInfo();
+        return paymentKitDid;
+    }
+    async checkCacheCheckoutId(checkoutId) {
+        try {
+            if (!checkoutId) {
+                return '';
+            }
+            // API_ENDPOINTS already includes /api prefix
+            const orderStatusUrl = urlUtils.join(this.config.baseUrl, API_ENDPOINTS.orderStatus.replace('{id}', checkoutId));
+            const response = await this.deps.httpClient.get(orderStatusUrl);
+            if (response.error) {
+                throw new Error(response.error);
+            }
+            // Check payment status
+            const isPaid = response.payment_status === 'paid';
+            return isPaid ? checkoutId : '';
+        }
+        catch {
+            return '';
+        }
+    }
+    async createSession(options = {}) {
+        const { linkId, mountPoint, paymentKitDid } = await this.getConfigInfo();
+        logger.info('Creating payment session', { linkId, mountPoint, paymentKitDid });
+        try {
+            // Build URL - API_ENDPOINTS already includes /api prefix
+            const url = urlUtils.join(this.config.baseUrl, API_ENDPOINTS.createCheckout, linkId);
+            const { needShortUrl = true, page_info: pageInfo } = options;
+            const payload = {
+                needShortUrl,
+                metadata: {
+                    page_info: {
+                        has_vendor: true,
+                        ...pageInfo,
+                    },
+                },
+            };
+            const response = await timeUtils.timeout(this.deps.httpClient.post(url, payload), this.config.timeout || 30000);
+            const session = {
+                id: response.checkoutSession.id,
+                paymentUrl: response.paymentUrl,
+                status: 'pending',
+                linkId,
+                vendorDid: paymentKitDid,
+                createdAt: timeUtils.now(),
+                updatedAt: timeUtils.now(),
+                expiresAt: new Date(Date.now() + (this.config.timeout || 300000)).toISOString(),
+                currency: 'USD',
+            };
+            logger.info('Session created successfully', { sessionId: session.id });
+            return session;
+        }
+        catch (error) {
+            logger.error('Failed to create session', { error: error.message, linkId });
+            throw createDeploymentError(`Failed to create session: ${error.message}`, 'SESSION_ERROR', {
+                step: 'creating_session',
+                linkId,
+                details: { originalError: error },
+                recovery: {
+                    canRetry: true,
+                    suggestions: ['Check your network connection', 'Verify the Payment Kit service is available'],
+                },
+            });
+        }
+    }
+    async getSessionStatus(sessionId) {
+        logger.debug('Getting session status', { sessionId });
+        try {
+            // API_ENDPOINTS already includes /api prefix
+            const url = urlUtils.join(this.config.baseUrl, API_ENDPOINTS.orderStatus.replace('{id}', sessionId));
+            const response = await timeUtils.timeout(this.deps.httpClient.get(url), this.config.timeout || 30000);
+            logger.debug('Session status retrieved', { sessionId, status: response.payment_status });
+            return response;
+        }
+        catch (error) {
+            logger.error('Failed to get session status', { error: error.message, sessionId });
+            throw createDeploymentError(`Failed to get session status: ${error.message}`, 'SESSION_ERROR', {
+                sessionId,
+                recovery: {
+                    canRetry: true,
+                    suggestions: ['Check your network connection', 'Verify the session ID is correct'],
+                },
+            });
+        }
+    }
+    waitForPayment(sessionId) {
+        logger.info('Waiting for payment completion', { sessionId });
+        return this.deps.pollingManager.poll({
+            checkCondition: async () => {
+                const status = await this.getSessionStatus(sessionId);
+                if (status.payment_status === 'paid') {
+                    logger.info('Payment completed', { sessionId });
+                    return status.vendors || true;
+                }
+                if (status.payment_status === 'expired' || status.payment_status === 'cancelled') {
+                    throw createDeploymentError(`Payment ${status.payment_status}`, 'SESSION_ERROR', {
+                        sessionId,
+                        recovery: {
+                            canRetry: status.payment_status === 'expired',
+                            suggestions: status.payment_status === 'expired'
+                                ? ['Create a new payment session', 'Try the deployment again']
+                                : ['Payment was cancelled', 'Start a new deployment if needed'],
+                        },
+                    });
+                }
+                return false;
+            },
+            stepName: 'waiting for payment',
+            maxAttempts: this.config.polling?.maxAttempts || 100,
+            interval: this.config.polling?.interval || 3000,
+        });
+    }
+    async getOrderDetails(sessionId) {
+        logger.debug('Getting order details', { sessionId });
+        try {
+            // API_ENDPOINTS already includes /api prefix
+            const url = urlUtils.join(this.config.baseUrl, API_ENDPOINTS.orderDetail.replace('{id}', sessionId));
+            const response = await timeUtils.timeout(this.deps.httpClient.get(url), this.config.timeout || 30000);
+            logger.debug('Order details retrieved', { sessionId });
+            return response;
+        }
+        catch (error) {
+            logger.error('Failed to get order details', { error: error.message, sessionId });
+            throw createDeploymentError(`Failed to get order details: ${error.message}`, 'SESSION_ERROR', {
+                sessionId,
+                recovery: {
+                    canRetry: true,
+                    suggestions: ['Check your network connection', 'Verify the session is still active'],
+                },
+            });
+        }
+    }
+}
+
+/* eslint-disable import/prefer-default-export */
+/**
+ * Unified DeploymentManager class
+ * Uses dependency injection to support different environment implementations
+ */
+class DeploymentManager {
+    constructor(config, deps) {
+        this.config = config;
+        this.deps = deps;
+        this.installationStarted = false;
+        this.serviceStartCallbackCalled = false;
+        this.currentDeployment = null;
+    }
+    async startDeployment(sessionId, options) {
+        this.currentDeployment = {
+            sessionId,
+            startTime: timeUtils.now(),
+        };
+        this.installationStarted = false;
+        this.serviceStartCallbackCalled = false;
+        logger.info('Starting deployment', { sessionId });
+        try {
+            await this.waitForPaymentCompletion(sessionId, options);
+            const vendors = await this.waitForInstallation(sessionId, options);
+            await this.waitForServiceStartup(vendors, options);
+            const result = await this.getFinalUrls(sessionId, vendors, options);
+            this.currentDeployment.result = result;
+            logger.info('Deployment completed successfully', { sessionId, duration: result.duration });
+            return result;
+        }
+        catch (error) {
+            logger.error('Deployment failed', { sessionId, error: error.message });
+            this.currentDeployment.error = error;
+            options.onError?.(error, 'getting_urls'); // Call onError
+            throw error;
+        }
+    }
+    async waitForPaymentCompletion(sessionId, options) {
+        logger.info('Waiting for payment to be marked as paid', { sessionId });
+        await this.deps.pollingManager.poll({
+            checkCondition: async () => {
+                // API_ENDPOINTS already includes /api prefix
+                const orderStatusUrl = urlUtils.join(this.config.baseUrl, API_ENDPOINTS.orderStatus.replace('{id}', sessionId));
+                const response = await this.deps.httpClient.get(orderStatusUrl);
+                if (response.session_status === 'complete') {
+                    const vendors = response.vendors || [];
+                    await options.hooks?.[STEPS.PAYMENT_COMPLETED]?.({
+                        sessionId,
+                        vendors,
+                    });
+                    return true;
+                }
+                return false;
+            },
+            stepName: 'waiting_payment',
+        });
+    }
+    waitForInstallation(sessionId, options) {
+        logger.info('Waiting for installation to start', { sessionId });
+        return this.deps.pollingManager.poll({
+            checkCondition: async () => {
+                // API_ENDPOINTS already includes /api prefix
+                const url = urlUtils.join(this.config.baseUrl, API_ENDPOINTS.orderStatus.replace('{id}', sessionId));
+                const response = await this.deps.httpClient.get(url);
+                const vendors = response.vendors || [];
+                if (vendors.length === 0) {
+                    return false;
+                }
+                if (vendors.length > 0 && !this.installationStarted) {
+                    this.installationStarted = true;
+                    await options.hooks?.[STEPS.INSTALLATION_STARTING]?.({
+                        vendors,
+                    });
+                }
+                // Check if all vendors meet conditions: progress >= 80 and appUrl exists
+                const isInstalled = vendors.every((vendor) => vendor.progress >= 80 && vendor.appUrl);
+                if (isInstalled) {
+                    const avgProgress = vendors.reduce((sum, v) => sum + v.progress, 0) / vendors.length;
+                    await options.hooks?.[STEPS.INSTALLATION_COMPLETED]?.({
+                        vendors,
+                        progress: Math.round(avgProgress),
+                    });
+                    return vendors;
+                }
+                return false;
+            },
+            stepName: 'installation_started',
+        });
+    }
+    async waitForServiceStartup(vendors, options) {
+        logger.info('Services starting', { vendorCount: vendors.length });
+        // Since we don't need to check service status, we can directly call the callbacks
+        await options.hooks?.[STEPS.SERVICE_STARTING]?.({
+            vendors,
+        });
+        // Wait a brief moment for services to initialize
+        await new Promise((resolve) => {
+            setTimeout(resolve, 2000);
+        });
+        logger.info('Services started successfully');
+        await options.hooks?.[STEPS.SERVICE_READY]?.({
+            vendors,
+        });
+    }
+    async getFinalUrls(sessionId, runningVendors, options) {
+        try {
+            await options.hooks?.[STEPS.ACCESS_PREPARING]?.({
+                sessionId,
+            });
+            // API_ENDPOINTS already includes /api prefix
+            const orderDetailUrl = urlUtils.join(this.config.baseUrl, API_ENDPOINTS.orderDetail.replace('{id}', sessionId));
+            const data = await this.deps.httpClient.get(orderDetailUrl);
+            if (data.vendors.length === 0) {
+                throw createDeploymentError('No vendors found in order details', 'DEPLOYMENT_ERROR', {
+                    step: 'getting_urls',
+                    sessionId,
+                    recovery: {
+                        canRetry: true,
+                        suggestions: ['Wait a moment and try again', 'Check if the deployment completed successfully'],
+                    },
+                });
+            }
+            // Wait 3 seconds like in the original code
+            await timeUtils.sleep(3000);
+            // Return the URLs from the API response, fallback to running vendor data
+            const apiVendor = data.vendors[0];
+            const primaryVendor = runningVendors[0];
+            const endTime = timeUtils.now();
+            const duration = this.currentDeployment.startTime
+                ? new Date(endTime).getTime() - new Date(this.currentDeployment.startTime).getTime()
+                : 0;
+            const result = {
+                success: true,
+                sessionId,
+                appUrl: apiVendor?.appUrl || primaryVendor?.appUrl,
+                dashboardUrl: apiVendor?.dashboardUrl || primaryVendor?.dashboardUrl,
+                homeUrl: apiVendor?.homeUrl || primaryVendor?.homeUrl,
+                token: apiVendor?.token || primaryVendor?.token,
+                subscriptionUrl: data.subscriptionUrl,
+                vendors: data.vendors || runningVendors,
+                duration,
+                startTime: this.currentDeployment.startTime || timeUtils.now(),
+                endTime,
+                metadata: data.metadata,
+                data: data.data,
+            };
+            await options.hooks?.[STEPS.ACCESS_READY]?.({
+                sessionId,
+                appUrl: result.appUrl,
+                dashboardUrl: result.dashboardUrl,
+                homeUrl: result.homeUrl,
+                subscriptionUrl: result.subscriptionUrl,
+            });
+            return result;
+        }
+        catch (error) {
+            logger.error('Failed to get final URLs', { sessionId, error: error.message });
+            // If getting details fails, use the appUrl of running vendor
+            return {
+                success: true,
+                sessionId,
+                appUrl: runningVendors[0]?.appUrl || null,
+                dashboardUrl: runningVendors[0]?.dashboardUrl || null,
+                homeUrl: runningVendors[0]?.homeUrl || null,
+                token: runningVendors[0]?.token || null,
+                duration: this.currentDeployment.startTime
+                    ? new Date().getTime() - new Date(this.currentDeployment.startTime).getTime()
+                    : 0,
+            };
+        }
+    }
+}
+
+/**
+ * Unified BrokerClient class
+ * Uses dependency injection to support different environment implementations
+ */
+class BrokerClient {
+    constructor(config, dependencies) {
+        this.isDeploying = false;
+        this.currentDeployment = null;
+        this.validateConfig(config);
+        this.config = objectUtils.deepMerge({}, DEFAULT_CONFIG, config);
+        this.sessionManager = new SessionManager(this.config, dependencies);
+        this.deploymentManager = new DeploymentManager(this.config, dependencies);
+    }
+    async deploy(options) {
+        if (this.isDeploying) {
+            throw createDeploymentError('Deployment already in progress', 'VALIDATION_ERROR');
+        }
+        this.isDeploying = true;
+        this.currentDeployment = {
+            sessionId: '', // Will be set after session creation
+            startTime: timeUtils.now(),
+        };
+        try {
+            let sessionId;
+            let paymentUrl = options.cachedPaymentUrl;
+            // Check cached checkout session
+            if (options.cachedCheckoutId) {
+                logger.info('Checking cached checkout session', { cachedCheckoutId: options.cachedCheckoutId });
+                const cachedCheckoutId = await this.sessionManager.checkCacheCheckoutId(options.cachedCheckoutId);
+                if (cachedCheckoutId) {
+                    sessionId = cachedCheckoutId;
+                    logger.info('Using cached session', { sessionId });
+                    // Build payment URL if not cached
+                    if (!paymentUrl) {
+                        const mountPoint = await this.sessionManager.getMountPoint();
+                        const basePath = `${this.config.baseUrl}${mountPoint}`;
+                        paymentUrl = `${basePath}/checkout/pay/${sessionId}`;
+                    }
+                    await options.hooks?.[STEPS.PAYMENT_PENDING]?.({
+                        sessionId,
+                        paymentUrl,
+                        isResuming: true,
+                    });
+                }
+            }
+            // Create new session if no valid cached session
+            if (!sessionId) {
+                logger.info('Creating new checkout session');
+                const linkId = await this.sessionManager.getLinkId();
+                const session = await this.sessionManager.createSession(options);
+                sessionId = session.id;
+                paymentUrl = session.paymentUrl;
+                await options.hooks?.[STEPS.PAYMENT_PENDING]?.({
+                    sessionId: session.id,
+                    paymentUrl: session.paymentUrl,
+                    linkId,
+                    isResuming: false,
+                });
+            }
+            this.currentDeployment.sessionId = sessionId;
+            const result = await this.deploymentManager.startDeployment(sessionId, options);
+            return result;
+        }
+        catch (error) {
+            this.isDeploying = false;
+            if (this.currentDeployment) {
+                if (isDeploymentError(error)) {
+                    this.currentDeployment.error = error;
+                }
+                else {
+                    this.currentDeployment.error = createDeploymentError(error.message, 'UNKNOWN_ERROR', {
+                        sessionId: this.currentDeployment.sessionId,
+                        details: { originalError: error },
+                        recovery: {
+                            canRetry: true,
+                            suggestions: ['Check your network connection', 'Verify the baseUrl is correct'],
+                        },
+                    });
+                }
+            }
+            if (options.onError) {
+                const deploymentError = isDeploymentError(error) ? error : this.currentDeployment?.error;
+                if (deploymentError) {
+                    options.onError(deploymentError, deploymentError.step);
+                }
+            }
+            throw error;
+        }
+    }
+    createSession(options = {}) {
+        return this.sessionManager.createSession(options);
+    }
+    getSessionStatus(sessionId) {
+        return this.sessionManager.getSessionStatus(sessionId);
+    }
+    cancelDeployment() {
+        if (this.isDeploying) {
+            logger.info('Cancelling deployment');
+            this.isDeploying = false;
+            // Note: Actual cancellation would need to be implemented in deployment manager
+        }
+    }
+    getDeploymentStatus() {
+        const result = this.currentDeployment?.result;
+        const error = this.currentDeployment?.error;
+        const sessionId = this.currentDeployment?.sessionId;
+        const startTime = this.currentDeployment?.startTime;
+        return {
+            isDeploying: this.isDeploying,
+            result,
+            error,
+            sessionId,
+            duration: startTime ? new Date().getTime() - new Date(startTime).getTime() : 0,
+        };
+    }
+    updateConfig(newConfig) {
+        this.config = objectUtils.deepMerge(this.config, newConfig);
+        // Note: In a real implementation, we might need to recreate the dependencies
+        // For now, we assume the dependencies remain the same
+    }
+    getConfig() {
+        return this.config;
+    }
+    validateConfig(config) {
+        if (!config.baseUrl) {
+            throw createDeploymentError('baseUrl is required in configuration', 'VALIDATION_ERROR');
+        }
+        try {
+            // eslint-disable-next-line no-new
+            new URL(config.baseUrl);
+        }
+        catch {
+            throw createDeploymentError('Invalid baseUrl format', 'VALIDATION_ERROR');
+        }
+    }
+}
+
+/* eslint-disable import/prefer-default-export */
+class PollingManager {
+    constructor(options = {}) {
+        this.baseInterval = 1000;
+        this.maxAttempts = 60;
+        this.backoffStrategy = 'linear';
+        this.baseInterval = options.baseInterval || 1000;
+        this.maxAttempts = options.maxAttempts || 60;
+        this.backoffStrategy = options.backoffStrategy || 'linear';
+    }
+    async poll(options) {
+        const { checkCondition, stepName = 'polling', interval = this.baseInterval, maxAttempts = this.maxAttempts, backoffStrategy = this.backoffStrategy, onProgress, } = options;
+        for (let attempts = 1; attempts <= maxAttempts; attempts++) {
+            try {
+                logger.debug(`${stepName} - Attempt ${attempts}/${maxAttempts}`);
+                // eslint-disable-next-line no-await-in-loop
+                const result = await checkCondition();
+                if (result !== null && result !== false && result !== undefined) {
+                    logger.debug(`${stepName} - Success on attempt ${attempts}`);
+                    return result;
+                }
+                onProgress?.(attempts, maxAttempts);
+                if (attempts < maxAttempts) {
+                    const waitTime = this.calculateWaitTime(attempts, interval, backoffStrategy);
+                    logger.debug(`${stepName} - Waiting ${waitTime}ms before next attempt`);
+                    // eslint-disable-next-line no-await-in-loop
+                    await timeUtils.sleep(waitTime);
+                }
+            }
+            catch (error) {
+                logger.error(`${stepName} - Error on attempt ${attempts}:`, error.message);
+                if (attempts === maxAttempts) {
+                    throw createDeploymentError(`${stepName} failed after ${maxAttempts} attempts: ${error.message}`, 'TIMEOUT_ERROR');
+                }
+                const waitTime = this.calculateWaitTime(attempts, interval, backoffStrategy);
+                // eslint-disable-next-line no-await-in-loop
+                await timeUtils.sleep(waitTime);
+            }
+        }
+        throw createDeploymentError(`${stepName} timed out after ${maxAttempts} attempts`, 'TIMEOUT_ERROR');
+    }
+    calculateWaitTime(attempt, baseInterval, strategy) {
+        switch (strategy) {
+            case 'linear':
+                return baseInterval;
+            case 'exponential':
+                return Math.min(baseInterval * 2 ** (attempt - 1), 30000);
+            default:
+                return baseInterval;
+        }
+    }
+    pollWithTimeout(options, timeoutMs) {
+        return Promise.race([
+            this.poll(options),
+            new Promise((_, reject) => {
+                setTimeout(() => reject(createDeploymentError('Polling timed out', 'TIMEOUT_ERROR')), timeoutMs);
+            }),
+        ]);
+    }
+    async pollBatch(items, checkCondition, options = {}) {
+        const completed = [];
+        const remaining = [...items];
+        while (remaining.length > 0) {
+            const batchPromises = remaining.map(async (item) => {
+                const isComplete = await checkCondition(item);
+                return { item, isComplete };
+            });
+            // eslint-disable-next-line no-await-in-loop
+            const results = await Promise.all(batchPromises);
+            results.forEach(({ item, isComplete }) => {
+                if (isComplete) {
+                    completed.push(item);
+                    const index = remaining.indexOf(item);
+                    if (index > -1) {
+                        remaining.splice(index, 1);
+                    }
+                }
+            });
+            if (remaining.length > 0) {
+                // eslint-disable-next-line no-await-in-loop
+                await timeUtils.sleep(options.interval || this.baseInterval);
+            }
+        }
+        return completed;
+    }
+}
+
+/* eslint-disable import/prefer-default-export */
+/**
+ * Node.js HTTP client implementation
+ * Uses httpUtils and automatically adds Authorization header
+ */
+class NodeHttpClient {
+    constructor(authToken) {
+        this.authToken = authToken;
+    }
+    get(url) {
+        const headers = {};
+        if (this.authToken) {
+            headers.Authorization = `Bearer ${this.authToken}`;
+        }
+        return httpUtils.get(url, headers);
+    }
+    post(url, data) {
+        const headers = {};
+        if (this.authToken) {
+            headers.Authorization = `Bearer ${this.authToken}`;
+        }
+        return httpUtils.post(url, data, headers);
+    }
+}
+
+/* eslint-disable import/prefer-default-export */
+/**
+ * Node.js configuration provider implementation
+ * Gets raw blocklet information from API endpoints
+ */
+class NodeConfigProvider {
+    constructor(config) {
+        this.config = config;
+    }
+    async getBlockletInfo() {
+        if (this.cachedBlockletInfo) {
+            return this.cachedBlockletInfo;
+        }
+        logger.info('Getting blocklet info from baseUrl', { baseUrl: this.config.baseUrl });
+        try {
+            // Try to get info from /__blocklet__.js endpoint
+            const blockletInfoUrl = urlUtils.join(this.config.baseUrl, '__blocklet__.js?type=json');
+            logger.info('Getting blocklet info from __blocklet__.js', { blockletInfoUrl });
+            const response = await httpUtils.get(blockletInfoUrl);
+            if (response.PAYMENT_LINK_ID) {
+                this.cachedBlockletInfo = response;
+                logger.info('Blocklet info found from __blocklet__.js', { hasPaymentLinkId: true });
+                return this.cachedBlockletInfo;
+            }
+            // Fallback to env API if not found in blocklet info
+            const envUrl = urlUtils.join(this.config.baseUrl, 'api/env');
+            const envResponse = await httpUtils.get(envUrl);
+            if (envResponse.PAYMENT_LINK_ID) {
+                this.cachedBlockletInfo = envResponse;
+                logger.info('Blocklet info found from /api/env', { hasPaymentLinkId: true });
+                return this.cachedBlockletInfo;
+            }
+            throw new Error('PAYMENT_LINK_ID not found in any API endpoint');
+        }
+        catch (error) {
+            logger.error('Failed to get blocklet info', { error });
+            throw createDeploymentError(`Failed to get blocklet info from ${this.config.baseUrl}: ${error.message}`, 'VALIDATION_ERROR', {
+                step: 'creating_session',
+                details: { originalError: error },
+                recovery: {
+                    canRetry: true,
+                    suggestions: [
+                        'Check if the baseUrl is correct and accessible',
+                        'Verify the service is running and configured properly',
+                        'Ensure PAYMENT_LINK_ID is set in the environment',
+                    ],
+                },
+            });
+        }
+    }
+}
+
+/* eslint-disable import/prefer-default-export */
+/**
+ * Creates a Node.js specific BrokerClient instance
+ * @param config - Partial configuration for the broker client
+ * @returns Configured BrokerClient instance with Node.js dependencies
+ */
+function createNodeBrokerClient(config) {
+    // Validate required Node.js specific config
+    if (!config.authToken) {
+        throw new Error('authToken is required for Node.js BrokerClient');
+    }
+    const fullConfig = { ...config };
+    // Create HTTP client with auth token
+    const httpClient = new NodeHttpClient(fullConfig.authToken);
+    // Create dependencies for Node.js environment
+    const dependencies = {
+        httpClient,
+        configProvider: new NodeConfigProvider(fullConfig),
+        pollingManager: new PollingManager({
+            baseInterval: fullConfig.polling?.interval || 3000,
+            maxAttempts: fullConfig.polling?.maxAttempts || 100,
+            backoffStrategy: fullConfig.polling?.backoffStrategy || 'linear',
+        }),
+    };
+    return new BrokerClient(fullConfig, dependencies);
+}
+
+exports.API_ENDPOINTS = API_ENDPOINTS;
+exports.BrokerClient = createNodeBrokerClient;
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.DEPLOYMENT_STEPS = DEPLOYMENT_STEPS;
+exports.ERROR_CODES = ERROR_CODES;
+exports.PollingManager = PollingManager;
+exports.STEPS = STEPS;
+exports.createDeploymentError = createDeploymentError;
+exports.httpUtils = httpUtils;
+exports.isDeploymentError = isDeploymentError;
+exports.logger = logger;
+exports.objectUtils = objectUtils;
+exports.timeUtils = timeUtils;
+exports.urlUtils = urlUtils;
+//# sourceMappingURL=index.js.map