@munchi_oy/payments 1.4.8 → 1.5.0

package/src/MunchiPaymentSDK.ts

@@ -3,7 +3,9 @@ import type { AxiosInstance } from "axios";
 import { version } from "../package.json";
 import { PaymentErrorCode, PaymentSDKError } from "./error";
 import type { IPaymentStrategy } from "./strategies/IPaymentStrategy";
+import { StrategyExecutionMode } from "./strategies/IPaymentStrategy";
 import { NetsStrategy } from "./strategies/NetsStrategy";
+import { VivaAppToAppStrategy } from "./strategies/VivaAppToAppStrategy";
 import { VivaStrategy } from "./strategies/VivaStrategy";
 import { WorldlineStrategy } from "./strategies/WorldlineStrategy";
 import {
@@ -17,7 +19,7 @@ import {
   SdkPaymentStatus,
   type TransactionOptions,
 } from "./types/payment";
-import type { ILogger, SDKOptions } from "./types/sdk";
+import type { AppToAppConfig, ILogger, SDKOptions } from "./types/sdk";
 
 type StateListener = (state: PaymentInteractionState) => void;
 
@@ -33,6 +35,7 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
   private _currentSessionId: string | undefined;
   private _autoResetTimer: ReturnType<typeof setTimeout> | undefined;
   private autoResetOptions: SDKOptions["autoResetOnPaymentComplete"];
+  private appToAppConfig: AppToAppConfig | undefined;
 
   private static readonly TERMINAL_STATES = [
     PaymentInteractionState.SUCCESS,
@@ -57,6 +60,7 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
     this.logger = options.logger;
     this.timeoutMs = options.timeoutMs || 30000;
     this.autoResetOptions = options.autoResetOnPaymentComplete;
+    this.appToAppConfig = options.appToApp;
     this.strategy = strategy ?? this.resolveStrategy(config);
   }
 
@@ -187,6 +191,16 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
         return new NetsStrategy(this.axios, this.messaging, config);
       case PaymentProvider.Worldline:
         return new WorldlineStrategy(this.axios, this.messaging, config);
+      case PaymentProvider.Viva:
+        if (this.appToAppConfig?.enabled) {
+          return new VivaAppToAppStrategy(
+            this.axios,
+            this.messaging,
+            config,
+            this.appToAppConfig,
+          );
+        }
+        return new VivaStrategy(this.axios, this.messaging, config);
 
       default:
         return new VivaStrategy(this.axios, this.messaging, config);
@@ -245,19 +259,25 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
         params,
         internalStateCallback,
       );
-
-      const timeoutPromise = new Promise<never>((_, reject) => {
-        setTimeout(() => {
-          reject(
-            new PaymentSDKError(
-              PaymentErrorCode.TIMEOUT,
-              "Transaction timed out",
-            ),
-          );
-        }, this.timeoutMs);
-      });
-
-      const result = await Promise.race([transactionPromise, timeoutPromise]);
+      const executionMode =
+        this.strategy.getExecutionMode?.() ?? StrategyExecutionMode.Managed;
+
+      const result =
+        executionMode === StrategyExecutionMode.CallbackDriven
+          ? await transactionPromise
+          : await Promise.race([
+              transactionPromise,
+              new Promise<never>((_, reject) => {
+                setTimeout(() => {
+                  reject(
+                    new PaymentSDKError(
+                      PaymentErrorCode.TIMEOUT,
+                      "Transaction timed out",
+                    ),
+                  );
+                }, this.timeoutMs);
+              }),
+            ]);
 
       if (result.success) {
         this.transitionTo(PaymentInteractionState.SUCCESS);
@@ -551,6 +571,7 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
     this.logger?.info("Initiating refund", { orderRef: params.orderRef });
     // Clear any stale session before starting a new refund flow.
     this._currentSessionId = undefined;
+    this._cancellationIntent = false;
 
     // Ensure we are in a valid state to start a refund
     const isRestingState = MunchiPaymentSDK.RESTING_STATES.includes(
@@ -589,6 +610,17 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
       if (result.success) {
         this.transitionTo(PaymentInteractionState.SUCCESS);
         this.safeFireCallback(() => callbacks.onSuccess?.(result));
+      } else if (
+        this._cancellationIntent ||
+        result.status === SdkPaymentStatus.CANCELLED
+      ) {
+        this.transitionTo(PaymentInteractionState.FAILED);
+        this.safeFireCallback(() =>
+          callbacks.onCancelled?.({
+            orderRef: params.orderRef,
+            refPaymentId: this._currentSessionId,
+          }),
+        );
       } else {
         this.transitionTo(PaymentInteractionState.FAILED);
         this.safeFireCallback(() => callbacks.onError?.(result));
@@ -602,6 +634,61 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
     } catch (error) {
       this.logger?.error("Refund failed", error);
 
+      if (this._cancellationIntent) {
+        try {
+          if (this._currentSessionId) {
+            const finalStatus = await this.verifyWithRetry(
+              params,
+              this._currentSessionId,
+            );
+
+            if (finalStatus.success) {
+              this.transitionTo(PaymentInteractionState.SUCCESS);
+              this.safeFireCallback(() => callbacks.onSuccess?.(finalStatus));
+              return finalStatus;
+            }
+
+            if (finalStatus.status === SdkPaymentStatus.CANCELLED) {
+              this.transitionTo(PaymentInteractionState.FAILED);
+              this.safeFireCallback(() =>
+                callbacks.onCancelled?.({
+                  orderRef: params.orderRef,
+                  refPaymentId: this._currentSessionId,
+                }),
+              );
+              return finalStatus;
+            }
+
+            this.transitionTo(PaymentInteractionState.FAILED);
+            this.safeFireCallback(() => callbacks.onError?.(finalStatus));
+            return finalStatus;
+          }
+        } catch (verifyError) {
+          this.logger?.warn("Refund final status verification failed", {
+            verifyError,
+          });
+        }
+
+        this.transitionTo(PaymentInteractionState.FAILED);
+
+        this.safeFireCallback(() =>
+          callbacks.onCancelled?.({
+            orderRef: params.orderRef,
+            refPaymentId: this._currentSessionId,
+          }),
+        );
+
+        return {
+          success: false,
+          status: SdkPaymentStatus.CANCELLED,
+          errorCode: this.normalizeErrorCode(PaymentErrorCode.CANCELLED),
+          orderId: params.orderRef,
+          ...(this._currentSessionId
+            ? { transactionId: this._currentSessionId }
+            : {}),
+        };
+      }
+
       this.transitionTo(PaymentInteractionState.FAILED);
 
       const errorResult = this.generateErrorResult(

package/src/strategies/IPaymentStrategy.ts

@@ -5,7 +5,13 @@ import type {
   RefundRequest,
 } from "../types/payment";
 
+export enum StrategyExecutionMode {
+  Managed = "managed",
+  CallbackDriven = "callback_driven",
+}
+
 export interface IPaymentStrategy {
+  getExecutionMode?(): StrategyExecutionMode;
 
   processPayment(
     request: PaymentRequest,