@reactionary/source 0.0.52 → 0.2.16

package/providers/commercetools/src/providers/checkout.provider.ts

@@ -1,262 +1,401 @@
-
+import type { Address as CTAddress, Cart as CTCart, Payment as CTPayment, ShippingMethod as CTShippingMethod, LineItem, MyCartUpdateAction } from '@commercetools/platform-sdk';
 import type {
+  Address,
   Cache,
   Checkout,
-  RequestContext,
-  PaymentMethod,
-  ShippingMethod,
-  CheckoutMutationInitiateCheckout,
-  CheckoutMutationSetShippingAddress,
-  CheckoutMutationFinalizeCheckout,
+  CheckoutIdentifier,
+  CheckoutItem,
   CheckoutMutationAddPaymentInstruction,
+  CheckoutMutationFinalizeCheckout,
+  CheckoutMutationInitiateCheckout,
   CheckoutMutationRemovePaymentInstruction,
+  CheckoutMutationSetShippingAddress,
   CheckoutMutationSetShippingInstruction,
   CheckoutQueryById,
   CheckoutQueryForAvailablePaymentMethods,
   CheckoutQueryForAvailableShippingMethods,
-  CheckoutIdentifier,
+  CostBreakDown,
   Currency,
+  MonetaryAmount,
+  NotFoundError,
+  PaymentInstruction,
+  PaymentInstructionIdentifier,
+  PaymentMethod,
+  PaymentMethodIdentifier,
+  PaymentStatus,
+  RequestContext,
+  Result,
   ShippingInstruction,
-  PaymentInstruction
-} from "@reactionary/core";
-import { AddressSchema, CheckoutItemSchema, CheckoutProvider, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, PaymentMethodIdentifierSchema, ShippingInstructionSchema, ShippingMethodSchema } from "@reactionary/core";
-import type z from "zod";
-import { CommercetoolsClient } from "../core/client.js";
-import type { CommercetoolsConfiguration } from "../schema/configuration.schema.js";
-import type { MyCartUpdateAction } from "@commercetools/platform-sdk";
-import { CommercetoolsCartIdentifierSchema, CommercetoolsCheckoutIdentifierSchema, CommercetoolsOrderIdentifierSchema, type CommercetoolsCheckoutIdentifier } from "../schema/commercetools.schema.js";
-import type  { Address as CTAddress, Payment as CTPayment, Cart as CTCart, ShippingMethod as CTShippingMethod } from "@commercetools/platform-sdk";
-
+  ShippingMethod,
+  ShippingMethodIdentifier,
+} from '@reactionary/core';
+import {
+  CheckoutItemSchema,
+  CheckoutMutationAddPaymentInstructionSchema,
+  CheckoutMutationFinalizeCheckoutSchema,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutMutationRemovePaymentInstructionSchema,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutMutationSetShippingInstructionSchema,
+  CheckoutProvider,
+  CheckoutQueryByIdSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema,
+  CheckoutSchema,
+  PaymentMethodSchema,
+  Reactionary,
+  ShippingMethodSchema,
+  success,
+  error,
+  unwrapValue
+} from '@reactionary/core';
+import z from 'zod';
+import type { CommercetoolsAPI } from '../core/client.js';
+import {
+  type CommercetoolsCartIdentifier,
+  type CommercetoolsCheckoutIdentifier,
+} from '../schema/commercetools.schema.js';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 
 export class CheckoutNotReadyForFinalizationError extends Error {
   constructor(public checkoutIdentifier: CheckoutIdentifier) {
-    super("Checkout is not ready for finalization. Ensure all required fields are set and valid. " + (checkoutIdentifier ? `Checkout ID: ${JSON.stringify(checkoutIdentifier)}` : ''));
-    this.name = "CheckoutNotReadyForFinalizationError";
+    super(
+      'Checkout is not ready for finalization. Ensure all required fields are set and valid. ' +
+        (checkoutIdentifier
+          ? `Checkout ID: ${JSON.stringify(checkoutIdentifier)}`
+          : '')
+    );
+    this.name = 'CheckoutNotReadyForFinalizationError';
   }
 }
 
