@munchi_oy/payments 1.10.6 → 1.11.0

package/dist/src/strategies/sessionResult.d.ts

@@ -1,5 +1,12 @@
-import { type PaymentSessionViewDto } from "@munchi_oy/core";
+import { PaymentSessionStatus, type PaymentSessionViewDto } from "@munchi_oy/core";
 import { type PaymentResult } from "../types/payment";
 export declare function pendingResult(orderId: string): PaymentResult;
 export declare function mapSessionResult(data: PaymentSessionViewDto, orderId: string): PaymentResult;
+export interface ReversalStatusView {
+    status: PaymentSessionStatus;
+    providerTransactionId?: string;
+    errorCode?: string;
+    errorMessage?: string;
+}
+export declare function mapReversalResult(data: ReversalStatusView, orderId: string): PaymentResult;
 //# sourceMappingURL=sessionResult.d.ts.map

package/dist/src/strategies/sessionResult.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessionResult.d.ts","sourceRoot":"","sources":["../../../src/strategies/sessionResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,qBAAqB,EAC3B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,KAAK,aAAa,EAAoB,MAAM,kBAAkB,CAAC;AASxE,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAQ5D;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,MAAM,GACd,aAAa,CA+Df"}
+{"version":3,"file":"sessionResult.d.ts","sourceRoot":"","sources":["../../../src/strategies/sessionResult.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,oBAAoB,EACpB,KAAK,qBAAqB,EAC3B,MAAM,iBAAiB,CAAC;AAGzB,OAAO,EAAE,KAAK,aAAa,EAAoB,MAAM,kBAAkB,CAAC;AASxE,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAQ5D;AAED,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,MAAM,GACd,aAAa,CAgEf;AAED,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,oBAAoB,CAAC;IAC7B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,MAAM,GACd,aAAa,CAgEf"}

package/dist/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "1.10.6";
+export declare const VERSION = "1.11.0";
 //# sourceMappingURL=version.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@munchi_oy/payments",
-  "version": "1.10.6",
+  "version": "1.11.0",
   "description": "Munchi Payments SDK - Payment processing utilities",
   "license": "UNLICENSED",
   "publishConfig": {
@@ -32,7 +32,7 @@
     "@types/jest": "^30.0.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0",
-    "@munchi_oy/core": "1.9.67"
+    "@munchi_oy/core": "1.9.74"
   },
   "scripts": {
     "test": "jest",

package/src/MunchiPaymentSDK.ts

@@ -4,6 +4,7 @@ import { version } from "../package.json";
 import { PaymentErrorCode, PaymentSDKError } from "./error";
 import type { IPaymentStrategy } from "./strategies/IPaymentStrategy";
 import { StrategyExecutionMode } from "./strategies/IPaymentStrategy";
+import { NetsSessionStrategy } from "./strategies/NetsSessionStrategy";
 import { NetsStrategy } from "./strategies/NetsStrategy";
 import { VivaAppToAppStrategy } from "./strategies/VivaAppToAppStrategy";
 import { VivaSessionStrategy } from "./strategies/VivaSessionStrategy";
@@ -56,6 +57,8 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
     ...MunchiPaymentSDK.TERMINAL_STATES,
   ];
 
+  private static readonly CANCEL_VERIFY_TIMEOUT_MS = 5000;
+
   constructor(
     axios: AxiosInstance,
     messaging: IMessagingAdapter,
@@ -197,6 +200,9 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
   private resolveStrategy(config: PaymentTerminalConfig): IPaymentStrategy {
     switch (config.provider) {
       case PaymentProvider.Nets:
+        if (this.paymentSessionConfig?.enabled) {
+          return new NetsSessionStrategy(this.axios, this.messaging, config);
+        }
         return new NetsStrategy(this.axios, this.messaging, config);
       case PaymentProvider.Worldline:
         return new WorldlineStrategy(this.axios, this.messaging, config);
@@ -343,10 +349,14 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
 
     if (this._cancellationIntent) {
       try {
-        if (this._currentSessionId) {
+        if (
+          this._currentSessionId &&
+          (this.strategy.shouldVerifyAfterCancel?.() ?? true)
+        ) {
           const finalStatus = await this.strategy.verifyFinalStatus(
             params,
             this._currentSessionId,
+            MunchiPaymentSDK.CANCEL_VERIFY_TIMEOUT_MS,
           );
           if (finalStatus.success) {
             this.transitionTo(PaymentInteractionState.SUCCESS);
@@ -689,7 +699,15 @@ export class MunchiPaymentSDK implements IMunchiPaymentSDK {
     this.transitionTo(PaymentInteractionState.CONNECTING);
 
     try {
-      const result = await revertTransaction(params);
+      const result = await revertTransaction(params, (state, detail) => {
+        if (detail?.sessionId) {
+          this._currentSessionId = detail.sessionId;
+        }
+        if (state !== PaymentInteractionState.FAILED) {
+          this.transitionTo(state);
+          this.fireStateCallback(state, callbacks, params.orderRef);
+        }
+      });
       this.settleSingleShot(result, params.orderRef, callbacks);
       return result;
     } catch (error) {

package/src/strategies/IPaymentStrategy.ts

@@ -13,6 +13,7 @@ export enum StrategyExecutionMode {
 
 export interface IPaymentStrategy {
   getExecutionMode?(): StrategyExecutionMode;
+  shouldVerifyAfterCancel?(): boolean;
 
   processPayment(
     request: PaymentRequest,
@@ -25,7 +26,17 @@ export interface IPaymentStrategy {
     request: RefundRequest,
     onStateChange: (state: PaymentInteractionState, detail?: { sessionId?: string }) => void,
   ): Promise<PaymentResult>;
-  verifyFinalStatus(request: PaymentRequest, sessionId: string): Promise<PaymentResult>;
-  revertTransaction?(request: RevertRequest): Promise<PaymentResult>;
+  verifyFinalStatus(
+    request: PaymentRequest,
+    sessionId: string,
+    timeoutMs?: number,
+  ): Promise<PaymentResult>;
+  revertTransaction?(
+    request: RevertRequest,
+    onStateChange?: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult>;
   abort(): void;
 }

package/src/strategies/NetsSessionStrategy.ts

@@ -0,0 +1,448 @@
+import {
+  type InitiateNetsSessionDto,
+  PaymentEventType,
+  PaymentSessionApi,
+  type PaymentSessionViewDto,
+  type PaymentStatusDto,
+  type ReverseSessionDto,
+  SimplePaymentStatus,
+  type TransactionDto,
+} from "@munchi_oy/core";
+import type { AxiosInstance } from "axios";
+
+import { PaymentErrorCode, PaymentSDKError } from "../error";
+import {
+  type IMessagingAdapter,
+  PaymentInteractionState as InteractionState,
+  type PaymentInteractionState,
+  type PaymentRequest,
+  type PaymentResult,
+  type PaymentTerminalConfig,
+  type RefundRequest,
+  type RevertRequest,
+  SdkPaymentStatus,
+} from "../types/payment";
+import type { IPaymentStrategy } from "./IPaymentStrategy";
+import {
+  mapReversalResult,
+  mapSessionResult,
+  pendingResult,
+  type ReversalStatusView,
+} from "./sessionResult";
+
+export class NetsSessionStrategy implements IPaymentStrategy {
+  private static readonly POLLING_DURATION_MS = 180000;
+  private static readonly POLLING_INTERVAL_MS = 1000;
+  private static readonly VERIFY_DURATION_MS = 30000;
+  private static readonly INITIAL_POLL_DELAY_MS = 10000;
+
+  private sessionApi: PaymentSessionApi;
+  private abortController: AbortController | null = null;
+  private idempotencyKey: string | null = null;
+  private idempotencyOrderRef: string | null = null;
+  private currentClientToken: string | null = null;
+
+  constructor(
+    axios: AxiosInstance,
+    private messaging: IMessagingAdapter,
+    private config: PaymentTerminalConfig,
+  ) {
+    this.sessionApi = new PaymentSessionApi(undefined, "", axios);
+  }
+
+  async processPayment(
+    request: PaymentRequest,
+    onStateChange: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult> {
+    this.abortController = new AbortController();
+    if (
+      this.idempotencyKey === null ||
+      this.idempotencyOrderRef !== request.orderRef
+    ) {
+      this.idempotencyKey = this.generateIdempotencyKey();
+      this.idempotencyOrderRef = request.orderRef;
+    }
+    this.currentClientToken = null;
+
+    onStateChange(InteractionState.CONNECTING);
+
+    const payload: InitiateNetsSessionDto = {
+      amount: request.amountCents,
+      businessId: Number(this.config.storeId),
+      orderId: request.orderRef,
+    };
+    if (request.splitContext !== undefined) {
+      payload.splitContext = request.splitContext;
+    }
+
+    try {
+      const { data } = await this.sessionApi.initiateNetsSession(
+        payload,
+        this.idempotencyKey,
+      );
+      this.currentClientToken = data.clientToken;
+      const signal = this.abortController.signal;
+
+      if (signal.aborted) {
+        throw new Error("Aborted");
+      }
+
+      onStateChange(InteractionState.REQUIRES_INPUT, {
+        sessionId: data.sessionId,
+      });
+
+      const terminal = await this.waitForCompletion(
+        data.clientToken,
+        data.sessionId,
+        request,
+        signal,
+      );
+
+      if (terminal) {
+        return this.finalize(terminal);
+      }
+
+      await this.armCancel(data.clientToken);
+      return pendingResult(request.orderRef);
+    } catch (err) {
+      if (err instanceof PaymentSDKError) throw err;
+      throw new PaymentSDKError(
+        PaymentErrorCode.TERMINAL_BUSY,
+        "Failed to create Nets payment session",
+        err,
+      );
+    }
+  }
+
+  async verifyFinalStatus(
+    request: PaymentRequest,
+    _sessionId: string,
+    timeoutMs?: number,
+  ): Promise<PaymentResult> {
+    if (!this.currentClientToken) {
+      throw new PaymentSDKError(
+        PaymentErrorCode.NETWORK_ERROR,
+        "No active payment session to verify",
+      );
+    }
+
+    const terminal = await this.pollUntilTerminal(
+      this.currentClientToken,
+      request.orderRef,
+      undefined,
+      timeoutMs ?? NetsSessionStrategy.VERIFY_DURATION_MS,
+    );
+
+    return this.finalize(terminal ?? pendingResult(request.orderRef));
+  }
+
+  async cancelTransaction(
+    _onStateChange: (state: PaymentInteractionState) => void,
+  ): Promise<boolean> {
+    if (!this.currentClientToken) {
+      return false;
+    }
+
+    try {
+      await this.sessionApi.cancelSession(this.currentClientToken);
+    } catch (error) {
+      throw new PaymentSDKError(
+        PaymentErrorCode.NETWORK_ERROR,
+        "Failed to cancel Nets payment session",
+        error,
+      );
+    }
+
+    this.abortController?.abort();
+    this.resetIdempotencyKey();
+    return true;
+  }
+
+  async refundTransaction(
+    request: RefundRequest,
+    onStateChange: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult> {
+    this.abortController = new AbortController();
+    onStateChange(InteractionState.CONNECTING);
+
+    const payload: ReverseSessionDto = {
+      sessionId: request.originalTransactionId,
+      amount: request.amountCents,
+    };
+
+    try {
+      const { data } = await this.sessionApi.refundNetsSession(payload);
+      return await this.settleReversal(
+        data,
+        request.orderRef,
+        this.abortController.signal,
+        true,
+        onStateChange,
+      );
+    } catch (error) {
+      if (error instanceof PaymentSDKError) throw error;
+      throw new PaymentSDKError(
+        PaymentErrorCode.NETWORK_ERROR,
+        "Failed to refund Nets transaction",
+        error,
+      );
+    }
+  }
+
+  async revertTransaction(
+    request: RevertRequest,
+    onStateChange?: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult> {
+    this.abortController = new AbortController();
+
+    const payload: ReverseSessionDto = {
+      sessionId: request.originalTransactionId,
+    };
+
+    try {
+      const { data } = await this.sessionApi.revertNetsSession(payload);
+      return await this.settleReversal(
+        data,
+        request.orderRef,
+        this.abortController.signal,
+        data.requiresCardTap,
+        onStateChange,
+      );
+    } catch (error) {
+      if (error instanceof PaymentSDKError) throw error;
+      throw new PaymentSDKError(
+        PaymentErrorCode.NETWORK_ERROR,
+        "Failed to revert Nets transaction",
+        error,
+      );
+    }
+  }
+
+  shouldVerifyAfterCancel(): boolean {
+    return false;
+  }
+
+  abort(): void {
+    this.abortController?.abort();
+  }
+
+  private async settleReversal(
+    view: ReversalStatusView & { clientToken: string; sessionId: string },
+    orderRef: string,
+    signal: AbortSignal,
+    requiresCardTap: boolean,
+    onStateChange?: (
+      state: PaymentInteractionState,
+      detail?: { sessionId?: string },
+    ) => void,
+  ): Promise<PaymentResult> {
+    const immediate = mapReversalResult(view, orderRef);
+    if (immediate.status !== SdkPaymentStatus.PENDING) {
+      return immediate;
+    }
+
+    if (requiresCardTap) {
+      onStateChange?.(InteractionState.REQUIRES_INPUT, {
+        sessionId: view.sessionId,
+      });
+    }
+
+    const terminal = await this.pollUntilTerminal(
+      view.clientToken,
+      orderRef,
+      signal,
+      NetsSessionStrategy.POLLING_DURATION_MS,
+      mapReversalResult,
+    );
+
+    return terminal ?? pendingResult(orderRef);
+  }
+
+  private async pollUntilTerminal(
+    clientToken: string,
+    orderRef: string,
+    signal: AbortSignal | undefined,
+    durationMs: number,
+    map: (
+      data: PaymentSessionViewDto,
+      orderId: string,
+    ) => PaymentResult = mapSessionResult,
+  ): Promise<PaymentResult | undefined> {
+    const deadline = Date.now() + durationMs;
+
+    while (Date.now() < deadline) {
+      if (signal?.aborted) {
+        throw new Error("Aborted");
+      }
+
+      let data: PaymentSessionViewDto | undefined;
+      try {
+        data = (await this.sessionApi.getPaymentSession(clientToken)).data;
+      } catch (error) {
+        if (error instanceof Error && error.message === "Aborted") throw error;
+      }
+
+      if (signal?.aborted) {
+        throw new Error("Aborted");
+      }
+
+      if (data) {
+        const result = map(data, orderRef);
+        if (result.status !== SdkPaymentStatus.PENDING) {
+          return result;
+        }
+      }
+
+      await this.delay(NetsSessionStrategy.POLLING_INTERVAL_MS, signal);
+    }
+
+    return undefined;
+  }
+
+  private waitForCompletion(
+    clientToken: string,
+    sessionId: string,
+    request: PaymentRequest,
+    signal: AbortSignal,
+  ): Promise<PaymentResult | undefined> {
+    const channelName = `nets.requests.${sessionId}`;
+
+    return new Promise((resolve, reject) => {
+      let settled = false;
+
+      const cleanup = () => {
+        settled = true;
+        if (typeof unsubscribe === "function") unsubscribe();
+        clearTimeout(pollTimer);
+        signal.removeEventListener("abort", onAbort);
+      };
+
+      const onAbort = () => {
+        cleanup();
+        reject(new Error("Aborted"));
+      };
+      signal.addEventListener("abort", onAbort);
+
+      const unsubscribe = this.messaging.subscribe<PaymentStatusDto>(
+        channelName,
+        PaymentEventType.StatusChanged,
+        (data: PaymentStatusDto) => {
+          if (settled) return;
+          if (data.status === SimplePaymentStatus.Pending) return;
+          cleanup();
+          resolve(this.mapStatusDto(data, request));
+        },
+      );
+
+      const pollTimer = setTimeout(() => {
+        if (settled) return;
+        this.pollUntilTerminal(
+          clientToken,
+          request.orderRef,
+          signal,
+          NetsSessionStrategy.POLLING_DURATION_MS,
+        ).then(
+          (result) => {
+            if (settled) return;
+            cleanup();
+            resolve(result);
+          },
+          (error) => {
+            if (settled) return;
+            cleanup();
+            reject(error);
+          },
+        );
+      }, NetsSessionStrategy.INITIAL_POLL_DELAY_MS);
+    });
+  }
+
+  private mapStatusDto(
+    data: PaymentStatusDto,
+    request: PaymentRequest,
+  ): PaymentResult {
+    const isSuccess = data.status === SimplePaymentStatus.Success;
+
+    const result: PaymentResult = {
+      success: isSuccess,
+      status: isSuccess ? SdkPaymentStatus.SUCCESS : SdkPaymentStatus.FAILED,
+      orderId: request.orderRef,
+    };
+
+    if (data.transactionId) {
+      result.transactionId = data.transactionId;
+    }
+    if (data.transaction) {
+      result.transaction = data.transaction as unknown as TransactionDto;
+    }
+    if (data.error?.code) {
+      result.errorCode = data.error.code;
+    }
+    if (data.error?.message) {
+      result.errorMessage = data.error.message;
+    }
+
+    return result;
+  }
+
+  private finalize(result: PaymentResult): PaymentResult {
+    if (result.status !== SdkPaymentStatus.PENDING) {
+      this.resetIdempotencyKey();
+    }
+    return result;
+  }
+
+  private resetIdempotencyKey(): void {
+    this.idempotencyKey = null;
+    this.idempotencyOrderRef = null;
+  }
+
+  private armCancel(clientToken: string): Promise<void> {
+    return this.sessionApi.cancelSession(clientToken).then(
+      () => undefined,
+      () => undefined,
+    );
+  }
+
+  private generateIdempotencyKey(): string {
+    const cryptoRef = (globalThis as { crypto?: { randomUUID?: () => string } })
+      .crypto;
+
+    if (cryptoRef?.randomUUID) {
+      return cryptoRef.randomUUID();
+    }
+
+    return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (char) => {
+      const random = (Math.random() * 16) | 0;
+      const value = char === "x" ? random : (random & 0x3) | 0x8;
+      return value.toString(16);
+    });
+  }
+
+  private delay(ms: number, signal?: AbortSignal): Promise<void> {
+    return new Promise((resolve) => {
+      const onAbort = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+      if (signal) {
+        signal.addEventListener("abort", onAbort, { once: true });
+      }
+      const timeout = setTimeout(() => {
+        if (signal) {
+          signal.removeEventListener("abort", onAbort);
+        }
+        resolve();
+      }, ms);
+    });
+  }
+}

package/src/strategies/VivaSessionStrategy.ts

@@ -111,6 +111,7 @@ export class VivaSessionStrategy implements IPaymentStrategy {
   async verifyFinalStatus(
     request: PaymentRequest,
     _sessionId: string,
+    timeoutMs?: number,
   ): Promise<PaymentResult> {
     if (!this.currentClientToken) {
       throw new PaymentSDKError(
@@ -123,7 +124,7 @@ export class VivaSessionStrategy implements IPaymentStrategy {
       this.currentClientToken,
       request,
       undefined,
-      VivaSessionStrategy.VERIFY_DURATION_MS,
+      timeoutMs ?? VivaSessionStrategy.VERIFY_DURATION_MS,
     );
 
     return this.finalize(terminal ?? pendingResult(request.orderRef));
@@ -137,7 +138,7 @@ export class VivaSessionStrategy implements IPaymentStrategy {
     }
 
     try {
-      await this.sessionApi.cancelVivaSession(this.currentClientToken);
+      await this.sessionApi.cancelSession(this.currentClientToken);
     } catch (error) {
       throw new PaymentSDKError(
         PaymentErrorCode.NETWORK_ERROR,
@@ -147,6 +148,7 @@ export class VivaSessionStrategy implements IPaymentStrategy {
     }
 
     this.abortController?.abort();
+    this.resetIdempotencyKey();
     return true;
   }
 
@@ -353,14 +355,18 @@ export class VivaSessionStrategy implements IPaymentStrategy {
 
   private finalize(result: PaymentResult): PaymentResult {
     if (result.status !== SdkPaymentStatus.PENDING) {
-      this.idempotencyKey = null;
-      this.idempotencyOrderRef = null;
+      this.resetIdempotencyKey();
     }
     return result;
   }
 
+  private resetIdempotencyKey(): void {
+    this.idempotencyKey = null;
+    this.idempotencyOrderRef = null;
+  }
+
   private armCancel(clientToken: string): Promise<void> {
-    return this.sessionApi.cancelVivaSession(clientToken).then(
+    return this.sessionApi.cancelSession(clientToken).then(
       () => undefined,
       () => undefined,
     );