@tonder.io/ionic-full-sdk 0.0.62-beta.DEV-2106.1 → 0.0.62-beta.DEV-2106.99e3729

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tonder.io/ionic-full-sdk",
-  "version": "0.0.62-beta.DEV-2106.1",
+  "version": "0.0.62-beta.DEV-2106.99e3729",
   "description": "Tonder ionic full SDK",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,7 +10,7 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@tonder.io/ionic-lite-sdk": "0.0.68-beta.DEV-2106.1",
+    "@tonder.io/ionic-lite-sdk": "0.0.68-beta.DEV-2106.48d18dd",
     "accordion-js": "^3.4.0",
     "crypto-js": "^4.1.1",
     "lodash.get": "^4.4.2",

package/rollup.config.js

@@ -6,7 +6,8 @@ const packageJson = require('./package.json');
 
 module.exports = {
   input: './src/index.ts',
-  output: {
+  output:
+  {
     dir: 'dist',
     format: 'es',
     plugins: [terser()]

package/src/classes/inlineCheckout.ts

@@ -5,7 +5,6 @@ import {
   mapCards,
 } from '../helpers/utils';
 import {initSkyflow, initUpdateSkyflow} from '../helpers/skyflow'
-import { ErrorResponse } from '@tonder.io/ionic-lite-sdk/dist/classes/errorResponse';
 import { CustomerRegisterResponse } from '@tonder.io/ionic-lite-sdk/dist/types/responses';
 import { BaseInlineCheckout } from "@tonder.io/ionic-lite-sdk";
 import {IProcessPaymentRequest} from "@tonder.io/ionic-lite-sdk/dist/types/checkout";
@@ -17,6 +16,7 @@ import {IInlineCheckout} from "../types/inlineCheckout";
 import { buildPublicAppError } from "../shared/utils/appError";
 import { ErrorKeyEnum } from "../shared/enums/ErrorKeyEnum";
 import { MESSAGES_EN, MESSAGES_ES } from "../shared/constants/messages";
+import { SDK_INFO } from "../helpers/sdkInfo";
 import get from "lodash.get";
 // @ts-ignore
 import Accordion from "accordion-js";
@@ -66,15 +66,18 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
     customization,
     events
   }: IInlineCheckoutOptions) {
-    super({
+    const baseOptions = {
       apiKey: apiKey,
       returnUrl: returnUrl,
       mode: mode,
       callBack: callBack,
       customization: customization,
       tdsIframeId: collectorIds && 'tdsIframe' in collectorIds ? collectorIds?.tdsIframe : "tdsIframe",
-      tonderPayButtonId: collectorIds ? collectorIds?.tonderPayButton : "tonderPayButton"
-    });
+      tonderPayButtonId: collectorIds ? collectorIds?.tonderPayButton : "tonderPayButton",
+      sdkInfo: SDK_INFO,
+    };
+    super(baseOptions);
+
     this.renderPaymentButton = renderPaymentButton || false;
     this.renderSaveCardButton = renderSaveCardButton;
     this.customStyles = styles
@@ -397,8 +400,8 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
   async #handlePaymentClick() {
     try {
       await this.payment({} as IProcessPaymentRequest);
-    } catch (error) {
-      console.error("Payment error:", error);
+    } catch (error: any) {
+      console.error("Payment error:", error?.message, error?.code, error?.details);
     }
   }
 
@@ -688,7 +691,7 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
       try{
         if(this.merchantData!) {
           const cardTokensSkyflowTonder: any = await this.#getCardTokens(this.collectorIds.tonderSaveCardButton!);
-          const customerResponse : CustomerRegisterResponse | ErrorResponse = await this._getCustomer() as CustomerRegisterResponse;
+          const customerResponse : CustomerRegisterResponse = await this._getCustomer() as CustomerRegisterResponse;
 
           if("auth_token" in customerResponse && this.secureToken) {
             // @ts-ignore
@@ -736,6 +739,7 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
                 throw buildPublicAppError(
                   {
                     errorCode: ErrorKeyEnum.CARD_ON_FILE_DECLINED,
+                    lockErrorCode: true,
                     message: MESSAGES_EN[ErrorKeyEnum.CARD_ON_FILE_DECLINED],
                   },
                   processError,
@@ -841,9 +845,18 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
                   currency: this.currency || 'MXN',
               });
           } catch (processError) {
+            console.error("Error processing card-on-file payment=====", processError);
+            this.reportSdkError(processError, {
+              feature: "payment",
+              process_id: cardId,
+              metadata: {
+                step: "#processCardOnFilePayment_cardOnFile.process",
+              },
+            });
               throw buildPublicAppError(
                   {
                       errorCode: ErrorKeyEnum.CARD_ON_FILE_DECLINED,
+                      lockErrorCode: true,
                       message: MESSAGES_EN[ErrorKeyEnum.CARD_ON_FILE_DECLINED],
                       details: {
                           cardId,
@@ -871,11 +884,13 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
             process_id: cardId,
             metadata: {
               step: "#processCardOnFilePayment",
+              error,
             },
           });
           throw buildPublicAppError(
             {
               errorCode: ErrorKeyEnum.CARD_ON_FILE_DECLINED,
+              lockErrorCode: true,
               message: MESSAGES_EN[ErrorKeyEnum.CARD_ON_FILE_DECLINED],
               details: {
                 cardId,
@@ -966,18 +981,16 @@ export class InlineCheckout extends BaseInlineCheckout<IInlineCustomizationOptio
         showError("No se han configurado los datos del proveedor de servicio",  this.radioChecked, this.collectorIds.msgError)
       }
     } catch (error) {
-        const cardIdFromError = (error as any)?.details?.cardId as string | null | undefined;
-        const cardIdToCleanup = cardIdSaved || cardIdFromError || null;
-        if(cardIdToCleanup && auth_token){
+        if(cardIdSaved && auth_token){
             this.cardsInjected = false
-            await this._removeCustomerCard(auth_token, this.merchantData!.business.pk, cardIdToCleanup)
+            await this._removeCustomerCard(auth_token, this.merchantData!.business.pk, cardIdSaved)
             await this.#loadCardsList(auth_token)
         }
       this.reportSdkError(error, {
         feature: "payment",
-        process_id: cardIdToCleanup || this.radioChecked || this.getCustomerId(),
+        process_id: cardIdSaved || this.radioChecked || this.getCustomerId(),
         metadata: {
-          step: "card_on_file",
+          step: "_checkout",
         },
       });
       const visualMessage =

package/src/shared/constants/messages.ts

@@ -3,9 +3,11 @@ import { ErrorKeyEnum } from "../enums/ErrorKeyEnum";
 export const MESSAGES_EN: Record<string, string> = {
   [ErrorKeyEnum.CARD_ON_FILE_DECLINED]:
     "Transaction declined. Please verify your card details.",
+  [ErrorKeyEnum.UNKNOWN_ERROR]: 'An unexpected error occurred.',
 };
 
 export const MESSAGES_ES: Record<string, string> = {
   [ErrorKeyEnum.CARD_ON_FILE_DECLINED]:
     "Transaccion declinada. Verique los datos de su tarjeta.",
+  [ErrorKeyEnum.UNKNOWN_ERROR]: 'Ocurrió un error inesperado.',
 };

package/src/shared/enums/ErrorKeyEnum.ts

@@ -2,4 +2,5 @@ export enum ErrorKeyEnum {
   SAVE_CARD_ERROR = "SAVE_CARD_ERROR",
   PAYMENT_PROCESS_ERROR = "PAYMENT_PROCESS_ERROR",
   CARD_ON_FILE_DECLINED = "CARD_ON_FILE_DECLINED",
+  UNKNOWN_ERROR = 'UNKNOWN_ERROR'
 }

package/src/shared/utils/appError.ts

@@ -1,22 +1,42 @@
+import { MESSAGES_EN } from '../constants/messages';
+import { ErrorKeyEnum } from '../enums/ErrorKeyEnum';
+
 const DEFAULT_SYSTEM_ERROR = 'APP_INTERNAL_001';
-const DEFAULT_MESSAGE = 'An unexpected error occurred.';
+const LOCK_ERROR_CODE_KEY = '__tonderLockErrorCode__';
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+    return typeof value === 'object' && value !== null;
+}
 
 export interface IAppErrorInput {
     errorCode: string;
     message?: string;
-    details?: Record<string, unknown>;
     statusCode?: number;
+    details?: Record<string, unknown>;
+    originalError?: unknown;
+    lockErrorCode?: boolean;
 }
 
 export class AppError extends Error {
     public readonly status: 'error' = 'error';
     public readonly code: string;
     public readonly statusCode: number;
+    public readonly originalError?: unknown;
     public details: Record<string, unknown>;
 
     constructor(error: IAppErrorInput) {
-        const resolvedStatusCode = AppError.parseStatusCode(error.statusCode);
-        const resolvedMessage = error.message || DEFAULT_MESSAGE;
+        const resolvedStatusCode = AppError.resolveStatusCode(
+            error.statusCode,
+            error.originalError,
+        );
+        const resolvedMessage = AppError.resolveMessage(
+            error.errorCode,
+            error.message,
+        );
+        const resolvedSystemError = AppError.resolveSystemError(
+            error.details?.systemError,
+            error.originalError,
+        );
 
         super(resolvedMessage);
 
@@ -25,22 +45,28 @@ export class AppError extends Error {
         this.name = 'TonderError';
         this.code = error.errorCode;
         this.statusCode = resolvedStatusCode;
-
-        const baseDetails = {
-            ...(error.details || {}),
-        };
-
-        const resolvedSystemError = AppError.extractSystemError(baseDetails);
+        this.originalError = error.originalError;
         this.details = {
-            ...baseDetails,
             code: error.errorCode,
             statusCode: resolvedStatusCode,
             systemError: resolvedSystemError,
         };
 
+        if (error.lockErrorCode) {
+            Object.defineProperty(this, LOCK_ERROR_CODE_KEY, {
+                value: true,
+                enumerable: false,
+                configurable: true,
+            });
+        }
+
         Error.captureStackTrace?.(this, AppError);
     }
 
+    private static isRecord(value: unknown): value is Record<string, unknown> {
+        return typeof value === 'object' && value !== null;
+    }
+
     public static parseStatusCode(code: unknown): number {
         const parsed = Number(code);
         if (!Number.isFinite(parsed)) return 500;
@@ -48,28 +74,86 @@ export class AppError extends Error {
         return Math.trunc(parsed);
     }
 
+    public static resolveStatusCode(
+        explicitStatusCode: unknown,
+        originalError?: unknown,
+    ): number {
+        const candidates: unknown[] = [explicitStatusCode];
+
+        if (AppError.isRecord(originalError)) {
+            candidates.push(
+                originalError.statusCode,
+                originalError.status,
+            );
+
+            const body = AppError.isRecord(originalError.body)
+                ? originalError.body
+                : null;
+            if (body) {
+                candidates.push(body.statusCode, body.status);
+            }
+        }
+
+        for (const candidate of candidates) {
+            if (AppError.isHttpStatusCode(candidate)) {
+                return Math.trunc(Number(candidate));
+            }
+        }
+
+        return 500;
+    }
+
+    public static resolveMessage(errorCode: string, message?: string): string {
+        if (message) return message;
+        return (
+            MESSAGES_EN[errorCode] ||
+            MESSAGES_EN[ErrorKeyEnum.UNKNOWN_ERROR] ||
+            'An unexpected error occurred.'
+        );
+    }
+
     public static isHttpStatusCode(value: unknown): boolean {
         const parsed = Number(value);
         return Number.isFinite(parsed) && parsed >= 100 && parsed <= 599;
     }
 
-    public static resolveSystemError(value: unknown): string | null {
+    public static normalizeSystemError(value: unknown): string | null {
         if (typeof value !== 'string') return null;
-        const normalized = value.trim();
-        if (!normalized) return null;
-        return normalized;
+        const trimmed = value.trim();
+        return trimmed || null;
     }
 
-    public static extractSystemError(details: Record<string, unknown>): string {
-        const cause = details?.cause as any;
-        const candidates: unknown[] = [
-            details?.systemError,
-            cause?.body?.code,
-            cause?.details?.code,
-        ];
+    public static resolveSystemError(
+        explicitSystemError: unknown,
+        originalError?: unknown,
+    ): string {
+        const candidates: unknown[] = [explicitSystemError];
+
+        if (AppError.isRecord(originalError)) {
+            const details = AppError.isRecord(originalError.details)
+                ? originalError.details
+                : null;
+            const body = AppError.isRecord(originalError.body)
+                ? originalError.body
+                : null;
+            const bodyDetails = body && AppError.isRecord(body.details)
+                ? body.details
+                : null;
+
+            candidates.push(
+                originalError.systemError,
+                originalError.code,
+                details?.systemError,
+                details?.code,
+                body?.systemError,
+                body?.code,
+                bodyDetails?.systemError,
+                bodyDetails?.code,
+            );
+        }
 
         for (const candidate of candidates) {
-            const resolved = AppError.resolveSystemError(candidate);
+            const resolved = AppError.normalizeSystemError(candidate);
             if (resolved) return resolved;
         }
 
@@ -82,50 +166,139 @@ export interface IBuildPublicAppErrorInput {
     message?: string;
     details?: Record<string, unknown>;
     statusCode?: number;
+    response?: Response;
+    lockErrorCode?: boolean;
 }
 
-export function buildPublicAppError(
+function markErrorCodeLocked(error: Record<string, unknown>): void {
+    Object.defineProperty(error, LOCK_ERROR_CODE_KEY, {
+        value: true,
+        enumerable: false,
+        configurable: true,
+    });
+}
+
+function hasLockedErrorCode(error: unknown): boolean {
+    return isRecord(error) && error[LOCK_ERROR_CODE_KEY] === true;
+}
+
+function isTonderAppErrorLike(error: unknown): error is AppError {
+    return (
+        isRecord(error) &&
+        error.name === 'TonderError' &&
+        typeof error.code === 'string'
+    );
+}
+
+function getOriginalError(error: unknown): unknown {
+    if (error instanceof AppError) {
+        return error.originalError !== undefined ? error.originalError : error;
+    }
+
+    return error;
+}
+
+async function parseResponseBody(response: Response): Promise<unknown> {
+    try {
+        return await response.clone().json();
+    } catch (_) {
+        // Ignore JSON parsing errors and fallback to text.
+    }
+
+    try {
+        const text = await response.text();
+        return text || undefined;
+    } catch (_) {
+        return undefined;
+    }
+}
+
+function buildPublicAppErrorSync(
     data: IBuildPublicAppErrorInput,
-    error?: any,
+    error?: unknown,
 ): AppError {
     if (!data?.errorCode) {
         throw new Error('buildPublicAppError requires errorCode');
     }
 
-    const hasDataDetails = !!data.details && Object.keys(data.details).length > 0;
-    const hasOverrides =
-        data.errorCode !== error?.code ||
+    const explicitSystemError = data.details?.systemError;
+    const hasExplicitOverrides =
         !!data.message ||
         data.statusCode !== undefined ||
-        hasDataDetails;
+        explicitSystemError !== undefined;
+
+    if (isTonderAppErrorLike(error)) {
+        if (data.lockErrorCode) {
+            markErrorCodeLocked(error as unknown as Record<string, unknown>);
+        }
 
-    if (error instanceof AppError && !hasOverrides) {
-        return error;
+        if (!hasExplicitOverrides) {
+            if (data.errorCode === error.code || hasLockedErrorCode(error)) {
+                return error;
+            }
+        }
     }
 
-    const resolvedStatusCode =
-        data.statusCode ??
-        (AppError.isHttpStatusCode(error?.statusCode)
-            ? Number(error.statusCode)
-            : AppError.isHttpStatusCode(error?.code)
-                ? Number(error.code)
-                : AppError.isHttpStatusCode(error?.status)
-                    ? Number(error.status)
-                    : 500);
+    return new AppError({
+        errorCode: data.errorCode,
+        message: data.message,
+        statusCode: data.statusCode,
+        details:
+            explicitSystemError !== undefined
+                ? { systemError: explicitSystemError }
+                : undefined,
+        originalError: getOriginalError(error),
+        lockErrorCode: data.lockErrorCode || hasLockedErrorCode(error),
+    });
+}
+
+async function buildPublicAppErrorFromHttpResponse(
+    data: IBuildPublicAppErrorInput & { response: Response },
+): Promise<AppError> {
+    const body = await parseResponseBody(data.response);
 
-    const resolvedDetails: Record<string, unknown> = {
-        ...(error?.details || {}),
-        ...(data.details || {}),
+    const originalError: Record<string, unknown> = {
+        status: data.response.status,
     };
 
-    if (resolvedDetails.cause === undefined && error !== undefined) {
-        resolvedDetails.cause = error;
+    if (data.response.statusText) {
+        originalError.statusText = data.response.statusText;
+    }
+
+    if (body !== undefined) {
+        originalError.body = body;
     }
 
     return new AppError({
         errorCode: data.errorCode,
         message: data.message,
-        details: resolvedDetails,
-        statusCode: resolvedStatusCode,
+        statusCode: data.statusCode ?? data.response.status,
+        details:
+            data.details?.systemError !== undefined
+                ? { systemError: data.details.systemError }
+                : undefined,
+        originalError,
+        lockErrorCode: data.lockErrorCode,
     });
 }
+
+export function buildPublicAppError(
+    data: IBuildPublicAppErrorInput & { response: Response },
+    error?: unknown,
+): Promise<AppError>;
+export function buildPublicAppError(
+    data: IBuildPublicAppErrorInput,
+    error?: unknown,
+): AppError;
+export function buildPublicAppError(
+    data: IBuildPublicAppErrorInput,
+    error?: unknown,
+): AppError | Promise<AppError> {
+    if (data?.response) {
+        return buildPublicAppErrorFromHttpResponse(
+            data as IBuildPublicAppErrorInput & { response: Response },
+        );
+    }
+
+    return buildPublicAppErrorSync(data, error);
+}

package/src/types/inlineCheckout.ts

@@ -1,7 +1,6 @@
 import {IConfigureCheckout} from "@tonder.io/ionic-lite-sdk/dist/types/commons";
 import {
     IProcessPaymentRequest,
-    IStartCheckoutErrorResponse,
     IStartCheckoutResponse
 } from "@tonder.io/ionic-lite-sdk/dist/types/checkout";
 import {ITransaction} from "@tonder.io/ionic-lite-sdk/dist/types/transaction";
@@ -32,7 +31,6 @@ export interface IInlineCheckout {
      *
      * @throws {Error} Throws an error if the checkout process fails. The error object contains
      * additional `details` property with the response from the server if available.
-     * @property {IStartCheckoutErrorResponse} error.details - The response body from the server when an error occurs.
      *
      * @public
      */