@commercetools/connect-payments-sdk 0.27.0 → 0.27.2

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @commercetools/connect-payments-sdk
 
+## 0.27.2
+
+### Patch Changes
+
+- d66f007: fix(payments): correct retry mechanism and add exponential backoff to payment updates
+
+## 0.27.1
+
+### Patch Changes
+
+- 7bfd391: Fix issue calling the recurring payment jobs API
+
 ## 0.27.0
 
 ### Minor Changes

package/dist/commercetools/services/ct-payment.service.d.ts

@@ -19,6 +19,17 @@ export declare class DefaultPaymentService implements PaymentService {
     findPaymentsByInterfaceId(opts: FindPaymentsByInterfaceId): Promise<Payment[]>;
     createPayment(draft: PaymentDraft): Promise<Payment>;
     updatePayment(opts: UpdatePayment): Promise<Payment>;
+    /**
+     * Calculates exponential backoff delay with jitter
+     * @param attempt - Current attempt number (0-based)
+     * @returns Delay in milliseconds
+     */
+    private calculateExponentialBackoff;
+    /**
+     * Sleep for a specified duration
+     * @param ms - Duration in milliseconds
+     */
+    private sleep;
     private consolidateUpdateActions;
     private populateSetInterfaceIdAction;
     private populateChangeTransactionInteractionId;

package/dist/commercetools/services/ct-payment.service.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DefaultPaymentService = void 0;
 const ct_api_error_1 = require("../errors/ct-api.error");
+const node_crypto_1 = require("node:crypto");
 /**
  * This is the default implementation of the PaymentService interface.
  */
@@ -24,40 +25,60 @@ class DefaultPaymentService {
     }
     async updatePayment(opts) {
         const maxRetries = 3;
-        let err;
-        for (let retries = 0; retries < maxRetries; retries++) {
+        let lastError;
+        for (let attempt = 0; attempt < maxRetries; attempt++) {
             const payment = await this.getPayment({ id: opts.id });
             const actions = this.consolidateUpdateActions(payment, opts);
-            this.logger.info({ paymentId: payment.id, paymentVersion: payment.version, actions, retries }, 'Updating payment with actions');
+            this.logger.info({ paymentId: payment.id, paymentVersion: payment.version, actions, attempt }, 'Updating payment with actions');
             if (actions.length === 0) {
-                this.logger.info({ paymentId: payment.id, paymentVersion: payment.version, retries }, 'Update payment skipped, no actions to perform');
+                this.logger.info({ paymentId: payment.id, paymentVersion: payment.version, attempt }, 'Update payment skipped, no actions to perform');
                 return payment;
             }
             try {
-                const updatedPayment = await this.ctAPI.payment.updatePayment({
+                return await this.ctAPI.payment.updatePayment({
                     resource: {
                         id: payment.id,
                         version: payment.version,
                     },
                     actions,
                 });
-                return updatedPayment;
             }
             catch (e) {
-                err = e;
-                if (e instanceof ct_api_error_1.CommercetoolsAPIError &&
+                lastError = e;
+                const isRetryableError = e instanceof ct_api_error_1.CommercetoolsAPIError &&
                     (e.httpErrorStatus === 409 ||
-                        (e.httpErrorStatus === 400 && e.message.includes('already used without setting a payment interface')))) {
-                    this.logger.warn({ paymentId: payment.id, paymentVersion: payment.version, retries, err }, 'Unable to update the payment, retrying');
-                    retries++;
-                }
-                else {
-                    this.logger.error({ paymentId: payment.id, paymentVersion: payment.version, retries, err }, 'Unable to update the payment, abort');
-                    throw e;
+                        (e.httpErrorStatus === 400 && e.message.includes('already used without setting a payment interface')));
+                if (isRetryableError && attempt < maxRetries - 1) {
+                    const delayMs = this.calculateExponentialBackoff(attempt);
+                    this.logger.warn({ paymentId: payment.id, paymentVersion: payment.version, attempt, delayMs, err: e }, 'Unable to update the payment, retrying');
+                    await this.sleep(delayMs);
+                    continue;
                 }
+                this.logger.error({ paymentId: payment.id, paymentVersion: payment.version, attempt, err: e }, 'Unable to update the payment, abort');
+                throw e;
             }
         }
-        throw err;
+        throw lastError;
+    }
+    /**
+     * Calculates exponential backoff delay with jitter
+     * @param attempt - Current attempt number (0-based)
+     * @returns Delay in milliseconds
+     */
+    calculateExponentialBackoff(attempt) {
+        const baseDelayMs = 100;
+        const maxDelayMs = 2000;
+        const jitterMs = 100;
+        const exponentialDelay = baseDelayMs * Math.pow(2, attempt);
+        const jitter = (0, node_crypto_1.randomInt)(0, jitterMs);
+        return Math.min(exponentialDelay + jitter, maxDelayMs);
+    }
+    /**
+     * Sleep for a specified duration
+     * @param ms - Duration in milliseconds
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
     }
     consolidateUpdateActions(payment, updateInfo) {
         const actions = [];

package/dist/commercetools/services/ct-recurring-payment-job.service.d.ts

@@ -1,15 +1,19 @@
 import { Logger } from '../..';
+import { AuthorizationService } from '../types/authorization.type';
 import { RecurringPaymentJob, RecurringPaymentJobDraft, RecurringPaymentJobService } from '../types/recurring-payment-job.type';
 import { DefaultCartService } from './ct-cart.service';
 /**
  * Default implementation of the RecurringPaymentJobService interface.
  */
 export declare class DefaultRecurringPaymentJobService implements RecurringPaymentJobService {
+    private authorizationService;
     private ctCartService;
     private checkoutUrl;
     private projectKey;
     private logger;
+    private token;
     constructor(opts: {
+        authorizationService: AuthorizationService;
         ctCartService: DefaultCartService;
         checkoutUrl: string;
         projectKey: string;
@@ -51,5 +55,9 @@ export declare class DefaultRecurringPaymentJobService implements RecurringPayme
      * Internal method that performs the HTTP request to create a recurring payment job.
      */
     private internalCreateRecurringPaymentJob;
+    /**
+     * Performs a fetch request with automatic token refresh on 401/403 errors.
+     */
+    private fetchWithTokenRetry;
     private safeParseErrorResponse;
 }

package/dist/commercetools/services/ct-recurring-payment-job.service.js

@@ -6,11 +6,14 @@ const errorx_1 = require("../../errorx/errorx");
  * Default implementation of the RecurringPaymentJobService interface.
  */
 class DefaultRecurringPaymentJobService {
+    authorizationService;
     ctCartService;
     checkoutUrl;
     projectKey;
     logger;
+    token;
     constructor(opts) {
+        this.authorizationService = opts.authorizationService;
         this.ctCartService = opts.ctCartService;
         this.checkoutUrl = opts.checkoutUrl;
         this.projectKey = opts.projectKey;
@@ -75,11 +78,8 @@ class DefaultRecurringPaymentJobService {
                 state: 'Initial',
             },
         };
-        const response = await fetch(url, {
+        const response = await this.fetchWithTokenRetry(url, {
             method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-            },
             body: JSON.stringify(payload),
         });
         if (!response.ok) {
@@ -94,6 +94,35 @@ class DefaultRecurringPaymentJobService {
         }
         return (await response.json());
     }
+    /**
+     * Performs a fetch request with automatic token refresh on 401/403 errors.
+     */
+    async fetchWithTokenRetry(url, options) {
+        if (!this.token) {
+            this.token = await this.authorizationService.getAccessToken();
+        }
+        let response = await fetch(url, {
+            ...options,
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.token.access_token}`,
+                ...options.headers,
+            },
+        });
+        // If commercetools oauth token is expired, get a new one and retry once
+        if (response.status === 401 || response.status === 403) {
+            this.token = await this.authorizationService.getAccessToken();
+            response = await fetch(url, {
+                ...options,
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${this.token.access_token}`,
+                    ...options.headers,
+                },
+            });
+        }
+        return response;
+    }
     async safeParseErrorResponse(response) {
         try {
             return await response.json();

package/dist/index.js

@@ -71,6 +71,7 @@ const setupPaymentSDK = (opts) => {
     const ctPaymentMethodService = new ct_payment_method_service_1.DefaultPaymentMethodService({ ctAPI, logger });
     const ctCustomTypeService = new ct_custom_type_service_1.DefaultCustomTypeService({ ctAPI, logger });
     const ctRecurringPaymentJobService = new ct_recurring_payment_job_service_1.DefaultRecurringPaymentJobService({
+        authorizationService: ctAuthorizationService,
         ctCartService,
         checkoutUrl: opts.checkoutUrl,
         projectKey: opts.projectKey,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commercetools/connect-payments-sdk",
-  "version": "0.27.0",
+  "version": "0.27.2",
   "description": "Payment SDK for commercetools payment connectors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",