@commercetools/connect-payments-sdk 0.24.0 → 0.25.1

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @commercetools/connect-payments-sdk
 
+## 0.25.1
+
+### Patch Changes
+
+- ad4c0d7: fix(payments): extract checkoutTransactionItemId from session
+
+## 0.25.0
+
+### Minor Changes
+
+- 511fbef: - Add new api and service for interacting with CT custom-types APIs.
+  - Add predefined Checkout custom-types.
+- d28fe6d: support use of transaction interface id and checkoutTransactionItemsIds
+
+### Patch Changes
+
+- 5d0e4c2: chore(sdk): for CT API sdk mask sensitive data in error object
+
 ## 0.24.0
 
 ### Minor Changes

package/dist/api/context/request-context.helper.d.ts

@@ -3,7 +3,13 @@ export declare function getGiftCardPlannedAmountFromContext(context: RequestCont
 export declare function getCtSessionIdFromContext(context: RequestContextData): string | undefined;
 export declare function getCartIdFromContext(context: RequestContextData): string | undefined;
 export declare function getAllowedPaymentMethodsFromContext(context: RequestContextData): string[] | undefined;
+/**
+ * @deprecated use getCheckoutTransactionItemIdFromContext instead
+ * @param context
+ * @returns
+ */
 export declare function getPaymentInterfaceFromContext(context: RequestContextData): string | undefined;
+export declare function getCheckoutTransactionItemIdFromContext(context: RequestContextData): string | undefined;
 export declare function getProcessorUrlFromContext(context: RequestContextData): string | undefined;
 export declare function getMerchantReturnUrlFromContext(context: RequestContextData): string | undefined;
 export declare function getFutureOrderNumberFromContext(context: RequestContextData): string | undefined;

package/dist/api/context/request-context.helper.js

@@ -5,6 +5,7 @@ exports.getCtSessionIdFromContext = getCtSessionIdFromContext;
 exports.getCartIdFromContext = getCartIdFromContext;
 exports.getAllowedPaymentMethodsFromContext = getAllowedPaymentMethodsFromContext;
 exports.getPaymentInterfaceFromContext = getPaymentInterfaceFromContext;
+exports.getCheckoutTransactionItemIdFromContext = getCheckoutTransactionItemIdFromContext;
 exports.getProcessorUrlFromContext = getProcessorUrlFromContext;
 exports.getMerchantReturnUrlFromContext = getMerchantReturnUrlFromContext;
 exports.getFutureOrderNumberFromContext = getFutureOrderNumberFromContext;
@@ -33,12 +34,23 @@ function getAllowedPaymentMethodsFromContext(context) {
         return authentication?.getPrincipal().allowedPaymentMethods;
     }
 }
+/**
+ * @deprecated use getCheckoutTransactionItemIdFromContext instead
+ * @param context
+ * @returns
+ */
 function getPaymentInterfaceFromContext(context) {
     const authentication = context.authentication;
     if (authentication && authentication instanceof __1.SessionAuthentication) {
         return authentication?.getPrincipal().paymentInterface;
     }
 }