-
-export class CommercetoolsCheckoutProvider<
-  T extends Checkout = Checkout
-> extends CheckoutProvider<T> {
+export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
+  constructor(
+    config: CommercetoolsConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
+  ) {
+    super(cache, context);
 
     this.config = config;
+    this.commercetools = commercetools;
   }
 
-  protected async getClient(reqCtx: RequestContext) {
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
 
     return {
-      payments: client.withProjectKey({ projectKey: this.config.projectKey }).me().payments(),
-      carts: client.withProjectKey({ projectKey: this.config.projectKey }).me().carts(),
-      shippingMethods: client.withProjectKey({ projectKey: this.config.projectKey }).shippingMethods(),
-      orders: client.withProjectKey({ projectKey: this.config.projectKey }).me().orders()
+      payments: client
+        .withProjectKey({ projectKey: this.config.projectKey })
+        .me()
+        .payments(),
+      carts: client
+        .withProjectKey({ projectKey: this.config.projectKey })
+        .me()
+        .carts(),
+      shippingMethods: client
+        .withProjectKey({ projectKey: this.config.projectKey })
+        .shippingMethods(),
+      orders: client
+        .withProjectKey({ projectKey: this.config.projectKey })
+        .me()
+        .orders(),
     };
   }
 
-  public async initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout, reqCtx: RequestContext): Promise<T> {
+  @Reactionary({
+    inputSchema: CheckoutMutationInitiateCheckoutSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public async initiateCheckoutForCart(
+    payload: CheckoutMutationInitiateCheckout
+  ): Promise<Result<Checkout>> {
     // so......we could copy the cart......
 
-    const client = await this.getClient(reqCtx);
-
-    const cart = await client.carts.withId({ ID: (payload.cart as any).key }).get().execute();
-    const replicationResponse = await client.carts.replicate().post({
-      body: {
-        reference: {
-          typeId: 'cart',
-          id: cart.body.id
-        }
-      }
-    }).execute();
+    const client = await this.getClient();
+
+    const cart = await client.carts
+      .withId({ ID: payload.cart.identifier.key })
+      .get()
+      .execute();
+    const replicationResponse = await client.carts
+      .replicate()
+      .post({
+        body: {
+          reference: {
+            typeId: 'cart',
+            id: cart.body.id,
+          },
+        },
+      })
+      .execute();
     // set the custom type to mark it as a checkout
 
     const actions: MyCartUpdateAction[] = [
-        {
-            action: 'setCustomType',
-            type: {
-              typeId: 'type',
-              key: 'reactionaryCheckout'
-            },
-            fields: {
-              commerceToolsCartId: payload.cart.key,
-            }
+      {
+        action: 'setCustomType',
+        type: {
+          typeId: 'type',
+          key: 'reactionaryCheckout',
+        },
+        fields: {
+          commerceToolsCartId: payload.cart.identifier.key,
         },
+      },
     ];
 
     if (payload.billingAddress) {
-        actions.push({
-            action: 'setBillingAddress',
-            address: {
-              country: payload.billingAddress.countryCode,
-              firstName: payload.billingAddress.firstName || '',
-              lastName: payload.billingAddress.lastName || '',
-              streetName: payload.billingAddress.streetAddress || '',
-              streetNumber: payload.billingAddress.streetNumber || '',
-              postalCode: payload.billingAddress.postalCode || '',
-              city: payload.billingAddress.city || '',
-              email: payload.notificationEmail || '',
-              phone: payload.notificationPhone || ''
-            }
-        });
-        actions.push({
-            action: 'setShippingAddress',
-            address: {
-              country: payload.billingAddress.countryCode,
-              firstName: payload.billingAddress.firstName || '',
-              lastName: payload.billingAddress.lastName || '',
-              streetName: payload.billingAddress.streetAddress || '',
-              streetNumber: payload.billingAddress.streetNumber || '',
-              postalCode: payload.billingAddress.postalCode || '',
-              city: payload.billingAddress.city || '',
-            }
-        });
+      actions.push({
+        action: 'setBillingAddress',
+        address: {
+          country: payload.billingAddress.countryCode,
+          firstName: payload.billingAddress.firstName || '',
+          lastName: payload.billingAddress.lastName || '',
+          streetName: payload.billingAddress.streetAddress || '',
+          streetNumber: payload.billingAddress.streetNumber || '',
+          postalCode: payload.billingAddress.postalCode || '',
+          city: payload.billingAddress.city || '',
+          email: payload.notificationEmail || '',
+          phone: payload.notificationPhone || '',
+        },
+      });
+      actions.push({
+        action: 'setShippingAddress',
+        address: {
+          country: payload.billingAddress.countryCode,
+          firstName: payload.billingAddress.firstName || '',
+          lastName: payload.billingAddress.lastName || '',
+          streetName: payload.billingAddress.streetAddress || '',
+          streetNumber: payload.billingAddress.streetNumber || '',
+          postalCode: payload.billingAddress.postalCode || '',
+          city: payload.billingAddress.city || '',
+        },
+      });
     }
 
-    const checkoutResponse = await client.carts.withId({ ID: replicationResponse.body.id }).post({
-      body: {
-        version: replicationResponse.body.version || 0,
-        actions: [
-          ...actions
-        ]
-      }
-    }).execute();
-
-    return this.parseSingle(checkoutResponse.body, reqCtx);
+    const checkoutResponse = await client.carts
+      .withId({ ID: replicationResponse.body.id })
+      .post({
+        body: {
+          version: replicationResponse.body.version || 0,
+          actions: [...actions],
+        },
+      })
+      .execute();
 
+    return success(this.parseSingle(checkoutResponse.body));
   }
 
-  public async getById(payload: CheckoutQueryById, reqCtx: RequestContext): Promise<T | null> {
+  @Reactionary({
+    inputSchema: CheckoutQueryByIdSchema,
+    outputSchema: CheckoutSchema.nullable(),
+  })
+  public async getById(payload: CheckoutQueryById): Promise<Result<Checkout, NotFoundError>> {
+    const client = await this.getClient();
+    const checkoutResponse = await client.carts
+      .withId({ ID: payload.identifier.key })
+      .get({
+        queryArgs: {
+          expand: ['paymentInfo.payments[*]', 'shippingInfo.shippingMethod'],
+        },
+      })
+      .execute();
 
-    const client = await this.getClient(reqCtx);
-    const checkoutResponse = await client.carts.withId({ ID: payload.identifier.key }).get({
-      queryArgs: {
-        expand: ['paymentInfo.payments[*]', 'shippingInfo.shippingMethod']
-      }
-    }).execute();
+    const checkout = this.parseSingle(checkoutResponse.body);
 
-    return this.parseSingle(checkoutResponse.body, reqCtx);
-  }
+    if (checkoutResponse.body.cartState === 'Ordered') {
+      const order = await client.orders
+        .get({
+          queryArgs: {
+            where: `cart(id="${checkout.identifier.key}")`,
+          },
+        })
+        .execute();
 
-  public async setShippingAddress(payload: CheckoutMutationSetShippingAddress, reqCtx: RequestContext): Promise<T> {
-    const client = await this.getClient(reqCtx);
+      checkout.resultingOrder = {
+        key: order.body.results[0].id,
+      };
+    }
 
-    const version = (payload.checkout as CommercetoolsCheckoutIdentifier).version;
-    const checkoutResponse = await client.carts.withId({ ID: payload.checkout.key }).post({
-      body: {
-        version: version,
-        actions: [
-          {
-            action: 'setShippingAddress',
-            address: {
-              country: payload.shippingAddress.countryCode,
-              firstName: payload.shippingAddress.firstName || '',
-              lastName: payload.shippingAddress.lastName || '',
-              streetName: payload.shippingAddress.streetAddress || '',
-              streetNumber: payload.shippingAddress.streetNumber || '',
-              postalCode: payload.shippingAddress.postalCode || '',
-              city: payload.shippingAddress.city || '',
-            }
-          }
-        ]
-      }
-    }).execute();
+    return success(checkout);
+  }
+
+  @Reactionary({
+    inputSchema: CheckoutMutationSetShippingAddressSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public async setShippingAddress(
+    payload: CheckoutMutationSetShippingAddress
+  ): Promise<Result<Checkout>> {
+    const client = await this.getClient();
+
+    const version = (payload.checkout as CommercetoolsCheckoutIdentifier)
+      .version;
+    const checkoutResponse = await client.carts
+      .withId({ ID: payload.checkout.key })
+      .post({
+        body: {
+          version: version,
+          actions: [
+            {
+              action: 'setShippingAddress',
+              address: {
+                country: payload.shippingAddress.countryCode,
+                firstName: payload.shippingAddress.firstName || '',
+                lastName: payload.shippingAddress.lastName || '',
+                streetName: payload.shippingAddress.streetAddress || '',
+                streetNumber: payload.shippingAddress.streetNumber || '',
+                postalCode: payload.shippingAddress.postalCode || '',
+                city: payload.shippingAddress.city || '',
+              },
+            },
+          ],
+        },
+      })
+      .execute();
 
-    return this.parseSingle(checkoutResponse.body, reqCtx);
+    return success(this.parseSingle(checkoutResponse.body));
   }
 
-  public async getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods, reqCtx: RequestContext): Promise<ShippingMethod[]> {
-    const client = await this.getClient(reqCtx);
-    const shippingMethodsResponse = await client.shippingMethods.matchingCart().get({
-      queryArgs: {
-        cartId: payload.checkout.key
-      }
-    }).execute();
+  @Reactionary({
+    inputSchema: CheckoutQueryForAvailableShippingMethodsSchema,
+    outputSchema: z.array(ShippingMethodSchema),
+  })
+  public async getAvailableShippingMethods(
+    payload: CheckoutQueryForAvailableShippingMethods
+  ): Promise<Result<ShippingMethod[]>> {
+    const client = await this.getClient();
+    const shippingMethodsResponse = await client.shippingMethods
+      .matchingCart()
+      .get({
+        queryArgs: {
+          cartId: payload.checkout.key,
+        },
+      })
+      .execute();
 
     const result: Array<ShippingMethod> = [];
-    const inputShippingMethods: CTShippingMethod[] = shippingMethodsResponse.body.results as CTShippingMethod[];
+    const inputShippingMethods: CTShippingMethod[] = shippingMethodsResponse
+      .body.results as CTShippingMethod[];
     for (const sm of inputShippingMethods) {
-      const shippingMethod = ShippingMethodSchema.parse({
-        identifier: {
-          key: sm.key,
-        },
-        name: sm.name,
-        description: sm.localizedDescription?.[ reqCtx.languageContext.locale ] || '',
-        price: sm.zoneRates[0].shippingRates[0].price ? {
-          value: (sm.zoneRates[0].shippingRates[0].price.centAmount || 0) / 100,
-          currency: sm.zoneRates[0].shippingRates[0].price.currencyCode || reqCtx.languageContext.currencyCode
-        } : { value: 0, currency: reqCtx.languageContext.currencyCode },
-      });
+      const identifier = {
+        key: sm.key!,
+      } satisfies ShippingMethodIdentifier;
+      const name = sm.name;
+      const description = sm.localizedDescription?.[this.context.languageContext.locale] || '';
+      const shippingMethod = {
+        deliveryTime: '',
+        description,
+        identifier,
+        name,
+        price: sm.zoneRates[0].shippingRates[0].price
+          ? {
+              value:
+                (sm.zoneRates[0].shippingRates[0].price.centAmount || 0) / 100,
+              currency:
+                sm.zoneRates[0].shippingRates[0].price.currencyCode as Currency ||
+                this.context.languageContext.currencyCode,
+            }
+          : { value: 0, currency: this.context.languageContext.currencyCode },
+      } satisfies ShippingMethod;
+
       result.push(shippingMethod);
     }
-    return result;
+    return success(result);
   }
 
-  public async getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods, reqCtx: RequestContext): Promise<PaymentMethod[]> {
+  @Reactionary({
+    inputSchema: CheckoutQueryForAvailablePaymentMethodsSchema,
+    outputSchema: z.array(PaymentMethodSchema),
+  })
+  public async getAvailablePaymentMethods(
+    payload: CheckoutQueryForAvailablePaymentMethods
+  ): Promise<Result<PaymentMethod[]>> {
     // Commercetools does not have a concept of payment methods, as these are handled by the payment providers.
     // So for now, we will return an empty array.
-    const staticMethods = this.getStaticPaymentMethods(payload.checkout, reqCtx);
+    const staticMethods = this.getStaticPaymentMethods(payload.checkout);
 
     const dynamicMethods: PaymentMethod[] = [];
     // later we will also fetch any stored payment methods the user has...
 
-    return [...staticMethods, ...dynamicMethods];
+    return success([...staticMethods, ...dynamicMethods]);
   }
 
-  public async addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction, reqCtx: RequestContext): Promise<T> {
-    const client = await this.getClient(reqCtx);
-
-    const response = await client.payments.post({
-      body: {
-
-        amountPlanned: {
-          centAmount: Math.round(payload.paymentInstruction.amount.value * 100),
-          currencyCode: payload.paymentInstruction.amount.currency
-        },
-        paymentMethodInfo: {
-          method: payload.paymentInstruction.paymentMethod.method,
-          name: {
-            [reqCtx.languageContext.locale]: payload.paymentInstruction.paymentMethod.name
+  @Reactionary({
+    inputSchema: CheckoutMutationAddPaymentInstructionSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public async addPaymentInstruction(
+    payload: CheckoutMutationAddPaymentInstruction
+  ): Promise<Result<Checkout>> {
+    const client = await this.getClient();
+
+    const response = await client.payments
+      .post({
+        body: {
+          amountPlanned: {
+            centAmount: Math.round(
+              payload.paymentInstruction.amount.value * 100
+            ),
+            currencyCode: payload.paymentInstruction.amount.currency,
           },
-          paymentInterface: payload.paymentInstruction.paymentMethod.paymentProcessor
-        },
-        custom: {
-          type: {
-            typeId: 'type',
-            key: 'reactionaryPaymentCustomFields',
+          paymentMethodInfo: {
+            method: payload.paymentInstruction.paymentMethod.method,
+            name: {
+              [this.context.languageContext.locale]:
+                payload.paymentInstruction.paymentMethod.name,
+            },
+            paymentInterface:
+              payload.paymentInstruction.paymentMethod.paymentProcessor,
           },
-          fields: {
-            'commerceToolsCartId': payload.checkout.key,
-          }
-        }
-      },
-    }).execute();
+          custom: {
+            type: {
+              typeId: 'type',
+              key: 'reactionaryPaymentCustomFields',
+            },
+            fields: {
+              commerceToolsCartId: payload.checkout.key,
+            },
+          },
+        },
+      })
+      .execute();
 
-    const version = (payload.checkout as CommercetoolsCheckoutIdentifier).version;
+    const version = (payload.checkout as CommercetoolsCheckoutIdentifier)
+      .version;
     const actions: MyCartUpdateAction[] = [
       {
         action: 'addPayment',
         payment: {
           typeId: 'payment',
-          id: response.body.id
-        }
-      }
+          id: response.body.id,
+        },
+      },
     ];
 
-    return this.applyActions(payload.checkout as CommercetoolsCheckoutIdentifier, actions, reqCtx);
-  }
-
-  public async removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction, reqCtx: RequestContext): Promise<T> {
-   const client = await this.getClient(reqCtx);
-
+    const result = await this.applyActions(
+      payload.checkout as CommercetoolsCheckoutIdentifier,
+      actions
+    );
 
-   // FIXME: Need to get full-endpoint rights, if we want to cancel the authorization on the payment. The MyPayment endpoint does not support
-   // changing a payment intent after it has transactions.
+    return success(result);
+  }
 
+  @Reactionary({
+    inputSchema: CheckoutMutationRemovePaymentInstructionSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public async removePaymentInstruction(
+    payload: CheckoutMutationRemovePaymentInstruction
+  ): Promise<Result<Checkout>> {
+    const client = await this.getClient();
 
+    // FIXME: Need to get full-endpoint rights, if we want to cancel the authorization on the payment. The MyPayment endpoint does not support
+    // changing a payment intent after it has transactions.
 
     // get newest version
     /*
@@ -284,8 +423,8 @@ export class CommercetoolsCheckoutProvider<
     // The cart can be re-used, and a new payment instruction can be added to it later.
     // The frontend should ignore any payment instructions with status 'canceled' when displaying payment options to the user.
 
-        // Now add the payment to the cart
-        /*
+    // Now add the payment to the cart
+    /*
     const ctId = payload.checkout as CommercetoolsCheckoutIdentifier
     const updatedCart = await client.carts.withId({ ID: ctId.key }).post({
       body: {
@@ -309,336 +448,379 @@ export class CommercetoolsCheckoutProvider<
     }).execute();
     */
 
-    const checkout =  await this.getById({ identifier: payload.checkout }, reqCtx);
-    return checkout!
-
+    const checkout = unwrapValue(await this.getById({ identifier: payload.checkout }));
+    return success(checkout);
   }
 
-  public async setShippingInstruction(payload: CheckoutMutationSetShippingInstruction, reqCtx: RequestContext): Promise<T> {
-
-    const client = await this.getClient(reqCtx);
-    const ctId = payload.checkout as CommercetoolsCheckoutIdentifier;
-
+  @Reactionary({
+    inputSchema: CheckoutMutationSetShippingInstructionSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public async setShippingInstruction(
+    payload: CheckoutMutationSetShippingInstruction
+  ): Promise<Result<Checkout>> {
     const actions: MyCartUpdateAction[] = [];
-      actions.push({
-        action: 'setShippingMethod',
-        shippingMethod: {
-          typeId: 'shipping-method',
-          key: payload.shippingInstruction.shippingMethod.key
-        }
-      });
-      actions.push({
-        action: 'setCustomField',
-        name: 'shippingInstruction',
-        value: payload.shippingInstruction.instructions
-      });
-      actions.push({
-        action: 'setCustomField',
-        name: 'consentForUnattendedDelivery',
-        value: payload.shippingInstruction.consentForUnattendedDelivery + ''
-      });
-      actions.push({
-        action: 'setCustomField',
-        name: 'pickupPointId',
-        value: payload.shippingInstruction.pickupPoint
-      });
-
+    actions.push({
+      action: 'setShippingMethod',
+      shippingMethod: {
+        typeId: 'shipping-method',
+        key: payload.shippingInstruction.shippingMethod.key,
+      },
+    });
+    actions.push({
+      action: 'setCustomField',
+      name: 'shippingInstruction',
+      value: payload.shippingInstruction.instructions,
+    });
+    actions.push({
+      action: 'setCustomField',
+      name: 'consentForUnattendedDelivery',
+      value: payload.shippingInstruction.consentForUnattendedDelivery + '',
+    });
+    actions.push({
+      action: 'setCustomField',
+      name: 'pickupPointId',
+      value: payload.shippingInstruction.pickupPoint,
+    });
 
+    const result = await this.applyActions(
+      payload.checkout as CommercetoolsCheckoutIdentifier,
+      actions
+    );
 
-    return this.applyActions(payload.checkout as CommercetoolsCheckoutIdentifier, actions, reqCtx);
+    return success(result);
   }
 
-  public async finalizeCheckout(payload: CheckoutMutationFinalizeCheckout, reqCtx: RequestContext): Promise<T> {
-    const checkout = await this.getById({ identifier: payload.checkout }, reqCtx);
-    if (!checkout || !checkout.readyForFinalization) {
+  @Reactionary({
+    inputSchema: CheckoutMutationFinalizeCheckoutSchema,
+    outputSchema: CheckoutSchema,
+  })
+  public async finalizeCheckout(
+    payload: CheckoutMutationFinalizeCheckout
+  ): Promise<Result<Checkout>> {
+    const checkout = await this.getById({ identifier: payload.checkout });
+    if (!checkout.success || !checkout.value.readyForFinalization) {
       throw new CheckoutNotReadyForFinalizationError(payload.checkout);
     }
 
-    const client = await this.getClient(reqCtx);
+    const client = await this.getClient();
     const ctId = payload.checkout as CommercetoolsCheckoutIdentifier;
 
     // create the order from the cart
-    const orderResponse = await client.orders.post({
-      body: {
-        id: ctId.key,
-        version: ctId.version
-      }
-    }).execute();
-
-    const actions: MyCartUpdateAction[] = [];
-      actions.push({
-        action: 'setCustomField',
-        name: 'commerceToolsOrderId',
-        value: orderResponse.body.id
-    });
+    const orderResponse = await client.orders
+      .post({
+        body: {
+          id: ctId.key,
+          version: ctId.version,
+        },
+      })
+      .execute();
 
-    return this.applyActions(payload.checkout as CommercetoolsCheckoutIdentifier, actions, reqCtx);
+    return this.getById({
+      identifier: payload.checkout,
+    }) as unknown as Result<Checkout>;
   }
 
-
-
-
   protected async applyActions(
     checkout: CheckoutIdentifier,
-    actions: MyCartUpdateAction[],
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
+    actions: MyCartUpdateAction[]
+  ): Promise<Checkout> {
+    const client = await this.getClient();
     const ctId = checkout as CommercetoolsCheckoutIdentifier;
 
+    try {
+      const response = await client.carts
+        .withId({ ID: ctId.key })
+        .post({
+          queryArgs: {
+            expand: ['paymentInfo.payments[*]', 'shippingInfo.shippingMethod'],
+          },
+          body: {
+            version: ctId.version,
+            actions,
+          },
+        })
+        .execute();
 
-       try {
-        const response = await client.carts
-          .withId({ ID: ctId.key })
-          .post({
-            queryArgs: {
-              expand: ['paymentInfo.payments[*]', 'shippingInfo.shippingMethod']
-            },
-            body: {
-              version: ctId.version,
-              actions,
-            },
-          })
-          .execute();
+      if (response.error) {
+        console.error(response.error);
+      }
 
-          if (response.error) {
-            console.error(response.error);
-          }
-          return this.parseSingle(response.body, reqCtx);
-       } catch (e: any) {
-        console.error('Error applying actions to cart:', e);
-        throw e;
-       }
+      const p = this.parseSingle(response.body);
 
+      return p;
+    } catch (e: any) {
+      console.error('Error applying actions to cart:', e);
+      throw e;
+    }
   }
 
   /**
    * Extension point, to allow filtering the options, or adding new ones, like invoicing for b2b.
    *
    * Usecase: Override this, if you need to change the payment options based on the request context.
-   * @param reqCtx
    * @returns
    */
-  protected getStaticPaymentMethods(_checkout: CheckoutIdentifier, reqCtx: RequestContext): PaymentMethod[] {
+  protected getStaticPaymentMethods(
+    _checkout: CheckoutIdentifier
+  ): PaymentMethod[] {
     return this.config.paymentMethods || [];
   }
 
-
-
-  protected override getResourceName(): string {
-    return "checkout";
-  }
-
-
-  protected override parseSingle(remote: CTCart, reqCtx: RequestContext): T {
-      const result = this.newModel();
-
-      result.identifier = CommercetoolsCheckoutIdentifierSchema.parse({
-        key: remote.id,
-        version: remote.version || 0,
-      });
-
-      result.name = remote.custom?.fields['name'] || '';
-      result.description = remote.custom?.fields['description'] || '';
-
-
-      result.originalCartReference = CommercetoolsCartIdentifierSchema.parse({
-        key: remote.custom?.fields['commerceToolsCartId'] || '',
-        version: 0,
-      });
-
-      const orderId = remote.custom?.fields['commerceToolsOrderId'];
-      if (orderId) {
-        result.resultingOrder = CommercetoolsOrderIdentifierSchema.parse({
-          key: orderId,
-          version: 0,
-        });
-      }
-
-
-      if (remote.shippingAddress) {
-        result.shippingAddress = this.parseAddress( remote.shippingAddress, reqCtx) ;
-      }
-
-      if (remote.billingAddress ) {
-        result.billingAddress = this.parseAddress( remote.billingAddress, reqCtx) ;
-      }
-      result.shippingInstruction = this.parseShippingInstruction(remote);
-
-      for(const p of remote.paymentInfo?.payments || []) {
-        if (p.obj) {
-          result.paymentInstructions.push( this.parsePaymentInstruction(p.obj, reqCtx) );
-        }
-      }
-
-      const grandTotal = remote.totalPrice.centAmount || 0;
-      const shippingTotal = remote.shippingInfo?.price.centAmount || 0;
-      const productTotal = grandTotal - shippingTotal;
-      const taxTotal = remote.taxedPrice?.totalTax?.centAmount || 0;
-      const discountTotal =
-        remote.discountOnTotalPrice?.discountedAmount.centAmount || 0;
-      const surchargeTotal = 0;
-      const currency = remote.totalPrice.currencyCode as Currency;
-
-      result.price = {
-        totalTax: {
-          value: taxTotal / 100,
-          currency,
-        },
-        totalDiscount: {
-          value: discountTotal / 100,
+  protected parseCheckoutItem(remoteItem: LineItem): CheckoutItem {
+    const unitPrice = remoteItem.price.value.centAmount;
+    const totalPrice = remoteItem.totalPrice.centAmount || 0;
+    const totalDiscount = remoteItem.price.discounted?.value.centAmount || 0;
+    const unitDiscount = totalDiscount / remoteItem.quantity;
+    const currency =
+      remoteItem.price.value.currencyCode.toUpperCase() as Currency;
+
+    const item = {
+      identifier: {
+        key: remoteItem.id,
+      },
+      variant: {
+        sku: remoteItem.variant.sku || '',
+      },
+      quantity: remoteItem.quantity,
+      price: {
+        unitPrice: {
+          value: unitPrice / 100,
           currency,
         },
-        totalSurcharge: {
-          value: surchargeTotal / 100,
+        unitDiscount: {
+          value: unitDiscount / 100,
           currency,
         },
-        totalShipping: {
-          value: shippingTotal / 100,
-          currency: remote.shippingInfo?.price.currencyCode as Currency,
-        },
-        totalProductPrice: {
-          value: productTotal / 100,
+        totalPrice: {
+          value: (totalPrice || 0) / 100,
           currency,
         },
-        grandTotal: {
-          value: grandTotal / 100,
+        totalDiscount: {
+          value: totalDiscount / 100,
           currency,
         },
-      };
-
-      for (const remoteItem of remote.lineItems) {
-        const item = CheckoutItemSchema.parse({});
+      },
+    } satisfies CheckoutItem;
 
-        item.identifier.key = remoteItem.id;
-        item.sku.key = remoteItem.variant.sku || '';
-        item.quantity = remoteItem.quantity;
+    return CheckoutItemSchema.parse(item);
+  }
 
-        const unitPrice = remoteItem.price.value.centAmount;
-        const totalPrice = remoteItem.totalPrice.centAmount || 0;
-        const totalDiscount = remoteItem.price.discounted?.value.centAmount || 0;
-        const unitDiscount = totalDiscount / remoteItem.quantity;
+  protected parseSingle(remote: CTCart): Checkout {
+    const identifier = {
+      key: remote.id,
+      version: remote.version || 0,
+    } satisfies CommercetoolsCheckoutIdentifier;
 
-        item.price = {
-          unitPrice: {
-            value: unitPrice / 100,
-            currency,
-          },
-          unitDiscount: {
-            value: unitDiscount / 100,
-            currency,
-          },
-          totalPrice: {
-            value: (totalPrice || 0) / 100,
-            currency,
-          },
-          totalDiscount: {
-            value: totalDiscount / 100,
-            currency,
-          },
-        };
+    const originalCartReference = {
+      key: remote.custom?.fields['commerceToolsCartId'] || '',
+      version: 0,
+    } satisfies CommercetoolsCartIdentifier;
 
-        result.items.push(item);
-      }
+    let shippingAddress: Address | undefined;
+    if (remote.shippingAddress) {
+      shippingAddress = this.parseAddress(remote.shippingAddress);
+    }
 
-      result.readyForFinalization = this.isReadyForFinalization(result);
-      result.meta = {
-        cache: {
-          hit: false,
-          key: this.generateCacheKeySingle(result.identifier, reqCtx),
-        },
-        placeholder: false,
-      };
+    let billingAddress: Address | undefined;
+    if (remote.billingAddress) {
+      billingAddress = this.parseAddress(remote.billingAddress);
+    }
 
-      return this.assert(result);
+    const paymentInstructions = new Array<PaymentInstruction>();
+    for (const p of remote.paymentInfo?.payments || []) {
+      if (p.obj) {
+        paymentInstructions.push(this.parsePaymentInstruction(p.obj));
+      }
     }
 
-    protected isReadyForFinalization(checkout: T): boolean {
-      // we should have a billing address
-      if (!checkout.billingAddress) return false;
+    const grandTotal = remote.totalPrice.centAmount || 0;
+    const shippingTotal = remote.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = remote.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal =
+      remote.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = remote.totalPrice.currencyCode as Currency;
+
+    const price = {
+      totalTax: {
+        value: taxTotal / 100,
+        currency,
+      },
+      totalDiscount: {
+        value: discountTotal / 100,
+        currency,
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency,
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency: currency
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency,
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency,
+      },
+    } satisfies CostBreakDown;
 
-      // we should know how to ship it
-      if (!checkout.shippingInstruction) return false;
+    const items = new Array<CheckoutItem>();
+    for (const remoteItem of remote.lineItems) {
+      const item = this.parseCheckoutItem(remoteItem);
+      items.push(item);
+    }
 
-      // and it should ship either to an address or a pickup point
-      if (!checkout.shippingAddress && !checkout.shippingInstruction.pickupPoint) return false;
+    const shippingInstruction = this.parseShippingInstruction(remote);
+    const readyForFinalization = this.isReadyForFinalization(
+      price,
+      paymentInstructions,
+      billingAddress,
+      shippingAddress,
+      shippingInstruction
+    );
+
+    const result = {
+      identifier,
+      originalCartReference,
+      name: remote.custom?.fields['name'] || '',
+      description: remote.custom?.fields['description'] || '',
+      readyForFinalization,
+      billingAddress,
+      shippingAddress,
+      shippingInstruction,
+      paymentInstructions,
+      items,
+      price,
+    } satisfies Checkout;
 
-      // and it should be paid for
-      if (checkout.paymentInstructions.length === 0) return false;
+    return result;
+  }
 
-      const authorizedPayments = checkout.paymentInstructions.filter(pi => pi.status === 'authorized').map(x => x.amount.value).reduce((a, b) => a + b, 0);
-      if (checkout.price.grandTotal.value !== authorizedPayments) return false;
+  protected isReadyForFinalization(
+    price: CostBreakDown,
+    paymentInstructions: Array<PaymentInstruction>,
+    billingAddress?: Address,
+    shippingAddress?: Address,
+    shippingInstruction?: ShippingInstruction
+  ): boolean {
+    // we should have a billing address
+    if (!billingAddress) return false;
 
-      return true
-    }
+    // we should know how to ship it
+    if (!shippingInstruction) return false;
 
-    protected parsePaymentInstruction(remote: CTPayment, reqCtx: RequestContext): PaymentInstruction {
-      const newModel = PaymentInstructionSchema.parse({});
-      newModel.identifier = PaymentInstructionIdentifierSchema.parse({ key: remote.id || '' });
-      newModel.amount = {
-        value: remote.amountPlanned.centAmount / 100,
-        currency: remote.amountPlanned.currencyCode as Currency,
-      };
+    // and it should ship either to an address or a pickup point
+    if (!shippingAddress && !shippingInstruction.pickupPoint) return false;
 
+    // and it should be paid for
+    if (paymentInstructions.length === 0) return false;
 
+    const authorizedPayments = paymentInstructions
+      .filter((pi) => pi.status === 'authorized')
+      .map((x) => x.amount.value)
+      .reduce((a, b) => a + b, 0);
+    if (price.grandTotal.value !== authorizedPayments) return false;
 
-      const method = remote.paymentMethodInfo?.method || 'unknown';
-      const paymentProcessor = remote.paymentMethodInfo?.paymentInterface || method;
-      const paymentName = remote.paymentMethodInfo.name![reqCtx.languageContext.locale];
-      newModel.paymentMethod = PaymentMethodIdentifierSchema.parse({
-        method,
-        paymentProcessor,
-        name: paymentName || method || 'Unknown',
-      });
+    return true;
+  }
 
-      const customData = remote.custom?.fields || {};
-      newModel.protocolData = Object.keys(customData).map(x => ({ key: x, value: customData[x] })) || [];
-      if (remote.transactions && remote.transactions.length > 0) {
-        const lastTransaction = remote.transactions[remote.transactions.length - 1];
-        if (lastTransaction.type === 'Authorization' && lastTransaction.state === 'Pending') {
-          newModel.status = 'pending';
-        } else if (lastTransaction.type === 'Authorization' && lastTransaction.state === 'Success') {
-          newModel.status = 'authorized';
-        }
-      } else {
-        newModel.status = 'pending';
+  protected parsePaymentInstruction(remote: CTPayment): PaymentInstruction {
+    const identifier = {
+      key: remote.id,
+    } satisfies PaymentInstructionIdentifier;
+    const amount = {
+      value: remote.amountPlanned.centAmount / 100,
+      currency: remote.amountPlanned.currencyCode as Currency,
+    } satisfies MonetaryAmount;
+
+    const method = remote.paymentMethodInfo?.method || 'unknown';
+    const paymentProcessor =
+      remote.paymentMethodInfo?.paymentInterface || method;
+    const paymentName =
+      remote.paymentMethodInfo.name![this.context.languageContext.locale];
+
+    const paymentMethod = {
+      method,
+      paymentProcessor,
+      name: paymentName || method || 'Unknown',
+    } satisfies PaymentMethodIdentifier;
+
+    const customData = remote.custom?.fields || {};
+    const protocolData =
+      Object.keys(customData).map((x) => ({ key: x, value: customData[x] })) ||
+      [];
+
+    let status: PaymentStatus = 'pending';
+    if (remote.transactions && remote.transactions.length > 0) {
+      const lastTransaction =
+        remote.transactions[remote.transactions.length - 1];
+      if (
+        lastTransaction.type === 'Authorization' &&
+        lastTransaction.state === 'Pending'
+      ) {
+        status = 'pending';
+      } else if (
+        lastTransaction.type === 'Authorization' &&
+        lastTransaction.state === 'Success'
+      ) {
+        status = 'authorized';
       }
-
-      return PaymentInstructionSchema.parse(newModel);
+    } else {
+      status = 'pending';
     }
 
-    protected parseAddress(remote: CTAddress, reqCtx: RequestContext) {
-      return AddressSchema.parse({
-        countryCode: remote.country || '',
-        firstName: remote.firstName || '',
-        lastName: remote.lastName || '',
-        streetAddress: remote.streetName || '',
-        streetNumber: remote.streetNumber || '',
-        postalCode: remote.postalCode || '',
-        city: remote.city || '',
-      });
-    }
+    const result = {
+      amount,
+      identifier,
+      paymentMethod,
+      protocolData,
+      status
+    } satisfies PaymentInstruction;
 
-    protected parseShippingInstruction(remote: CTCart): ShippingInstruction | undefined {
-      if (!remote.shippingInfo) return undefined;
+    return result;
+  }
 
-      const instructions = remote.custom?.fields['shippingInstruction'] || '';
-      const consentForUnattendedDelivery = remote.custom?.fields['consentForUnattendedDelivery'] === 'true' || false;
-      const pickupPoint = remote.custom?.fields['pickupPointId'] || '';
+  protected parseAddress(remote: CTAddress) {
+    return {
+      countryCode: remote.country || '',
+      firstName: remote.firstName || '',
+      lastName: remote.lastName || '',
+      streetAddress: remote.streetName || '',
+      streetNumber: remote.streetNumber || '',
+      postalCode: remote.postalCode || '',
+      city: remote.city || '',
+      identifier: {
+        nickName: '',
+      },
+      region: '',
+    } satisfies Address;
+  }
 
-      const shippingInstruction = ShippingInstructionSchema.parse({
-        amount: {
-          value: (remote.shippingInfo.price.centAmount || 0) / 100,
-          currency: remote.shippingInfo.price.currencyCode as Currency,
-        },
-        shippingMethod: {
-          key: remote.shippingInfo.shippingMethod?.obj?.key || '',
-        },
-        pickupPoint: pickupPoint || '',
-        instructions: instructions || '',
-        consentForUnattendedDelivery: consentForUnattendedDelivery || false,
-      });
+  protected parseShippingInstruction(
+    remote: CTCart
+  ): ShippingInstruction | undefined {
+    if (!remote.shippingInfo) return undefined;
 
-      return shippingInstruction;
-    }
+    const instructions = remote.custom?.fields['shippingInstruction'] || '';
+    const consentForUnattendedDelivery =
+      remote.custom?.fields['consentForUnattendedDelivery'] === 'true' || false;
+    const pickupPoint = remote.custom?.fields['pickupPointId'] || '';
+
+    const shippingInstruction = {
+      shippingMethod: {
+        key: remote.shippingInfo.shippingMethod?.obj?.key || '',
+      },
+      pickupPoint: pickupPoint || '',
+      instructions: instructions || '',
+      consentForUnattendedDelivery: consentForUnattendedDelivery || false,
+    } satisfies ShippingInstruction;
+
+    return shippingInstruction;
+  }
 }