@commercetools/connect-payments-sdk 0.23.1 → 0.25.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @commercetools/connect-payments-sdk
 
+## 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
+
+- bdd4f33: Add a new api and service for interacting with the CT payment-methods APIs.
+
 ## 0.23.1
 
 ### Patch 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.d.ts

@@ -0,0 +1,12 @@
+import { PaymentMethod, PaymentMethodDraft, PaymentMethodPagedQueryResponse } from '@commercetools/platform-sdk';
+import { APIOpts, CheckIfExistsByPredicate, DeletePaymentMethod, FindPaymentMethods, GetPaymentMethod, PaymentMethodAPI, UpdatePaymentMethod } from '../types/api.type';
+import { CommercetoolsBaseAPI } from './base-api';
+export declare class CommercetoolsPaymentMethodAPI extends CommercetoolsBaseAPI implements PaymentMethodAPI {
+    constructor(opts: APIOpts);
+    get(opts: GetPaymentMethod): Promise<PaymentMethod>;
+    checkIfExistsByPredicate(opts: CheckIfExistsByPredicate): Promise<boolean>;
+    find(opts: FindPaymentMethods): Promise<PaymentMethodPagedQueryResponse>;
+    create(draft: PaymentMethodDraft): Promise<PaymentMethod>;
+    update(opts: UpdatePaymentMethod): Promise<PaymentMethod>;
+    delete(opts: DeletePaymentMethod): Promise<PaymentMethod>;
+}

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

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommercetoolsPaymentMethodAPI = void 0;
+const base_api_1 = require("./base-api");
+class CommercetoolsPaymentMethodAPI extends base_api_1.CommercetoolsBaseAPI {
+    constructor(opts) {
+        super(opts);
+        Object.setPrototypeOf(this, CommercetoolsPaymentMethodAPI.prototype);
+    }
+    get(opts) {
+        return this.executeCall(this.client.paymentMethods().withId({ ID: opts.id }).get().execute());
+    }
+    async checkIfExistsByPredicate(opts) {
+        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
+            .paymentMethods()
+            .get({
+            queryArgs: {
+                where: opts.queryString,
+            },
+        })
+            .execute());
+    }
+    create(draft) {
+        return this.executeCall(this.client
+            .paymentMethods()
+            .post({
+            body: draft,
+        })
+            .execute());
+    }
+    update(opts) {
+        return this.executeCall(this.client
+            .paymentMethods()
+            .withId({ ID: opts.resource.id })
+            .post({
+            body: {
+                version: opts.resource.version,
+                actions: opts.actions,
+            },
+        })
+            .execute());
+    }
+    delete(opts) {
+        return this.executeCall(this.client
+            .paymentMethods()
+            .withId({ ID: opts.id })
+            .delete({
+            queryArgs: {
+                version: opts.version,
+            },
+        })
+            .execute());
+    }
+}
+exports.CommercetoolsPaymentMethodAPI = CommercetoolsPaymentMethodAPI;

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

@@ -1,11 +1,13 @@
 import { ContextProvider, RequestContextData } from '../../api';
-import { CartAPI, CommercetoolsAPI, CommercetoolsClient, OrderAPI, PaymentAPI } 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;
     cart: CartAPI;
     payment: PaymentAPI;
     order: OrderAPI;
