@unchainedshop/api 3.1.10 → 4.0.0-rc.2

package/src/resolvers/mutations/products/reorderProductMedia.ts

@@ -3,7 +3,7 @@ import { Context } from '../../../context.js';
 
 export default async function reorderProductMedia(
   root: never,
-  params: { sortKeys: Array<{ productMediaId: string; sortKey: number }> },
+  params: { sortKeys: { productMediaId: string; sortKey: number }[] },
   { modules, userId }: Context,
 ) {
   const { sortKeys = [] } = params;

package/src/resolvers/mutations/products/updateProductMediaTexts.ts

@@ -5,7 +5,7 @@ import { ProductMediaNotFoundError, InvalidIdError } from '../../../errors.js';
 
 export default async function updateProductMediaTexts(
   root: never,
-  { productMediaId, texts }: { productMediaId: string; texts: Array<ProductMediaText> },
+  { productMediaId, texts }: { productMediaId: string; texts: ProductMediaText[] },
   { modules, userId }: Context,
 ) {
   log(`mutation updateProductMediaTexts ${productMediaId}`, { userId });

package/src/resolvers/mutations/products/updateProductVariationTexts.ts

@@ -8,7 +8,7 @@ export default async function F(
   params: {
     productVariationId: string;
     productVariationOptionValue?: string;
-    texts: Array<ProductVariationText>;
+    texts: ProductVariationText[];
   },
   { modules, userId }: Context,
 ) {

package/src/resolvers/mutations/quotations/requestQuotation.ts

@@ -4,10 +4,10 @@ import { ProductNotFoundError, InvalidIdError } from '../../../errors.js';
 
 export default async function requestQuotation(
   root: never,
-  params: { productId: string; configuration: Array<{ key: string; value: string }> },
+  params: { productId: string; configuration: { key: string; value: string }[] },
   context: Context,
 ) {
-  const { countryContext, currencyContext, modules, services, userId } = context;
+  const { countryCode, currencyCode, modules, services, userId } = context;
   const { productId, configuration } = params;
 
   log(`mutation requestQuotation ${productId} ${configuration ? JSON.stringify(configuration) : ''}`, {
@@ -22,8 +22,8 @@ export default async function requestQuotation(
   const newQuotation = await modules.quotations.create({
     userId,
     productId,
-    countryCode: countryContext,
-    currency: currencyContext,
+    countryCode,
+    currencyCode,
     configuration,
   });
 

package/src/resolvers/mutations/users/heartbeat.ts

@@ -5,7 +5,7 @@ import { UserNotFoundError } from '../../../errors.js';
 export default async function heartbeat(
   root: never,
   _: any,
-  { countryContext, localeContext, modules, remoteAddress, remotePort, userId, getHeader }: Context,
+  { countryCode, locale, modules, remoteAddress, remotePort, userId, getHeader }: Context,
 ) {
   log(`mutation heartbeat`, { userId });
 
@@ -16,8 +16,8 @@ export default async function heartbeat(
   }
 
   const user = await modules.users.updateHeartbeat(userId, {
-    countryCode: countryContext,
-    locale: localeContext.baseName,
+    countryCode,
+    locale: locale.baseName,
     remoteAddress,
     remotePort,
     userAgent: getHeader('user-agent'),

package/src/resolvers/mutations/users/setRoles.ts

@@ -4,7 +4,7 @@ import { InvalidIdError, UserNotFoundError } from '../../../errors.js';
 
 export default async function setRoles(
   root: never,
-  params: { roles: Array<string>; userId: string },
+  params: { roles: string[]; userId: string },
   { modules, userId }: Context,
 ) {
   const foreignUserId = params.userId;

package/src/resolvers/mutations/users/setUserTags.ts

@@ -4,7 +4,7 @@ import { InvalidIdError, UserNotFoundError } from '../../../errors.js';
 
 export default async function setUserTags(
   root: never,
-  params: { tags: Array<string>; userId: string },
+  params: { tags: string[]; userId: string },
   { modules, userId }: Context,
 ) {
   const normalizedUserId = params.userId;

package/src/resolvers/mutations/warehousing/invalidateToken.ts

@@ -27,9 +27,9 @@ export default async function invalidateToken(
   const product = await modules.products.findProduct({ productId: token.productId });
   if (!product) throw new ProductNotFoundError({ productId: token.productId });
 
-  const virtualProviders = await context.modules.warehousing.findProviders({
-    type: WarehousingProviderType.VIRTUAL,
-  });
+  const virtualProviders = (await context.modules.warehousing.allProviders()).filter(
+    ({ type }) => type === WarehousingProviderType.VIRTUAL,
+  );
 
   const isInvalidateable = await WarehousingDirector.isInvalidateable(
     virtualProviders,

package/src/resolvers/mutations/worker/allocateWork.ts

@@ -3,7 +3,7 @@ import { log } from '@unchainedshop/logger';
 
 export default async function allocateWork(
   root: never,
-  { types, worker }: { types?: Array<string>; worker?: string },
+  { types, worker }: { types?: string[]; worker?: string },
   { modules, userId }: Context,
 ) {
   log(`mutation allocateWork ${(types || []).join(',')} ${worker}`, {

package/src/resolvers/queries/assortments/assortments.ts

@@ -8,7 +8,7 @@ export default async function assortments(
   params: AssortmentQuery & {
     limit?: number;
     offset?: number;
-    sort?: Array<SortOption>;
+    sort?: SortOption[];
   },
   { modules, userId }: Context,
 ) {

package/src/resolvers/queries/countries/countries.ts

@@ -5,7 +5,7 @@ import { Context } from '../../../context.js';
 
 export default async function countries(
   root: never,
-  params: CountryQuery & { limit?: number; offset?: number; sort?: Array<SortOption> },
+  params: CountryQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
   log(

package/src/resolvers/queries/currencies/currencies.ts

@@ -5,7 +5,7 @@ import { Context } from '../../../context.js';
 
 export default async function currencies(
   root: never,
-  params: CurrencyQuery & { limit: number; offset: number; sort?: Array<SortOption> },
+  params: CurrencyQuery & { limit: number; offset: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
   log(

package/src/resolvers/queries/enrollments/enrollments.ts

@@ -8,7 +8,7 @@ export default async function enrollments(
   params: EnrollmentQuery & {
     limit?: number;
     offset?: number;
-    sort?: Array<SortOption>;
+    sort?: SortOption[];
   },
   { modules, userId }: Context,
 ) {

package/src/resolvers/queries/filters/filters.ts

@@ -8,7 +8,7 @@ export default async function filters(
   params: FilterQuery & {
     limit?: number;
     offset?: number;
-    sort?: Array<SortOption>;
+    sort?: SortOption[];
   },
   { modules, userId }: Context,
 ) {

package/src/resolvers/queries/filters/searchAssortments.ts

@@ -4,7 +4,7 @@ import { log } from '@unchainedshop/logger';
 import { QueryStringRequiredError } from '../../../errors.js';
 
 export default async function searchAssortments(root: never, query: SearchQuery, context: Context) {
-  const { services, userId, localeContext } = context;
+  const { services, userId, locale } = context;
   const forceLiveCollection = false;
 
   log(`query search assortments ${JSON.stringify(query)}`, { userId });
@@ -13,6 +13,6 @@ export default async function searchAssortments(root: never, query: SearchQuery,
 
   return services.filters.searchAssortments(query, {
     forceLiveCollection,
-    locale: localeContext,
+    locale,
   });
 }

package/src/resolvers/queries/filters/searchProducts.ts

@@ -15,7 +15,7 @@ export default async function searchProducts(
   },
   context: Context,
 ) {
-  const { modules, services, userId, localeContext } = context;
+  const { modules, services, userId, locale } = context;
   const forceLiveCollection = false;
   const { queryString, includeInactive, filterQuery, assortmentId, ignoreChildAssortments, ...rest } =
     query;
@@ -33,7 +33,7 @@ export default async function searchProducts(
     });
     return services.filters.searchProducts(
       { queryString, includeInactive, filterQuery, productIds, filterIds, ...rest },
-      { forceLiveCollection, locale: localeContext },
+      { forceLiveCollection, locale: locale },
     );
   }
 
@@ -41,6 +41,6 @@ export default async function searchProducts(
 
   return services.filters.searchProducts(
     { queryString, includeInactive, filterQuery, ...rest },
-    { forceLiveCollection, locale: localeContext },
+    { forceLiveCollection, locale: locale },
   );
 }

package/src/resolvers/queries/languages/languages.ts

@@ -5,7 +5,7 @@ import { Context } from '../../../context.js';
 
 export default async function languages(
   root: never,
-  params: LanguageQuery & { limit: number; offset: number; sort?: Array<SortOption> },
+  params: LanguageQuery & { limit: number; offset: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
   log(

package/src/resolvers/queries/orders/orders.ts

@@ -5,7 +5,7 @@ import { Context } from '../../../context.js';
 
 export default async function orders(
   root: never,
-  params: OrderQuery & { limit?: number; offset?: number; sort?: Array<SortOption> },
+  params: OrderQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
   const { includeCarts, limit, offset, queryString } = params;

package/src/resolvers/queries/products/productReviews.ts

@@ -7,7 +7,7 @@ export default async function productReviews(
   params: {
     limit: number;
     offset: number;
-    sort: Array<SortOption>;
+    sort: SortOption[];
     queryString?: string;
   },
   { modules, userId }: Context,

package/src/resolvers/queries/products/products.ts

@@ -6,7 +6,7 @@ import { Context } from '../../../context.js';
 export default async function products(
   root: never,
   params: ProductQuery & {
-    sort: Array<SortOption>;
+    sort: SortOption[];
     limit: number;
     offset: number;
   },

package/src/resolvers/queries/quotations/quotations.ts

@@ -5,7 +5,7 @@ import { Context } from '../../../context.js';
 
 export default async function quotations(
   root: never,
-  params: QuotationQuery & { limit?: number; offset?: number; sort?: Array<SortOption> },
+  params: QuotationQuery & { limit?: number; offset?: number; sort?: SortOption[] },
   { modules, userId }: Context,
 ) {
   log(`query quotations: ${params.limit} ${params.offset}`, { userId });

package/src/resolvers/queries/users/impersonator.ts

@@ -9,5 +9,6 @@ export default async function impersonator(
   log(`query impersonator`, { userId });
 
   if (!impersonatorId) return null;
-  return modules.users.findUserById(impersonatorId);
+
+  return modules.users.findUser({ userId: impersonatorId });
 }

package/src/resolvers/queries/users/user.ts

@@ -7,5 +7,6 @@ export default async function user(
   { modules, userId }: Context,
 ) {
   log(`query user ${params.userId}`, { Id: userId });
+
   return modules.users.findUserById(params.userId || userId);
 }

package/src/resolvers/queries/users/users.ts

@@ -8,7 +8,7 @@ export default async function users(
   params: UserQuery & {
     limit?: number;
     offset?: number;
-    sort?: Array<SortOption>;
+    sort?: SortOption[];
     includeGuests?: boolean;
     emailVerified?: boolean;
     lastLogin?: DateFilterInput;

package/src/resolvers/queries/worker/workQueue.ts

@@ -17,13 +17,13 @@ export default async function workQueue(
     limit?: number;
     offset?: number;
     queryString?: string;
-    status?: Array<WorkStatus>;
-    types?: Array<string>;
+    status?: WorkStatus[];
+    types?: string[];
     created?: {
       start: Date;
       end: Date;
     };
-    sort?: Array<SortOption>;
+    sort?: SortOption[];
   },
   { modules, userId }: Context,
 ) {

package/src/resolvers/type/assortment/assortment-filter-types.ts

@@ -1,26 +1,16 @@
-import { Assortment, AssortmentFilter as AssortmentFilterType } from '@unchainedshop/core-assortments';
-import { Filter } from '@unchainedshop/core-filters';
+import { AssortmentFilter as AssortmentFilterType } from '@unchainedshop/core-assortments';
 import { Context } from '../../../context.js';
 
-type HelperType<T> = (assortmentFilter: AssortmentFilterType, _: never, context: Context) => T;
-
-export type AssortmentFilterHelperTypes = {
-  assortment: HelperType<Promise<Assortment>>;
-  filter: HelperType<Promise<Filter>>;
-};
-
-export const AssortmentFilter: AssortmentFilterHelperTypes = {
-  assortment: async (obj, _, { loaders }) => {
-    const assortment = await loaders.assortmentLoader.load({
+export const AssortmentFilter = {
+  async assortment(obj: AssortmentFilterType, _, { loaders }: Context) {
+    return loaders.assortmentLoader.load({
       assortmentId: obj.assortmentId,
     });
-    return assortment;
   },
 
-  filter: async (obj, _, { loaders }) => {
-    const filter = await loaders.filterLoader.load({
+  async filter(obj: AssortmentFilterType, _, { loaders }: Context) {
+    return loaders.filterLoader.load({
       filterId: obj.filterId,
     });
-    return filter;
   },
 };

package/src/resolvers/type/assortment/assortment-link-types.ts

@@ -3,10 +3,10 @@ import { Assortment, AssortmentLink as AssortmentLinkType } from '@unchainedshop
 
 type HelperType<T> = (assortmentLink: AssortmentLinkType, _: never, context: Context) => T;
 
-export type AssortmentLinkHelperTypes = {
+export interface AssortmentLinkHelperTypes {
   child: HelperType<Promise<Assortment>>;
   parent: HelperType<Promise<Assortment>>;
-};
+}
 
 export const AssortmentLink: AssortmentLinkHelperTypes = {
   child: async (obj, _, { loaders }) => {

package/src/resolvers/type/assortment/assortment-media-types.ts

@@ -11,10 +11,10 @@ export interface AssortmentMediaHelperTypes {
 
 export const AssortmentMedia: AssortmentMediaHelperTypes = {
   async texts(obj, { forceLocale }, requestContext) {
-    const { localeContext, loaders } = requestContext;
+    const { locale, loaders } = requestContext;
     return loaders.assortmentMediaTextLoader.load({
       assortmentMediaId: obj._id,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 

package/src/resolvers/type/assortment/assortment-path-link-types.ts

@@ -13,12 +13,12 @@ export const AssortmentPathLink = {
 
   assortmentTexts: async (
     { childAssortmentId }: AssortmentLink,
-    params: { forceLocale?: string },
-    { loaders, localeContext }: Context,
+    { forceLocale }: { forceLocale?: string },
+    { loaders, locale }: Context,
   ) => {
     const text = await loaders.assortmentTextLoader.load({
       assortmentId: childAssortmentId,
-      locale: params.forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
     return text;
   },

package/src/resolvers/type/assortment/assortment-product-types.ts

@@ -4,10 +4,10 @@ import { Product } from '@unchainedshop/core-products';
 
 type HelperType<T> = (assortmentProduct: AssortmentProductType, _: never, context: Context) => T;
 
-export type AssortmentProductHelperTypes = {
+export interface AssortmentProductHelperTypes {
   assortment: HelperType<Promise<Assortment>>;
   product: HelperType<Promise<Product>>;
-};
+}
 
 export const AssortmentProduct: AssortmentProductHelperTypes = {
   assortment: async (obj, _, { loaders }) => {

package/src/resolvers/type/assortment/assortment-types.ts

@@ -51,7 +51,7 @@ export const AssortmentTypes = {
   },
 
   async filterAssignments(obj: Assortment, _, { modules }: Context) {
-    // TODO: Loader & move default sort to module
+    // TODO: move default sort to module
     return modules.assortments.filters.findFilters(
       {
         assortmentId: obj._id,
@@ -73,7 +73,7 @@ export const AssortmentTypes = {
     params: {
       limit: number;
       offset: number;
-      tags?: Array<string>;
+      tags?: string[];
     },
     { modules, loaders }: Context,
   ) {
@@ -90,7 +90,7 @@ export const AssortmentTypes = {
   },
 
   async productAssignments(obj: Assortment, _, { modules }: Context) {
-    // TODO: Loader & move default sort to core module
+    // TODO: move default sort to core module
     return modules.assortments.products.findAssortmentProducts(
       {
         assortmentId: obj._id,
@@ -102,10 +102,10 @@ export const AssortmentTypes = {
   },
 
   async texts(obj: Assortment, { forceLocale }: { forceLocale?: string }, requestContext: Context) {
-    const { localeContext, loaders } = requestContext;
+    const { locale, loaders } = requestContext;
     return loaders.assortmentTextLoader.load({
       assortmentId: obj._id,
-      locale: forceLocale || localeContext.baseName,
+      locale: forceLocale ? new Intl.Locale(forceLocale) : locale,
     });
   },
 
@@ -132,7 +132,7 @@ export const AssortmentTypes = {
     return services.filters.searchProducts(
       { ...query, productIds, filterIds },
       {
-        locale: requestContext.localeContext,
+        locale: requestContext.locale,
       },
     );
   },

package/src/resolvers/type/bookmark-types.ts

@@ -19,8 +19,7 @@ export const Bookmark: BookmarkHelperTypes = {
     return product;
   },
 
-  user: async (obj, _, { modules }) => {
-    // TODO: use loader
-    return modules.users.findUserById(obj.userId);
+  user: async (obj, _, { loaders }) => {
+    return loaders.userLoader.load({ userId: obj.userId });
   },
 };

package/src/resolvers/type/country-types.ts

@@ -7,17 +7,14 @@ export type HelperType<P, T> = (country: CountryType, params: P, context: Contex
 export interface CountryHelperTypes {
   flagEmoji: HelperType<never, string>;
   isBase: HelperType<never, boolean>;
-  name: HelperType<{ forceLocale: string }, string>;
+  name: HelperType<{ forceLocale?: string }, string>;
   defaultCurrency: HelperType<never, Promise<Currency>>;
 }
 
 export const Country: CountryHelperTypes = {
-  defaultCurrency: async (country, _, { modules }) => {
+  defaultCurrency: async (country, _, { loaders }) => {
     if (country.defaultCurrencyCode) {
-      // TODO: use loader
-      return modules.currencies.findCurrency({
-        isoCode: country.defaultCurrencyCode,
-      });
+      return loaders.currencyLoader.load({ isoCode: country.defaultCurrencyCode });
     }
     return null;
   },
@@ -28,7 +25,7 @@ export const Country: CountryHelperTypes = {
   isBase: (country, _, { modules }: Context) => {
     return modules.countries.isBase(country);
   },
-  name: (country, { forceLocale }, { localeContext, modules }) => {
-    return modules.countries.name(country, forceLocale || localeContext.language);
+  name: (country, { forceLocale }, { locale, modules }) => {
+    return modules.countries.name(country, forceLocale ? new Intl.Locale(forceLocale) : locale);
   },
 };

package/src/resolvers/type/delivery-provider-types.ts

@@ -1,39 +1,9 @@
 import { Context } from '../../context.js';
 import { DeliveryProvider as DeliveryProviderType } from '@unchainedshop/core-delivery';
-import { DeliveryDirector, DeliveryError, DeliveryPricingDirector } from '@unchainedshop/core';
+import { DeliveryDirector, DeliveryPricingDirector } from '@unchainedshop/core';
 
-export type HelperType<P, T> = (provider: DeliveryProviderType, params: P, context: Context) => T;
-
-export interface DeliveryProviderHelperTypes {
-  interface: HelperType<
-    never,
-    {
-      _id: string;
-      label: string;
-      version: string;
-    }
-  >;
-  isActive: HelperType<void, Promise<boolean>>;
-  configurationError: HelperType<never, Promise<DeliveryError>>;
-  simulatedPrice: HelperType<
-    {
-      currency?: string;
-      orderId: string;
-      useNetPrice?: boolean;
-      context: any;
-    },
-    Promise<{
-      amount: number;
-      currencyCode: string;
-      countryCode: string;
-      isTaxable: boolean;
-      isNetPrice: boolean;
-    }>
-  >;
-}
-
-export const DeliveryProvider: DeliveryProviderHelperTypes = {
-  interface(deliveryProvider) {
+export const DeliveryProvider = {
+  interface(deliveryProvider: DeliveryProviderType) {
     const Adapter = DeliveryDirector.getAdapter(deliveryProvider.adapterKey);
     if (!Adapter) return null;
     return {
@@ -43,29 +13,38 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
     };
   },
 
-  async isActive(deliveryProvider, _, requestContext) {
+  async isActive(deliveryProvider: DeliveryProviderType, _: never, requestContext: Context) {
     const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
     return Boolean(director.isActive());
   },
 
-  async configurationError(deliveryProvider, _, requestContext) {
+  async configurationError(deliveryProvider: DeliveryProviderType, _: never, requestContext: Context) {
     const director = await DeliveryDirector.actions(deliveryProvider, {}, requestContext);
     return director.configurationError();
   },
 
   async simulatedPrice(
-    deliveryProvider,
-    { currency: currencyCode, orderId, useNetPrice, context: providerContext },
-    requestContext,
+    deliveryProvider: DeliveryProviderType,
+    {
+      currencyCode: forcedCurrencyCode,
+      orderId,
+      useNetPrice,
+      context: providerContext,
+    }: {
+      currencyCode?: string;
+      orderId: string;
+      useNetPrice?: boolean;
+      context: any;
+    },
+    requestContext: Context,
   ) {
-    const { modules, countryContext: country, user } = requestContext;
+    const { loaders, countryCode, user } = requestContext;
 
-    // TODO: use loader
-    const order = await modules.orders.findOrder({ orderId });
-    const currency = currencyCode || order?.currency || requestContext.currencyContext;
+    const order = await loaders.orderLoader.load({ orderId });
+    const currencyCode = forcedCurrencyCode || order?.currencyCode || requestContext.currencyCode;
     const pricingContext = {
-      country,
-      currency,
+      countryCode,
+      currencyCode,
       provider: deliveryProvider,
       order,
       providerContext,
@@ -80,13 +59,13 @@ export const DeliveryProvider: DeliveryProviderHelperTypes = {
 
     const orderPrice = pricing.total({ useNetPrice }) as {
       amount: number;
-      currency: string;
+      currencyCode: string;
     };
 
     return {
       amount: orderPrice.amount,
-      currencyCode: orderPrice.currency,
-      countryCode: country,
+      currencyCode: orderPrice.currencyCode,
+      countryCode,
       isTaxable: pricing.taxSum() > 0,
       isNetPrice: useNetPrice,
     };

package/src/resolvers/type/enrollment/enrollment-delivery-types.ts

@@ -1,16 +1,10 @@
 import { Context } from '../../../context.js';
-import { DeliveryProvider } from '@unchainedshop/core-delivery';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 
-type HelperType<T> = (enrollmentDelivery: Enrollment['delivery'], _: never, context: Context) => T;
-
-type EnrollmentDeliveryHelperTypes = {
-  provider: HelperType<Promise<DeliveryProvider>>;
-};
-
-export const EnrollmentDelivery: EnrollmentDeliveryHelperTypes = {
-  provider: async ({ deliveryProviderId }, _, { modules }) => {
-    // TODO: use loader
-    return modules.delivery.findProvider({ deliveryProviderId });
+export const EnrollmentDelivery = {
+  provider: async ({ deliveryProviderId }: Enrollment['delivery'], _: never, { loaders }: Context) => {
+    return loaders.deliveryProviderLoader.load({
+      deliveryProviderId,
+    });
   },
 };

package/src/resolvers/type/enrollment/enrollment-payment-types.ts

@@ -1,17 +1,9 @@
 import { Context } from '../../../context.js';
-import { PaymentProvider } from '@unchainedshop/core-payment';
 import { Enrollment } from '@unchainedshop/core-enrollments';
 
-type HelperType<T> = (enrollmentPayment: Enrollment['payment'], _: never, context: Context) => T;
-
-type EnrollmentPaymentHelperTypes = {
-  provider: HelperType<Promise<PaymentProvider>>;
-};
-
-export const EnrollmentPayment: EnrollmentPaymentHelperTypes = {
-  provider: async ({ paymentProviderId }, _, { modules }) => {
-    // TODO: use loader
-    return modules.payment.paymentProviders.findProvider({
+export const EnrollmentPayment = {
+  provider: async ({ paymentProviderId }: Enrollment['payment'], _: never, { loaders }: Context) => {
+    return loaders.paymentProviderLoader.load({
       paymentProviderId,
     });
   },