@commercetools/connect-payments-sdk 0.23.1 → 0.24.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @commercetools/connect-payments-sdk
 
+## 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/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,78 @@
+"use strict";
+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);
+        Object.setPrototypeOf(this, CommercetoolsPaymentMethodAPI.prototype);
+    }
+    get(opts) {
+        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;
+            }
+        }
+    }
+    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,12 @@
 import { ContextProvider, RequestContextData } from '../../api';
-import { CartAPI, CommercetoolsAPI, CommercetoolsClient, OrderAPI, PaymentAPI } from '../types/api.type';
+import { CartAPI, CommercetoolsAPI, CommercetoolsClient, 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;
     private logger;
     constructor(opts: {
         clientId: string;

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

@@ -5,6 +5,7 @@ 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 crypto_1 = require("crypto");
 class DefaultCommercetoolsAPI {
@@ -12,12 +13,14 @@ class DefaultCommercetoolsAPI {
     cart;
     payment;
     order;
+    paymentMethod;
     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.logger = opts.logger;
     }
 }

package/dist/commercetools/index.d.ts

@@ -3,7 +3,9 @@ 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 * 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, Money, LineItem, CustomLineItem, Address, Transaction, TransactionType, TransactionState, ShippingInfo, PaymentMethod, PaymentMethodToken, PaymentMethodStatus, } 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-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,147 @@
+"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,
+            },
+        });
+    }
+    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