+    paymentMethod: PaymentMethodAPI;
+    customType: CustomTypeAPI;
     private logger;
     constructor(opts: {
         clientId: string;

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

@@ -5,19 +5,25 @@ const platform_sdk_1 = require("@commercetools/platform-sdk");
 const ts_client_1 = require("@commercetools/ts-client");
 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;
     cart;
     payment;
     order;
+    paymentMethod;
+    customType;
     logger;
     constructor(opts) {
         this.client = createClient(opts);
         this.cart = new cart_api_1.CommercetoolsCartAPI({ client: this.client });
         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;
     }
 }
@@ -37,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

@@ -3,7 +3,10 @@ export { PaymentService as CommercetoolsPaymentService, TransactionData, UpdateP
 export { SessionService as CommercetoolsSessionService, Session } from './types/session.type';
 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, } 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/index.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaxRateConverter = exports.CurrencyConverters = void 0;
+exports.TaxRateConverter = exports.CurrencyConverters = exports.CommercetoolsPaymentMethodTypes = void 0;
+exports.CommercetoolsPaymentMethodTypes = __importStar(require("./types/payment-method.type"));
 exports.CurrencyConverters = __importStar(require("./helpers/currency.converter"));
 exports.TaxRateConverter = __importStar(require("./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.d.ts

@@ -0,0 +1,18 @@
+import { FindPaymentMethod, GetPaymentMethod, DeletePaymentMethod, PaymentMethodService, PaymentMethodServiceOptions, UpdatePaymentMethod, DoesTokenBelongToCustomer, GetByTokenValuePaymentMethod, SavePaymentMethodDraft } from '../types/payment-method.type';
+import { PaymentMethod, PaymentMethodPagedQueryResponse } from '@commercetools/platform-sdk';
+/**
+ * This is the default implementation of the PamentMethodService interface.
+ */
+export declare class DefaultPaymentMethodService implements PaymentMethodService {
+    private ctAPI;
+    private logger;
+    constructor(opts: PaymentMethodServiceOptions);
+    find(opts: FindPaymentMethod): Promise<PaymentMethodPagedQueryResponse>;
+    get(opts: GetPaymentMethod): Promise<PaymentMethod>;
+    getByTokenValue(opts: GetByTokenValuePaymentMethod): Promise<PaymentMethod>;
+    doesTokenBelongsToCustomer(opts: DoesTokenBelongToCustomer): Promise<boolean>;
+    update(opts: UpdatePaymentMethod): Promise<PaymentMethod>;
+    save(opts: SavePaymentMethodDraft): Promise<PaymentMethod>;
+    delete(opts: DeletePaymentMethod): Promise<PaymentMethod>;
+    private ensurePaymentMethodBelongsToGivenCustomer;
+}

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

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultPaymentMethodService = void 0;
+const errorx_1 = require("../../errorx");
+/**
+ * This is the default implementation of the PamentMethodService interface.
+ */
+class DefaultPaymentMethodService {
+    ctAPI;
+    logger;
+    constructor(opts) {
+        this.ctAPI = opts.ctAPI;
+        this.logger = opts.logger;
+    }
+    async find(opts) {
+        const whereFilters = [];
+        whereFilters.push(`customer(id="${opts.customerId}")`);
+        whereFilters.push(`paymentInterface="${opts.paymentInterface}"`);
+        if (opts.interfaceAccount) {
+            whereFilters.push(`interfaceAccount="${opts.interfaceAccount}"`);
+        }
+        const whereFilter = whereFilters.join(' and ');
+        return await this.ctAPI.paymentMethod.find({
+            queryString: whereFilter,
+        });
+    }
+    async get(opts) {
+        const paymentMethods = await this.find({
+            customerId: opts.customerId,
+            paymentInterface: opts.paymentInterface,
+            interfaceAccount: opts.interfaceAccount,
+        });
+        const paymentMethodMatchesId = paymentMethods.results.find((pm) => opts.id === pm.id);
+        if (!paymentMethodMatchesId) {
+            throw new errorx_1.ErrorResourceNotFound(opts.id);
+        }
+        return paymentMethodMatchesId;
+    }
+    async getByTokenValue(opts) {
+        const paymentMethods = await this.find({
+            customerId: opts.customerId,
+            paymentInterface: opts.paymentInterface,
+            interfaceAccount: opts.interfaceAccount,
+        });
+        const paymentMethodsMatchWithTokenValue = paymentMethods.results.filter((pm) => opts.tokenValue === pm.token?.value);
+        if (paymentMethodsMatchWithTokenValue.length > 1) {
+            throw new errorx_1.ErrorInternalConstraintViolated('Found more then one payment method with the same token value.', {
+                privateFields: {
+                    customerId: opts.customerId,
+                    paymentMethodIds: paymentMethodsMatchWithTokenValue.map((pm) => pm.id),
+                    paymentInterface: opts.paymentInterface,
+                    interfaceAccount: opts.interfaceAccount,
+                },
+            });
+        }
+        if (paymentMethodsMatchWithTokenValue.length === 0) {
+            throw new errorx_1.ErrorResourceNotFound(opts.customerId, {
+                privateFields: {
+                    customerId: opts.customerId,
+                    paymentInterface: opts.paymentInterface,
+                    interfaceAccount: opts.interfaceAccount,
+                },
+            });
+        }
+        return paymentMethodsMatchWithTokenValue[0];
+    }
+    async doesTokenBelongsToCustomer(opts) {
+        try {
+            const paymentMethod = await this.getByTokenValue({
+                customerId: opts.customerId,
+                paymentInterface: opts.paymentInterface,
+                interfaceAccount: opts.interfaceAccount,
+                tokenValue: opts.tokenValue,
+            });
+            return paymentMethod !== undefined;
+        }
+        catch (error) {
+            if (error instanceof errorx_1.ErrorResourceNotFound) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    async update(opts) {
+        await this.ensurePaymentMethodBelongsToGivenCustomer(opts.resource.id, opts.customerId);
+        return this.ctAPI.paymentMethod.update({
+            actions: opts.actions,
+            resource: opts.resource,
+        });
+    }
+    async save(opts) {
+        const paymentMethodExistsWithSameTokenValue = await this.doesTokenBelongsToCustomer({
+            customerId: opts.customerId,
+            paymentInterface: opts.paymentInterface,
+            interfaceAccount: opts.interfaceAccount,
+            tokenValue: opts.token,
+        });
+        if (paymentMethodExistsWithSameTokenValue) {
+            throw new errorx_1.ErrorInternalConstraintViolated('A payment method with the same "token.value" already exists.', {
+                privateFields: {
+                    customerId: opts.customerId,
+                    paymentInterface: opts.paymentInterface,
+                    interfaceAccount: opts.interfaceAccount,
+                },
+            });
+        }
+        return await this.ctAPI.paymentMethod.create({
+            customer: {
+                id: opts.customerId,
+                typeId: 'customer',
+            },
+            paymentInterface: opts.paymentInterface,
+            interfaceAccount: opts.interfaceAccount,
+            method: opts.method,
+            default: false,
+            paymentMethodStatus: 'Active',
+            token: {
+                value: opts.token,
+            },
+            ...(opts.customFields ? { custom: opts.customFields } : {}),
+        });
+    }
+    async delete(opts) {
+        await this.ensurePaymentMethodBelongsToGivenCustomer(opts.id, opts.customerId);
+        return await this.ctAPI.paymentMethod.delete({
+            id: opts.id,
+            version: opts.version,
+        });
+    }
+    async ensurePaymentMethodBelongsToGivenCustomer(paymentMethodId, customerId) {
+        const predicate = `id="${paymentMethodId}" and customer(id="${customerId}")`;
+        const doesGivenPaymentMethodBelongToGivenCustomer = await this.ctAPI.paymentMethod.checkIfExistsByPredicate({
+            queryString: predicate,
+        });
+        if (!doesGivenPaymentMethodBelongToGivenCustomer) {
+            throw new errorx_1.ErrorInternalConstraintViolated(`The provided payment-method '${paymentMethodId}' does not have a customer '${customerId}' set`, {
+                fields: {
+                    paymentMethodId: paymentMethodId,
+                    customerId: customerId,
+                },
+                privateFields: {
+                    predicateQueryString: predicate,
+                },
+            });
+        }
+    }
+}
+exports.DefaultPaymentMethodService = DefaultPaymentMethodService;

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,9 +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[];
@@ -26,5 +41,6 @@ export declare class DefaultPaymentService implements PaymentService {
     private handleTransactionUpdates;
     private shouldUpdateTransactionState;
     private shouldUpdateInteractionId;
+    private shouldUpdateTransactionInterfaceId;
     private throwMultipleMatchingTransactionsError;
 }