+function getCheckoutTransactionItemIdFromContext(context) {
+    const authentication = context.authentication;
+    if (authentication && authentication instanceof __1.SessionAuthentication) {
+        return authentication?.getPrincipal().checkoutTransactionItemId;
+    }
+}
 function getProcessorUrlFromContext(context) {
     const authentication = context.authentication;
     if (authentication && authentication instanceof __1.SessionAuthentication) {

package/dist/commercetools/api/custom-type-api.d.ts

@@ -0,0 +1,10 @@
+import { Type, TypeDraft, TypeUpdate } from '@commercetools/platform-sdk';
+import { APIOpts, CustomTypeAPI } from '../types/api.type';
+import { CommercetoolsBaseAPI } from './base-api';
+export declare class CommercetoolsCustomTypeAPI extends CommercetoolsBaseAPI implements CustomTypeAPI {
+    constructor(opts: APIOpts);
+    getByKey(key: string): Promise<Type>;
+    existsByKey(key: string): Promise<boolean>;
+    create(draft: TypeDraft): Promise<Type>;
+    update(key: string, update: TypeUpdate): Promise<Type>;
+}

package/dist/commercetools/api/custom-type-api.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommercetoolsCustomTypeAPI = void 0;
+const base_api_1 = require("./base-api");
+class CommercetoolsCustomTypeAPI extends base_api_1.CommercetoolsBaseAPI {
+    constructor(opts) {
+        super(opts);
+        Object.setPrototypeOf(this, CommercetoolsCustomTypeAPI.prototype);
+    }
+    async getByKey(key) {
+        return this.executeCall(this.client.types().withKey({ key }).get().execute());
+    }
+    async existsByKey(key) {
+        try {
+            await this.client.types().withKey({ key }).get().execute();
+            return true;
+        }
+        catch (error) {
+            if (error instanceof Object && 'statusCode' in error && error['statusCode'] === 404) {
+                return false;
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    async create(draft) {
+        return this.executeCall(this.client
+            .types()
+            .post({
+            body: draft,
+        })
+            .execute());
+    }
+    async update(key, update) {
+        return this.executeCall(this.client
+            .types()
+            .withKey({ key })
+            .post({
+            body: update,
+        })
+            .execute());
+    }
+}
+exports.CommercetoolsCustomTypeAPI = CommercetoolsCustomTypeAPI;

package/dist/commercetools/api/payment-method-api.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommercetoolsPaymentMethodAPI = void 0;
 const base_api_1 = require("./base-api");
-const ct_api_error_1 = require("../errors/ct-api.error");
 class CommercetoolsPaymentMethodAPI extends base_api_1.CommercetoolsBaseAPI {
     constructor(opts) {
         super(opts);
@@ -12,26 +11,18 @@ class CommercetoolsPaymentMethodAPI extends base_api_1.CommercetoolsBaseAPI {
         return this.executeCall(this.client.paymentMethods().withId({ ID: opts.id }).get().execute());
     }
     async checkIfExistsByPredicate(opts) {
-        try {
-            await this.executeCall(this.client
-                .paymentMethods()
-                .head({
-                queryArgs: {
-                    where: opts.queryString,
-                },
-            })
-                .execute());
-            return true;
-        }
-        catch (error) {
-            // The HEAD call returns a 404 if the paymentMethod does not exist
-            if (error instanceof ct_api_error_1.CommercetoolsAPIError && error.httpErrorStatus === 404) {
-                return false;
-            }
-            else {
-                throw error;
-            }
+        const result = await this.executeCall(this.client
+            .paymentMethods()
+            .get({
+            queryArgs: {
+                where: opts.queryString,
+            },
+        })
+            .execute());
+        if (result.total === 0) {
+            return false;
         }
+        return true;
     }
     find(opts) {
         return this.executeCall(this.client

package/dist/commercetools/api/root-api.d.ts

@@ -1,5 +1,5 @@
 import { ContextProvider, RequestContextData } from '../../api';
-import { CartAPI, CommercetoolsAPI, CommercetoolsClient, OrderAPI, PaymentAPI, PaymentMethodAPI } from '../types/api.type';
+import { CartAPI, CommercetoolsAPI, CommercetoolsClient, CustomTypeAPI, OrderAPI, PaymentAPI, PaymentMethodAPI } from '../types/api.type';
 import { Logger } from '../..';
 export declare class DefaultCommercetoolsAPI implements CommercetoolsAPI {
     client: CommercetoolsClient;
@@ -7,6 +7,7 @@ export declare class DefaultCommercetoolsAPI implements CommercetoolsAPI {
     payment: PaymentAPI;
     order: OrderAPI;
     paymentMethod: PaymentMethodAPI;
+    customType: CustomTypeAPI;
     private logger;
     constructor(opts: {
         clientId: string;

package/dist/commercetools/api/root-api.js

@@ -7,6 +7,7 @@ const cart_api_1 = require("./cart-api");
 const payment_api_1 = require("./payment-api");
 const payment_method_api_1 = require("./payment-method-api");
 const order_api_1 = require("./order-api");
+const custom_type_api_1 = require("./custom-type-api");
 const crypto_1 = require("crypto");
 class DefaultCommercetoolsAPI {
     client;
@@ -14,6 +15,7 @@ class DefaultCommercetoolsAPI {
     payment;
     order;
     paymentMethod;
+    customType;
     logger;
     constructor(opts) {
         this.client = createClient(opts);
@@ -21,6 +23,7 @@ class DefaultCommercetoolsAPI {
         this.payment = new payment_api_1.CommercetoolsPaymentAPI({ client: this.client });
         this.order = new order_api_1.CommercetoolsOrderAPI({ client: this.client });
         this.paymentMethod = new payment_method_api_1.CommercetoolsPaymentMethodAPI({ client: this.client });
+        this.customType = new custom_type_api_1.CommercetoolsCustomTypeAPI({ client: this.client });
         this.logger = opts.logger;
     }
 }
@@ -40,6 +43,7 @@ const createClient = (opts) => {
         //Enables SDK retries when CoCo returns a 503 error. It retries up to 10 times with an 200ms backoff.
         enableRetry: true,
         ...(opts.httpClient ? { httpClient: opts.httpClient } : {}),
+        maskSensitiveHeaderData: true,
     };
     const correlationIdMiddlewareOptions = {
         generate: () => {

package/dist/commercetools/index.d.ts

@@ -4,8 +4,9 @@ export { SessionService as CommercetoolsSessionService, Session } from './types/
 export { AuthorizationService as CommercetoolsAuthorizationService } from './types/authorization.type';
 export { OrderService as CommercetoolsOrderService } from './types/order.type';
 export { PaymentMethodService as CommercetoolsPaymentMethodService } from './types/payment-method.type';
+export { CustomTypeService as CommercetoolsCustomTypeService } from './types/custom-type.type';
 export * as CommercetoolsPaymentMethodTypes from './types/payment-method.type';
 export { CommercetoolsClient } from './types/api.type';
-export { CustomFieldsDraft, Cart, Order, OrderPagedQueryResponse, Payment, PaymentDraft, Money, LineItem, CustomLineItem, Address, Transaction, TransactionType, TransactionState, ShippingInfo, PaymentMethod, PaymentMethodToken, PaymentMethodStatus, } from '@commercetools/platform-sdk';
+export { CustomFieldsDraft, Cart, Order, OrderPagedQueryResponse, Payment, PaymentDraft, PaymentMethodInfoDraft, Money, LineItem, CustomLineItem, Address, Transaction, TransactionType, TransactionState, ShippingInfo, PaymentMethod, PaymentMethodPagedQueryResponse, PaymentMethodToken, PaymentMethodStatus, Type, TypeDraft, TypePagedQueryResponse, LocalizedString, } from '@commercetools/platform-sdk';
 export * as CurrencyConverters from './helpers/currency.converter';
 export * as TaxRateConverter from './helpers/taxrate.converter';

package/dist/commercetools/services/ct-custom-type.service.d.ts

@@ -0,0 +1,34 @@
+import { Type, TypeDraft } from '@commercetools/platform-sdk';
+import { PaymentServiceOptions } from '../types/payment.type';
+import { CustomTypeService, GetByKeyCustomType, UpdateCustomType } from '../types/custom-type.type';
+/**
+ * This is the default implementation of the CustomTypeService interface.
+ */
+export declare class DefaultCustomTypeService implements CustomTypeService {
+    private ctAPI;
+    private logger;
+    constructor(opts: PaymentServiceOptions);
+    getByKey(opts: GetByKeyCustomType): Promise<Type>;
+    existsByKey(opts: GetByKeyCustomType): Promise<boolean>;
+    create(draft: TypeDraft): Promise<Type>;
+    update(opts: UpdateCustomType): Promise<Type>;
+    createOrUpdatePredefinedPaymentMethodTypes(): Promise<Type[]>;
+    createOrUpdatePredefinedInterfaceInteractionType(): Promise<Type>;
+    /**
+     * Based on the given TypeDraft this will either create or update the custom type in CT based on the provided "key".
+     *
+     * - if a custom-type by key does not exist in CT then it will create it using the given draft
+     * - if a custom-type by key does exist in CT it will gather a set of update actions to try and sync up the definitions
+     *
+     * The update currently supports:
+     * - adding missing field definitions. If the given draft contains field definitions that the custom-type in CT does not have, it will for each missing field definition perform an "addFieldDefinition" update action. Purely by checking the "name" of the field definitions.
+     *
+     * Differences between the TypeDraft and existing custom-type in CT such as are not supported yet but could be added in the future.
+     * - remove field definition if they no longer exist in the TypeDraft
+     * - update/sync the possible enum values for a field definition
+     * - update/sync the actual field definition properties. Such as "localized label", "type" or "required" value
+     */
+    createOrUpdate(customTypeDraft: TypeDraft): Promise<Type>;
+    private consolidateUpdateActions;
+    private getMissingFieldDefinitionsUpdateActions;
+}

package/dist/commercetools/services/ct-custom-type.service.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultCustomTypeService = void 0;
+const custom_types_1 = require("../../custom-types");
+/**
+ * This is the default implementation of the CustomTypeService interface.
+ */
+class DefaultCustomTypeService {
+    ctAPI;
+    logger;
+    constructor(opts) {
+        this.ctAPI = opts.ctAPI;
+        this.logger = opts.logger;
+    }
+    async getByKey(opts) {
+        return await this.ctAPI.customType.getByKey(opts.key);
+    }
+    async existsByKey(opts) {
+        return await this.ctAPI.customType.existsByKey(opts.key);
+    }
+    async create(draft) {
+        return await this.ctAPI.customType.create(draft);
+    }
+    async update(opts) {
+        return await this.ctAPI.customType.update(opts.key, opts.updateActions);
+    }
+    async createOrUpdatePredefinedPaymentMethodTypes() {
+        const cardDetailsType = await this.createOrUpdate(custom_types_1.CardDetailsTypeDraft);
+        const sepaDetailsType = await this.createOrUpdate(custom_types_1.SepaDetailsTypeDraft);
+        return [cardDetailsType, sepaDetailsType];
+    }
+    async createOrUpdatePredefinedInterfaceInteractionType() {
+        return await this.createOrUpdate(custom_types_1.PaymentInterfaceInteractionTypeDraft);
+    }
+    /**
+     * Based on the given TypeDraft this will either create or update the custom type in CT based on the provided "key".
+     *
+     * - if a custom-type by key does not exist in CT then it will create it using the given draft
+     * - if a custom-type by key does exist in CT it will gather a set of update actions to try and sync up the definitions
+     *
+     * The update currently supports:
+     * - adding missing field definitions. If the given draft contains field definitions that the custom-type in CT does not have, it will for each missing field definition perform an "addFieldDefinition" update action. Purely by checking the "name" of the field definitions.
+     *
+     * Differences between the TypeDraft and existing custom-type in CT such as are not supported yet but could be added in the future.
+     * - remove field definition if they no longer exist in the TypeDraft
+     * - update/sync the possible enum values for a field definition
+     * - update/sync the actual field definition properties. Such as "localized label", "type" or "required" value
+     */
+    async createOrUpdate(customTypeDraft) {
+        const exists = await this.existsByKey({ key: customTypeDraft.key });
+        if (!exists) {
+            this.logger.info({ key: customTypeDraft.key }, 'Custom type by key does not exist in CT, creating it');
+            return await this.create(customTypeDraft);
+        }
+        const customTypeFromCT = await this.getByKey({ key: customTypeDraft.key });
+        const updateActions = this.consolidateUpdateActions(customTypeDraft, customTypeFromCT);
+        if (updateActions.actions.length > 0) {
+            this.logger.info({ key: customTypeDraft.key, updateActions: { total: updateActions.actions.length } }, 'Updating existing custom-type by key');
+            return await this.update({ key: customTypeFromCT.key, updateActions: updateActions });
+        }
+        this.logger.info({ key: customTypeDraft.key }, 'Custom type exists but no update is required, doing nothing.');
+        return customTypeFromCT;
+    }
+    consolidateUpdateActions(customTypeDraft, existingType) {
+        const updateActions = [];
+        updateActions.push(...this.getMissingFieldDefinitionsUpdateActions(customTypeDraft, existingType));
+        return {
+            version: existingType.version,
+            actions: updateActions,
+        };
+    }
+    getMissingFieldDefinitionsUpdateActions(customTypeDraft, existingType) {
+        const draftFieldDefinitions = customTypeDraft.fieldDefinitions || [];
+        const missingFieldDefinitions = draftFieldDefinitions.filter((fd) => !existingType.fieldDefinitions.some((existingFD) => fd.name === existingFD.name));
+        const addFieldDefinitionUpdateActions = missingFieldDefinitions.map((fd) => {
+            return {
+                action: 'addFieldDefinition',
+                fieldDefinition: fd,
+            };
+        });
+        if (addFieldDefinitionUpdateActions.length > 0) {
+            this.logger.info({
+                key: customTypeDraft.key,
+                missingFieldsCount: addFieldDefinitionUpdateActions.length,
+                fieldNames: missingFieldDefinitions.map((fd) => fd.name),
+            }, 'Custom type in CT is missing field definition from the draft, adding them');
+        }
+        return addFieldDefinitionUpdateActions;
+    }
+}
+exports.DefaultCustomTypeService = DefaultCustomTypeService;

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

@@ -117,6 +117,7 @@ class DefaultPaymentMethodService {
             token: {
                 value: opts.token,
             },
+            ...(opts.customFields ? { custom: opts.customFields } : {}),
         });
     }
     async delete(opts) {

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

@@ -1,5 +1,13 @@
 import { Payment, PaymentDraft, PaymentUpdateAction, Transaction } from '@commercetools/platform-sdk';
 import { FindPaymentsByInterfaceId, FindTransaction, GetPayment, PaymentService, PaymentServiceOptions, TransactionData, UpdatePayment } from '../types/payment.type';
+declare module '@commercetools/platform-sdk' {
+    interface PaymentDraft {
+        checkoutTransactionItemId?: string;
+    }
+    interface Payment {
+        checkoutTransactionItemId?: string;
+    }
+}
 /**
  * This is the default implementation of the PaymentService interface.
  */
@@ -14,10 +22,16 @@ export declare class DefaultPaymentService implements PaymentService {
     private consolidateUpdateActions;
     private populateSetInterfaceIdAction;
     private populateChangeTransactionInteractionId;
+    private populateSetTransactionInterfaceId;
     private populateAddTransactionAction;
     private populateChangeTransactionState;
     private populateSetPaymentMethod;
     private populateSetMethodInfoToken;
+    private populateSetMethodInfoInterface;
+    private populateSetMethodInfoName;
+    private populateSetMethodInfoInterfaceAccount;
+    private populateSetMethodInfoCustomType;
+    private populateSetMethodInfoCustomField;
     private populateSetCustomType;
     private populateAddInterfaceInteractions;
     findMatchingTransactions(payment: Payment, transaction: TransactionData): Transaction[];
@@ -27,5 +41,6 @@ export declare class DefaultPaymentService implements PaymentService {
     private handleTransactionUpdates;
     private shouldUpdateTransactionState;
     private shouldUpdateInteractionId;
+    private shouldUpdateTransactionInterfaceId;
     private throwMultipleMatchingTransactionsError;
 }

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

@@ -64,12 +64,36 @@ class DefaultPaymentService {
         if (!payment.interfaceId && updateInfo.pspReference) {
             actions.push(this.populateSetInterfaceIdAction(updateInfo.pspReference));
         }
+        /**
+         * old way
+         */
         if (!payment.paymentMethodInfo?.method && updateInfo.paymentMethod) {
             actions.push(this.populateSetPaymentMethod(updateInfo.paymentMethod));
         }
         if (!payment.paymentMethodInfo?.token && updateInfo.token) {
             actions.push(this.populateSetMethodInfoToken(updateInfo.token));
         }
+        /**
+         * New way
+         */
+        if (!payment.paymentMethodInfo?.method && updateInfo.paymentMethodInfo?.method) {
+            actions.push(this.populateSetPaymentMethod(updateInfo.paymentMethodInfo.method));
+        }
+        if (!payment.paymentMethodInfo?.token && updateInfo.paymentMethodInfo?.token?.value) {
+            actions.push(this.populateSetMethodInfoToken(updateInfo.paymentMethodInfo.token.value));
+        }
+        if (!payment.paymentMethodInfo?.name && updateInfo.paymentMethodInfo?.name) {
+            actions.push(this.populateSetMethodInfoName(updateInfo.paymentMethodInfo.name));
+        }
+        if (!payment.paymentMethodInfo?.paymentInterface && updateInfo.paymentMethodInfo?.paymentInterface) {
+            actions.push(this.populateSetMethodInfoInterface(updateInfo.paymentMethodInfo.paymentInterface));
+        }
+        if (!payment.paymentMethodInfo?.interfaceAccount && updateInfo.paymentMethodInfo?.interfaceAccount) {
+            actions.push(this.populateSetMethodInfoInterfaceAccount(updateInfo.paymentMethodInfo.interfaceAccount));
+        }
+        if (updateInfo.paymentMethodInfo?.custom) {
+            actions.push(this.populateSetMethodInfoCustomType(updateInfo.paymentMethodInfo.custom));
+        }
         if (updateInfo.transaction) {
             const transactionChanges = this.consolidateTransactionChanges(payment, updateInfo.transaction);
             if (transactionChanges.length > 0) {
@@ -97,6 +121,13 @@ class DefaultPaymentService {
             interactionId,
         };
     }
+    populateSetTransactionInterfaceId(txId, interfaceId) {
+        return {
+            action: 'setTransactionInterfaceId',
+            transactionId: txId,
+            interfaceId,
+        }; // TypeScript does not have this action in the SDK yet
+    }
     populateAddTransactionAction(draft) {
         return {
             action: 'addTransaction',
@@ -127,6 +158,37 @@ class DefaultPaymentService {
             },
         };
     }
+    populateSetMethodInfoInterface(paymentInterface) {
+        return {
+            action: 'setMethodInfoInterface',
+            interface: paymentInterface,
+        };
+    }
+    populateSetMethodInfoName(name) {
+        return {
+            action: 'setMethodInfoName',
+            name,
+        };
+    }
+    populateSetMethodInfoInterfaceAccount(interfaceAccount) {
+        return {
+            action: 'setMethodInfoInterfaceAccount',
+            interfaceAccount,
+        };
+    }
+    populateSetMethodInfoCustomType(customType) {
+        return {
+            action: 'setMethodInfoCustomType',
+            ...customType,
+        };
+    }
+    populateSetMethodInfoCustomField(name, value) {
+        return {
+            action: 'setMethodInfoCustomField',
+            name,
+            value,
+        };
+    }
     populateSetCustomType(customFields) {
         return {
             action: 'setCustomType',
@@ -143,13 +205,28 @@ class DefaultPaymentService {
     }
     findMatchingTransactions(payment, transaction) {
         return payment.transactions.filter((tx) => {
-            return (tx.type === transaction.type &&
-                transaction.interactionId &&
-                (tx.interactionId === transaction.interactionId ||
-                    (tx.amount.centAmount === transaction.amount.centAmount &&
-                        tx.amount.currencyCode === transaction.amount.currencyCode &&
-                        !tx.interactionId &&
-                        tx.state === 'Initial')));
+            // Must match transaction type
+            if (tx.type !== transaction.type) {
+                return false;
+            }
+            // New transaction must have at least one PSP identifier. InteractionId is for retro compatibility.
+            if (!transaction.interactionId && !transaction.interfaceId) {
+                return false;
+            }
+            // Match by interactionId
+            if (transaction.interactionId && tx.interactionId === transaction.interactionId) {
+                return true;
+            }
+            // Match by interfaceId
+            if (transaction.interfaceId && tx.interfaceId === transaction.interfaceId) {
+                return true;
+            }
+            // Match Initial transactions missing at least one ID by amount
+            // This allows reusing an Initial transaction when we get a PSP response with an ID
+            const isInitialMissingIds = tx.state === 'Initial' && (!tx.interactionId || !tx.interfaceId);
+            const hasMatchingAmount = tx.amount.centAmount === transaction.amount.centAmount &&
+                tx.amount.currencyCode === transaction.amount.currencyCode;
+            return isInitialMissingIds && hasMatchingAmount;
         });
     }
     hasTransactionInState(opts) {
@@ -187,6 +264,9 @@ class DefaultPaymentService {
         if (this.shouldUpdateInteractionId(existingTx, newTransaction)) {
             actions.push(this.populateChangeTransactionInteractionId(existingTx.id, newTransaction.interactionId));
         }
+        if (this.shouldUpdateTransactionInterfaceId(existingTx, newTransaction)) {
+            actions.push(this.populateSetTransactionInterfaceId(existingTx.id, newTransaction.interfaceId));
+        }
     }
     shouldUpdateTransactionState(existingTx, newTransaction) {
         const { state: currentState } = existingTx;
@@ -203,6 +283,9 @@ class DefaultPaymentService {
     shouldUpdateInteractionId(existingTx, newTransaction) {
         return !existingTx.interactionId && !!newTransaction.interactionId;
     }
+    shouldUpdateTransactionInterfaceId(existingTx, newTransaction) {
+        return !existingTx.interfaceId && !!newTransaction.interfaceId;
+    }
     throwMultipleMatchingTransactionsError(payment, newTransaction, matchingTxs) {
         this.logger.error({
             paymentId: payment.id,

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

@@ -19,6 +19,7 @@ export declare class DefaultSessionService implements SessionService {
     getAllowedPaymentMethodsFromSession(session: Session): string[];
     getProcessorUrlFromSession(session: Session): string;
     getPaymentInterfaceFromSession(session: Session): string | undefined;
+    getCheckoutTransactionItemIdFromSession(session: Session): string | undefined;
     getMerchantReturnUrlFromSession(session: Session): string | undefined;
     getFutureOrderNumberFromSession(session: Session): string | undefined;
     getGiftCardPlannedAmountFromSession(session: Session): Money | undefined;

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

@@ -69,6 +69,9 @@ class DefaultSessionService {
     getPaymentInterfaceFromSession(session) {
         return session.metadata?.paymentInterface;
     }
+    getCheckoutTransactionItemIdFromSession(session) {
+        return session.metadata?.checkoutTransactionItemId;
+    }
     getMerchantReturnUrlFromSession(session) {
         return session.metadata?.merchantReturnUrl;
     }

package/dist/commercetools/types/api.type.d.ts

@@ -1,4 +1,4 @@
-import { Cart, CartPagedQueryResponse, OrderPagedQueryResponse, Payment, PaymentDraft, PaymentPagedQueryResponse, PaymentUpdateAction, PaymentMethod, PaymentMethodDraft, PaymentMethodPagedQueryResponse, PaymentMethodUpdateAction } from '@commercetools/platform-sdk';
+import { Cart, CartPagedQueryResponse, OrderPagedQueryResponse, Payment, PaymentDraft, PaymentPagedQueryResponse, PaymentUpdateAction, PaymentMethod, PaymentMethodDraft, PaymentMethodPagedQueryResponse, PaymentMethodUpdateAction, Type, TypeDraft, TypeUpdate } from '@commercetools/platform-sdk';
 import { ByProjectKeyRequestBuilder } from '@commercetools/platform-sdk/dist/declarations/src/generated/client/by-project-key-request-builder';
 export type CommercetoolsClient = ByProjectKeyRequestBuilder;
 export type CommercetoolsSessionClient = ByProjectKeyRequestBuilder;
@@ -66,9 +66,16 @@ export interface PaymentMethodAPI {
 export interface OrderAPI {
     find(queryPredicate: string): Promise<OrderPagedQueryResponse>;
 }
+export interface CustomTypeAPI {
+    getByKey(key: string): Promise<Type>;
+    existsByKey(key: string): Promise<boolean>;
+    create(draft: TypeDraft): Promise<Type>;
+    update(key: string, update: TypeUpdate): Promise<Type>;
+}
 export interface CommercetoolsAPI {
     cart: CartAPI;
     payment: PaymentAPI;
     order: OrderAPI;
     paymentMethod: PaymentMethodAPI;
+    customType: CustomTypeAPI;
 }

package/dist/commercetools/types/custom-type.type.d.ts

@@ -0,0 +1,20 @@
+import { Type, TypeDraft, TypeUpdate } from '@commercetools/platform-sdk';
+export type GetByKeyCustomType = {
+    key: string;
+};
+export type ExistsByKeyCustomType = {
+    key: string;
+};
+export type UpdateCustomType = {
+    key: string;
+    updateActions: TypeUpdate;
+};
+export interface CustomTypeService {
+    getByKey(opts: GetByKeyCustomType): Promise<Type>;
+    existsByKey(opts: GetByKeyCustomType): Promise<boolean>;
+    create(draft: TypeDraft): Promise<Type>;
+    update(opts: UpdateCustomType): Promise<Type>;
+    createOrUpdate(customTypeDraft: TypeDraft): Promise<Type>;
+    createOrUpdatePredefinedPaymentMethodTypes(): Promise<Type[]>;
+    createOrUpdatePredefinedInterfaceInteractionType(): Promise<Type>;
+}

package/dist/commercetools/types/custom-type.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commercetools/types/payment-method.type.d.ts

@@ -1,6 +1,6 @@
 import { CommercetoolsAPI, UpdateResource } from './api.type';
 import { Logger } from '../../logger';
-import { PaymentMethod, PaymentMethodPagedQueryResponse, PaymentMethodUpdateAction } from '@commercetools/platform-sdk';
+import { CustomFieldsDraft, PaymentMethod, PaymentMethodPagedQueryResponse, PaymentMethodUpdateAction } from '@commercetools/platform-sdk';
 export type PaymentMethodServiceOptions = {
     ctAPI: CommercetoolsAPI;
     logger: Logger;
@@ -44,6 +44,7 @@ export type SavePaymentMethodDraft = {
     paymentInterface: string;
     interfaceAccount?: string;
     method: string;
+    customFields?: CustomFieldsDraft;
 };
 /**
  * Payment methods service interface exposes methods to interact with the commercetools platform API.

package/dist/commercetools/types/payment.type.d.ts

@@ -1,4 +1,4 @@
-import { CustomFieldsDraft, Money, Payment, PaymentDraft, TransactionState, TransactionType } from '@commercetools/platform-sdk';
+import { CustomFieldsDraft, Money, Payment, PaymentDraft, PaymentMethodInfoDraft, TransactionState, TransactionType } from '@commercetools/platform-sdk';
 import { CommercetoolsAPI } from './api.type';
 import { Logger } from '../../logger';
 export type PaymentAmount = {
@@ -25,6 +25,7 @@ export type TransactionData = {
     type: TransactionType;
     amount: Money;
     interactionId?: string;
+    interfaceId?: string;
     state: TransactionState;
 };
 export type UpdatePayment = {
@@ -33,6 +34,7 @@ export type UpdatePayment = {
     pspInteractions?: CustomFieldsDraft[];
     transaction?: TransactionData;
     paymentMethod?: string;
+    paymentMethodInfo?: PaymentMethodInfoDraft;
     customFields?: CustomFieldsDraft;
     token?: string;
 };

package/dist/commercetools/types/session.type.d.ts

@@ -28,6 +28,7 @@ export interface SessionService {
     getAllowedPaymentMethodsFromSession(session: Session): string[];
     getProcessorUrlFromSession(session: Session): string;
     getPaymentInterfaceFromSession(session: Session): string | undefined;
+    getCheckoutTransactionItemIdFromSession(session: Session): string | undefined;
     getMerchantReturnUrlFromSession(session: Session): string | undefined;
     getFutureOrderNumberFromSession(session: Session): string | undefined;
     getGiftCardPlannedAmountFromSession(session: Session): Money | undefined;

package/dist/custom-types/index.d.ts

@@ -0,0 +1,4 @@
+export * from './payment-methods/card';
+export * from './payment-methods/sepa';
+export * from './payment-methods/shared';
+export * from './payment-interface-interactions';

package/dist/custom-types/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./payment-methods/card"), exports);
+__exportStar(require("./payment-methods/sepa"), exports);
+__exportStar(require("./payment-methods/shared"), exports);
+__exportStar(require("./payment-interface-interactions"), exports);

package/dist/custom-types/payment-interface-interactions.d.ts

@@ -0,0 +1,11 @@
+import { CustomFieldsDraft, TypeDraft } from '@commercetools/platform-sdk';
+export declare const PaymentInterfaceInteractionTypeKey = "commercetools-checkout-payment-interface-interaction";
+export declare const PaymentInterfaceInteractionTypeDraft: TypeDraft;
+export type InterfaceInteractionFields = {
+    interactionId: string;
+    createdAt: string;
+    request?: string;
+    response?: string;
+    type: string;
+};
+export declare const GenerateInterfaceInteractionCustomFieldsDraft: (fields: InterfaceInteractionFields) => CustomFieldsDraft;

package/dist/custom-types/payment-interface-interactions.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateInterfaceInteractionCustomFieldsDraft = exports.PaymentInterfaceInteractionTypeDraft = exports.PaymentInterfaceInteractionTypeKey = void 0;
+exports.PaymentInterfaceInteractionTypeKey = 'commercetools-checkout-payment-interface-interaction';
+exports.PaymentInterfaceInteractionTypeDraft = {
+    key: exports.PaymentInterfaceInteractionTypeKey,
+    name: {
+        en: 'commercetools Checkout Payment Interface Interaction Type',
+    },
+    resourceTypeIds: ['payment-interface-interaction'],
+    fieldDefinitions: [
+        {
+            name: 'interactionId',
+            label: {
+                en: 'Interaction ID',
+            },
+            required: true,
+            type: {
+                name: 'String',
+            },
+            inputHint: 'SingleLine',
+        },
+        {
+            name: 'createdAt',
+            label: {
+                en: 'Created At',
+            },
+            required: true,
+            type: {
+                name: 'DateTime',
+            },
+            inputHint: 'SingleLine',
+        },
+        {
+            name: 'request',
+            label: {
+                en: 'Request',
+            },
+            required: false,
+            type: {
+                name: 'String',
+            },
+            inputHint: 'MultiLine',
+        },
+        {
+            name: 'response',
+            label: {
+                en: 'Response',
+            },
+            required: false,
+            type: {
+                name: 'String',
+            },
+            inputHint: 'MultiLine',
+        },
+        {
+            name: 'type',
+            label: {
+                en: 'Type',
+            },
+            required: true,
+            type: {
+                name: 'String',
+            },
+            inputHint: 'SingleLine',
+        },
+    ],
+};
+const GenerateInterfaceInteractionCustomFieldsDraft = (fields) => {
+    return {
+        type: {
+            key: exports.PaymentInterfaceInteractionTypeKey,
+            typeId: 'type',
+        },
+        fields: fields,
+    };
+};
+exports.GenerateInterfaceInteractionCustomFieldsDraft = GenerateInterfaceInteractionCustomFieldsDraft;

package/dist/custom-types/payment-methods/card.d.ts

@@ -0,0 +1,12 @@
+import { CustomFieldsDraft, TypeDraft } from '@commercetools/platform-sdk';
+export declare const CardDetailsTypeKey = "commercetools-checkout-card-details";
+export declare const CardDetailsTypeDraft: TypeDraft;
+export type CardDetailsFields = {
+    brand?: string;
+    lastFour?: string;
+    bin?: string;
+    expiryMonth?: number;
+    expiryYear?: number;
+    storePaymentMethod?: boolean;
+};
+export declare const GenerateCardDetailsCustomFieldsDraft: (fields: CardDetailsFields) => CustomFieldsDraft;

package/dist/custom-types/payment-methods/card.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateCardDetailsCustomFieldsDraft = exports.CardDetailsTypeDraft = exports.CardDetailsTypeKey = void 0;
+const shared_1 = require("./shared");
+exports.CardDetailsTypeKey = 'commercetools-checkout-card-details';
+exports.CardDetailsTypeDraft = {
+    key: exports.CardDetailsTypeKey,
+    name: {
+        en: 'Card payment details',
+    },
+    resourceTypeIds: ['payment-method-info', 'payment-method'],
+    fieldDefinitions: [
+        {
+            name: 'brand',
+            label: {
+                en: 'Card Brand',
+            },
+            type: {
+                name: 'String',
+            },
+            required: false,
+        },
+        {
+            name: 'lastFour',
+            label: {
+                en: 'Last four digits of the card',
+            },
+            type: {
+                name: 'String',
+            },
+            required: false,
+        },
+        {
+            name: 'bin',
+            label: {
+                en: 'Card BIN',
+            },
+            type: {
+                name: 'String',
+            },
+            required: false,
+        },
+        {
+            name: 'expiryMonth',
+            label: {
+                en: 'Expiry Month',
+            },
+            type: {
+                name: 'Number',
+            },
+            required: false,
+        },
+        {
+            name: 'expiryYear',
+            label: {
+                en: 'Expiry Year',
+            },
+            type: {
+                name: 'Number',
+            },
+            required: false,
+        },
+        shared_1.StorePaymentMethodFieldDefinition,
+    ],
+};
+const GenerateCardDetailsCustomFieldsDraft = (fields) => {
+    return {
+        type: {
+            key: exports.CardDetailsTypeKey,
+            typeId: 'type',
+        },
+        fields: fields,
+    };
+};
+exports.GenerateCardDetailsCustomFieldsDraft = GenerateCardDetailsCustomFieldsDraft;

package/dist/custom-types/payment-methods/sepa.d.ts

@@ -0,0 +1,8 @@
+import { CustomFieldsDraft, TypeDraft } from '@commercetools/platform-sdk';
+export declare const SepaDetailsTypeKey = "commercetools-checkout-sepa-details";
+export declare const SepaDetailsTypeDraft: TypeDraft;
+export type SepaDetailsFields = {
+    lastFour?: string;
+    storePaymentMethod?: boolean;
+};
+export declare const GenerateSepaDetailsCustomFieldsDraft: (fields: SepaDetailsFields) => CustomFieldsDraft;

package/dist/custom-types/payment-methods/sepa.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateSepaDetailsCustomFieldsDraft = exports.SepaDetailsTypeDraft = exports.SepaDetailsTypeKey = void 0;
+const shared_1 = require("./shared");
+exports.SepaDetailsTypeKey = 'commercetools-checkout-sepa-details';
+exports.SepaDetailsTypeDraft = {
+    key: exports.SepaDetailsTypeKey,
+    name: {
+        en: 'SEPA Direct Debit details',
+    },
+    resourceTypeIds: ['payment-method-info', 'payment-method'],
+    fieldDefinitions: [
+        {
+            name: 'lastFour',
+            label: {
+                en: 'Last four digits of IBAN',
+            },
+            type: {
+                name: 'String',
+            },
+            required: false,
+        },
+        shared_1.StorePaymentMethodFieldDefinition,
+    ],
+};
+const GenerateSepaDetailsCustomFieldsDraft = (fields) => {
+    return {
+        type: {
+            key: exports.SepaDetailsTypeKey,
+            typeId: 'type',
+        },
+        fields: fields,
+    };
+};
+exports.GenerateSepaDetailsCustomFieldsDraft = GenerateSepaDetailsCustomFieldsDraft;

package/dist/custom-types/payment-methods/shared.d.ts

@@ -0,0 +1,2 @@
+import { FieldDefinition } from '@commercetools/platform-sdk';
+export declare const StorePaymentMethodFieldDefinition: FieldDefinition;

package/dist/custom-types/payment-methods/shared.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorePaymentMethodFieldDefinition = void 0;
+exports.StorePaymentMethodFieldDefinition = {
+    name: 'storePaymentMethod',
+    label: {
+        en: 'Store the payment method',
+    },
+    type: {
+        name: 'Boolean',
+    },
+    required: false,
+};

package/dist/errorx/errorx.d.ts

@@ -9,6 +9,7 @@ export type ErrorxBaseOpts = {
     message: string;
     code: string;
     httpErrorStatus: number;
+    detailedErrorMessage?: string;
 };
 export type ErrorxOpts = ErrorxBaseOpts & ErrorxAdditionalOpts;
 /**
@@ -18,6 +19,7 @@ export declare class Errorx extends Error {
     code: string;
     httpErrorStatus: number;
     cause?: Error | unknown;
+    detailedErrorMessage?: string;
     privateFields?: object;
     privateMessage?: string;
     fields?: object;

package/dist/errorx/errorx.js

@@ -8,6 +8,7 @@ class Errorx extends Error {
     code;
     httpErrorStatus;
     cause;
+    detailedErrorMessage;
     privateFields;
     privateMessage;
     fields;
@@ -20,6 +21,9 @@ class Errorx extends Error {
         if (opts.cause) {
             this.cause = opts.cause;
         }
+        if (opts.detailedErrorMessage) {
+            this.detailedErrorMessage = opts.detailedErrorMessage;
+        }
         if (opts.privateFields) {
             this.privateFields = opts.privateFields;
         }

package/dist/index.d.ts

@@ -5,12 +5,14 @@ import { DefaultCartService } from './commercetools/services/ct-cart.service';
 import { DefaultOrderService } from './commercetools/services/ct-order.service';
 import { DefaultPaymentService } from './commercetools/services/ct-payment.service';
 import { DefaultPaymentMethodService } from './commercetools/services/ct-payment-method.service';
+import { DefaultCustomTypeService } from './commercetools/services/ct-custom-type.service';
 import { Logger } from './logger';
 export * from './api';
 export * from './commercetools';
 export * from './errorx';
 export * from './logger';
 export * from './security';
+export * from './custom-types';
 export declare const setupPaymentSDK: (opts: {
     authUrl: string;
     apiUrl: string;
@@ -29,6 +31,7 @@ export declare const setupPaymentSDK: (opts: {
     ctOrderService: DefaultOrderService;
     ctPaymentService: DefaultPaymentService;
     ctPaymentMethodService: DefaultPaymentMethodService;
+    ctCustomTypeService: DefaultCustomTypeService;
     ctAuthorizationService: DefaultAuthorizationService;
     contextProvider: RequestContextProvider;
     sessionHeaderAuthHookFn: SessionHeaderAuthenticationHook;

package/dist/index.js

@@ -23,6 +23,7 @@ const ct_order_service_1 = require("./commercetools/services/ct-order.service");
 const ct_payment_service_1 = require("./commercetools/services/ct-payment.service");
 const ct_payment_method_service_1 = require("./commercetools/services/ct-payment-method.service");
 const ct_session_service_1 = require("./commercetools/services/ct-session.service");
+const ct_custom_type_service_1 = require("./commercetools/services/ct-custom-type.service");
 const base_decorator_1 = require("./fetch/decorators/base.decorator");
 const monitoring_decorator_1 = require("./fetch/decorators/monitoring.decorator");
 const logger_1 = require("./logger");
@@ -32,6 +33,7 @@ __exportStar(require("./commercetools"), exports);
 __exportStar(require("./errorx"), exports);
 __exportStar(require("./logger"), exports);
 __exportStar(require("./security"), exports);
+__exportStar(require("./custom-types"), exports);
 const setupPaymentSDK = (opts) => {
     const contextProvider = new api_1.RequestContextProvider({
         getContextFn: opts.getContextFn,
@@ -66,6 +68,7 @@ const setupPaymentSDK = (opts) => {
     const ctOrderService = new ct_order_service_1.DefaultOrderService({ ctAPI, logger });
     const ctPaymentService = new ct_payment_service_1.DefaultPaymentService({ ctAPI, logger });
     const ctPaymentMethodService = new ct_payment_method_service_1.DefaultPaymentMethodService({ ctAPI, logger });
+    const ctCustomTypeService = new ct_custom_type_service_1.DefaultCustomTypeService({ ctAPI, logger });
     const oauth2Service = new security_1.DefaultOauth2Service({ logger });
     const jwtService = new security_1.DefaultJWTService({
         jwksUrl: opts.jwksUrl,
@@ -135,6 +138,7 @@ const setupPaymentSDK = (opts) => {
         ctOrderService,
         ctPaymentService,
         ctPaymentMethodService,
+        ctCustomTypeService,
         ctAuthorizationService,
         contextProvider,
         sessionHeaderAuthHookFn,

package/dist/security/authn/session-header-authn-manager.js

@@ -19,6 +19,7 @@ class SessionHeaderAuthenticationManager {
                 allowedPaymentMethods: this.sessionService.getAllowedPaymentMethodsFromSession(session),
                 processorUrl: this.sessionService.getProcessorUrlFromSession(session),
                 paymentInterface: this.sessionService.getPaymentInterfaceFromSession(session),
+                checkoutTransactionItemId: this.sessionService.getCheckoutTransactionItemIdFromSession(session),
                 merchantReturnUrl: this.sessionService.getMerchantReturnUrlFromSession(session),
                 futureOrderNumber: this.sessionService.getFutureOrderNumberFromSession(session),
                 giftCardPlannedAmount: this.sessionService.getGiftCardPlannedAmountFromSession(session),

package/dist/security/authn/session-query-param-authn-manager.js

@@ -19,6 +19,7 @@ class SessionQueryParamAuthenticationManager {
                 allowedPaymentMethods: this.sessionService.getAllowedPaymentMethodsFromSession(session),
                 processorUrl: this.sessionService.getProcessorUrlFromSession(session),
                 paymentInterface: this.sessionService.getPaymentInterfaceFromSession(session),
+                checkoutTransactionItemId: this.sessionService.getCheckoutTransactionItemIdFromSession(session),
                 merchantReturnUrl: this.sessionService.getMerchantReturnUrlFromSession(session),
                 futureOrderNumber: this.sessionService.getFutureOrderNumberFromSession(session),
             });

package/dist/security/authn/types/authn.type.d.ts

@@ -20,7 +20,11 @@ export type SessionPrincipal = {
     cartId: string;
     allowedPaymentMethods: string[];
     processorUrl: string;
+    /**
+     * @deprecated use checkoutTransactionItemId instead
+     */
     paymentInterface?: string;
+    checkoutTransactionItemId?: string;
     merchantReturnUrl?: string;
     futureOrderNumber?: string;
     giftCardPlannedAmount?: Money;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commercetools/connect-payments-sdk",
-  "version": "0.24.0",
+  "version": "0.25.1",
   "description": "Payment SDK for commercetools payment connectors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -16,7 +16,7 @@
   "license": "ISC",
   "dependencies": {
     "@commercetools-backend/loggers": "24.5.0",
-    "@commercetools/platform-sdk": "8.14.0",
+    "@commercetools/platform-sdk": "8.18.0",
     "@commercetools/ts-client": "3.4.1",
     "jsonwebtoken": "9.0.2",
     "jwks-rsa": "3.2.0",