@@ -17,6 +17,7 @@ export declare class DefaultPaymentService implements PaymentService {
     private populateAddTransactionAction;
     private populateChangeTransactionState;
     private populateSetPaymentMethod;
+    private populateSetMethodInfoToken;
     private populateSetCustomType;
     private populateAddInterfaceInteractions;
     findMatchingTransactions(payment: Payment, transaction: TransactionData): Transaction[];

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

@@ -67,6 +67,9 @@ class DefaultPaymentService {
         if (!payment.paymentMethodInfo?.method && updateInfo.paymentMethod) {
             actions.push(this.populateSetPaymentMethod(updateInfo.paymentMethod));
         }
+        if (!payment.paymentMethodInfo?.token && updateInfo.token) {
+            actions.push(this.populateSetMethodInfoToken(updateInfo.token));
+        }
         if (updateInfo.transaction) {
             const transactionChanges = this.consolidateTransactionChanges(payment, updateInfo.transaction);
             if (transactionChanges.length > 0) {
@@ -116,6 +119,14 @@ class DefaultPaymentService {
             method: paymentMethod,
         };
     }
+    populateSetMethodInfoToken(token) {
+        return {
+            action: 'setMethodInfoToken',
+            token: {
+                value: token,
+            },
+        };
+    }
     populateSetCustomType(customFields) {
         return {
             action: 'setCustomType',

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

@@ -1,4 +1,4 @@
-import { Cart, CartPagedQueryResponse, OrderPagedQueryResponse, Payment, PaymentDraft, PaymentPagedQueryResponse, PaymentUpdateAction } from '@commercetools/platform-sdk';
+import { Cart, CartPagedQueryResponse, OrderPagedQueryResponse, Payment, PaymentDraft, PaymentPagedQueryResponse, PaymentUpdateAction, PaymentMethod, PaymentMethodDraft, PaymentMethodPagedQueryResponse, PaymentMethodUpdateAction } 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;
@@ -24,6 +24,23 @@ export type OauthToken = {
     scope: string;
     refreshToken?: string;
 };
+export type UpdatePaymentMethod = {
+    resource: UpdateResource;
+    actions: PaymentMethodUpdateAction[];
+};
+export type FindPaymentMethods = {
+    queryString: string;
+};
+export type GetPaymentMethod = {
+    id: string;
+};
+export type DeletePaymentMethod = {
+    id: string;
+    version: number;
+};
+export type CheckIfExistsByPredicate = {
+    queryString: string;
+};
 export interface AuthorizationAPI {
     getToken(): Promise<OauthToken>;
 }
@@ -38,6 +55,14 @@ export interface PaymentAPI {
     createPayment(paymentDraft: PaymentDraft): Promise<Payment>;
     updatePayment(opts: UpdatePayment): Promise<Payment>;
 }
+export interface PaymentMethodAPI {
+    find(opts: FindPaymentMethods): Promise<PaymentMethodPagedQueryResponse>;
+    get(opts: GetPaymentMethod): Promise<PaymentMethod>;
+    create(draft: PaymentMethodDraft): Promise<PaymentMethod>;
+    update(opts: UpdatePaymentMethod): Promise<PaymentMethod>;
+    delete(opts: DeletePaymentMethod): Promise<PaymentMethod>;
+    checkIfExistsByPredicate(opts: CheckIfExistsByPredicate): Promise<boolean>;
+}
 export interface OrderAPI {
     find(queryPredicate: string): Promise<OrderPagedQueryResponse>;
 }
@@ -45,4 +70,5 @@ export interface CommercetoolsAPI {
     cart: CartAPI;
     payment: PaymentAPI;
     order: OrderAPI;
+    paymentMethod: PaymentMethodAPI;
 }

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

@@ -0,0 +1,108 @@
+import { CommercetoolsAPI, UpdateResource } from './api.type';
+import { Logger } from '../../logger';
+import { PaymentMethod, PaymentMethodPagedQueryResponse, PaymentMethodUpdateAction } from '@commercetools/platform-sdk';
+export type PaymentMethodServiceOptions = {
+    ctAPI: CommercetoolsAPI;
+    logger: Logger;
+};
+export type FindPaymentMethod = {
+    customerId: string;
+    paymentInterface: string;
+    interfaceAccount?: string;
+};
+export type GetPaymentMethod = {
+    customerId: string;
+    id: string;
+    paymentInterface: string;
+    interfaceAccount?: string;
+};
+export type GetByTokenValuePaymentMethod = {
+    customerId: string;
+    tokenValue: string;
+    paymentInterface: string;
+    interfaceAccount?: string;
+};
+export type DoesTokenBelongToCustomer = {
+    customerId: string;
+    tokenValue: string;
+    paymentInterface: string;
+    interfaceAccount?: string;
+};
+export type DeletePaymentMethod = {
+    customerId: string;
+    id: string;
+    version: number;
+};
+export type UpdatePaymentMethod = {
+    customerId: string;
+    resource: UpdateResource;
+    actions: PaymentMethodUpdateAction[];
+};
+export type SavePaymentMethodDraft = {
+    customerId: string;
+    token: string;
+    paymentInterface: string;
+    interfaceAccount?: string;
+    method: string;
+};
+/**
+ * Payment methods service interface exposes methods to interact with the commercetools platform API.
+ */
+export interface PaymentMethodService {
+    /**
+     * Finds all of the payment-methods that match with the given parameters.
+     *
+     * @param opts the parameters to search by
+     *
+     * @returns a paged list of payment-methods
+     */
+    find(opts: FindPaymentMethod): Promise<PaymentMethodPagedQueryResponse>;
+    /**
+     * Returns a payment-method by the given ID which must belong to the given customerId.
+     *
+     * @param opts
+     *
+     * @returns the payment-method
+     */
+    get(opts: GetPaymentMethod): Promise<PaymentMethod>;
+    /**
+     * Returns a payment-method by the given tokenValue which must belong to the given customerId and must be unique.
+     *
+     * @param opts
+     *
+     * @returns the payment-method
+     */
+    getByTokenValue(opts: GetByTokenValuePaymentMethod): Promise<PaymentMethod>;
+    /**
+     * Returns true if the given token belongs to the given customer for any payment-method.
+     *
+     * @param opts
+     *
+     * @returns true if the given token belongs to the customer for any payment method, false otherwise.
+     */
+    doesTokenBelongsToCustomer(opts: DoesTokenBelongToCustomer): Promise<boolean>;
+    /**
+     * Saves a new payment-method given the draft payload. The customer attribute is mandatory.
+     *
+     * @param opts the payment-method draft
+     *
+     * @returns the newly created payment-method
+     */
+    save(opts: SavePaymentMethodDraft): Promise<PaymentMethod>;
+    /**
+     * Updates an existing payment-method with the given list of update actions. The payment-method must belong to the given customerId.
+     *
+     * @param opts the list of update actions to apply
+     *
+     * @returns the updated payment-method
+     */
+    update(opts: UpdatePaymentMethod): Promise<PaymentMethod>;
+    /**
+     * Deletes the given payment-method
+     *
+     * @param opts the payment-method to delete
+     *
+     * @returns returns the final state of the payment-method before it's deleted
+     */
+    delete(opts: DeletePaymentMethod): Promise<PaymentMethod>;
+}

package/dist/commercetools/types/payment-method.type.js

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

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

@@ -34,6 +34,7 @@ export type UpdatePayment = {
     transaction?: TransactionData;
     paymentMethod?: string;
     customFields?: CustomFieldsDraft;
+    token?: string;
 };
 export type FindTransaction = {
     payment: Payment;

package/dist/index.d.ts

@@ -4,6 +4,7 @@ import { DefaultAuthorizationService } from './commercetools/services/ct-authori
 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 { Logger } from './logger';
 export * from './api';
 export * from './commercetools';
@@ -27,6 +28,7 @@ export declare const setupPaymentSDK: (opts: {
     ctCartService: DefaultCartService;
     ctOrderService: DefaultOrderService;
     ctPaymentService: DefaultPaymentService;
+    ctPaymentMethodService: DefaultPaymentMethodService;
     ctAuthorizationService: DefaultAuthorizationService;
     contextProvider: RequestContextProvider;
     sessionHeaderAuthHookFn: SessionHeaderAuthenticationHook;

package/dist/index.js

@@ -21,6 +21,7 @@ const ct_authorization_service_1 = require("./commercetools/services/ct-authoriz
 const ct_cart_service_1 = require("./commercetools/services/ct-cart.service");
 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 base_decorator_1 = require("./fetch/decorators/base.decorator");
 const monitoring_decorator_1 = require("./fetch/decorators/monitoring.decorator");
@@ -64,6 +65,7 @@ const setupPaymentSDK = (opts) => {
     const ctCartService = new ct_cart_service_1.DefaultCartService({ ctAPI, logger, contextProvider });
     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 oauth2Service = new security_1.DefaultOauth2Service({ logger });
     const jwtService = new security_1.DefaultJWTService({
         jwksUrl: opts.jwksUrl,
@@ -132,6 +134,7 @@ const setupPaymentSDK = (opts) => {
         ctCartService,
         ctOrderService,
         ctPaymentService,
+        ctPaymentMethodService,
         ctAuthorizationService,
         contextProvider,
         sessionHeaderAuthHookFn,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@commercetools/connect-payments-sdk",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "Payment SDK for commercetools payment connectors",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -15,9 +15,9 @@
   ],
   "license": "ISC",
   "dependencies": {
-    "@commercetools-backend/loggers": "24.1.0",
-    "@commercetools/platform-sdk": "8.10.0",
-    "@commercetools/ts-client": "3.4.0",
+    "@commercetools-backend/loggers": "24.5.0",
+    "@commercetools/platform-sdk": "8.14.0",
+    "@commercetools/ts-client": "3.4.1",
     "jsonwebtoken": "9.0.2",
     "jwks-rsa": "3.2.0",
     "lodash": "4.17.21",