@reactionary/provider-commercetools 0.0.48 → 0.0.51

package/core/client.js

@@ -3,22 +3,25 @@ import {
 } from "@commercetools/ts-client";
 import { createApiBuilderFromCtpClient } from "@commercetools/platform-sdk";
 import { randomUUID } from "crypto";
-import { GuestIdentitySchema, IdentitySchema } from "@reactionary/core";
+import {
+  AnonymousIdentitySchema,
+  GuestIdentitySchema,
+  RegisteredIdentitySchema
+} from "@reactionary/core";
 import * as crypto from "crypto";
+import createDebug from "debug";
+const debug = createDebug("commercetools:debug");
 class RequestContextTokenCache {
   constructor(context) {
     this.context = context;
   }
   async get(tokenCacheOptions) {
     const identity = this.context.identity;
-    if (identity.type !== "Anonymous") {
-      return {
-        refreshToken: identity.refresh_token,
-        token: identity.token || "",
-        expirationTime: identity.expiry.getTime()
-      };
-    }
-    return void 0;
+    return {
+      refreshToken: identity.refresh_token,
+      token: identity.token || "",
+      expirationTime: identity.expiry.getTime()
+    };
   }
   async set(cache, tokenCacheOptions) {
     const identity = this.context.identity;
@@ -35,7 +38,6 @@ class CommercetoolsClient {
     return this.createClient(reqCtx);
   }
   async register(username, password, reqCtx) {
-    const cache = new RequestContextTokenCache(reqCtx);
     const registrationBuilder = this.createBaseClientBuilder().withAnonymousSessionFlow({
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
@@ -43,8 +45,7 @@ class CommercetoolsClient {
         clientId: this.config.clientId,
         clientSecret: this.config.clientSecret
       },
-      scopes: this.config.scopes,
-      tokenCache: cache
+      scopes: this.config.scopes
     });
     const registrationClient = createApiBuilderFromCtpClient(
       registrationBuilder.build()
@@ -56,10 +57,10 @@ class CommercetoolsClient {
       }
     }).execute();
     const login = await this.login(username, password, reqCtx);
+    return login;
   }
   async login(username, password, reqCtx) {
     const cache = new RequestContextTokenCache(reqCtx);
-    const identity = reqCtx.identity;
     const loginBuilder = this.createBaseClientBuilder().withPasswordFlow({
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
@@ -72,17 +73,27 @@ class CommercetoolsClient {
       scopes: this.config.scopes
     });
     const loginClient = createApiBuilderFromCtpClient(loginBuilder.build());
-    const login = await loginClient.withProjectKey({ projectKey: this.config.projectKey }).me().get().execute();
-    identity.type = "Registered";
-    identity.logonId = username;
-    identity.id = {
-      userId: login.body.id
-    };
+    const login = await loginClient.withProjectKey({ projectKey: this.config.projectKey }).me().login().post({
+      body: {
+        email: username,
+        password
+      }
+    }).execute();
+    reqCtx.identity = RegisteredIdentitySchema.parse({
+      ...reqCtx.identity,
+      type: "Registered",
+      logonId: username,
+      id: {
+        userId: login.body.customer.id
+      }
+    });
+    return reqCtx.identity;
   }
   async logout(reqCtx) {
     const cache = new RequestContextTokenCache(reqCtx);
     await cache.set({ token: "", refreshToken: "", expirationTime: 0 });
-    reqCtx.identity = IdentitySchema.parse({});
+    reqCtx.identity = AnonymousIdentitySchema.parse({});
+    return reqCtx.identity;
   }
   createClient(reqCtx) {
     const cache = new RequestContextTokenCache(reqCtx);
@@ -95,7 +106,7 @@ class CommercetoolsClient {
       });
     }
     const identity = reqCtx.identity;
-    let builder = this.createBaseClientBuilder();
+    let builder = this.createBaseClientBuilder(reqCtx);
     if (!identity.token || !identity.refresh_token) {
       builder = builder.withAnonymousSessionFlow({
         host: this.config.authUrl,
@@ -121,8 +132,8 @@ class CommercetoolsClient {
     }
     return createApiBuilderFromCtpClient(builder.build());
   }
-  createBaseClientBuilder() {
-    const builder = new ClientBuilder().withProjectKey(this.config.projectKey).withQueueMiddleware({
+  createBaseClientBuilder(reqCtx) {
+    let builder = new ClientBuilder().withProjectKey(this.config.projectKey).withQueueMiddleware({
       concurrency: 20
     }).withConcurrentModificationMiddleware({
       concurrentModificationHandlerFn: (version, request) => {
@@ -133,9 +144,6 @@ class CommercetoolsClient {
         body["version"] = version;
         return Promise.resolve(body);
       }
-    }).withCorrelationIdMiddleware({
-      // ideally this would be pushed in as part of the session context, so we can trace it end-to-end
-      generate: () => `REACTIONARY-${randomUUID()}`
     }).withHttpMiddleware({
       retryConfig: {
         backoff: true,
@@ -151,6 +159,13 @@ class CommercetoolsClient {
       host: this.config.apiUrl,
       httpClient: fetch
     });
+    const correlationId = reqCtx?.correlationId || "REACTIONARY-" + (typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : randomUUID());
+    builder = builder.withCorrelationIdMiddleware({
+      generate: () => correlationId
+    });
+    if (debug.enabled) {
+      builder = builder.withLoggerMiddleware();
+    }
     return builder;
   }
 }

package/core/initialize.js

@@ -6,7 +6,7 @@ import {
   ProductSchema,
   SearchResultSchema,
   CategorySchema,
-  CartPaymentInstructionSchema
+  CheckoutSchema
 } from "@reactionary/core";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from "../providers/product.provider";
@@ -15,7 +15,7 @@ import { CommercetoolsCartProvider } from "../providers/cart.provider";
 import { CommercetoolsInventoryProvider } from "../providers/inventory.provider";
 import { CommercetoolsPriceProvider } from "../providers/price.provider";
 import { CommercetoolsCategoryProvider } from "../providers/category.provider";
-import { CommercetoolsCartPaymentProvider } from "../providers/cart-payment.provider";
+import { CommercetoolsCheckoutProvider } from "../providers";
 function withCommercetoolsCapabilities(configuration, capabilities) {
   return (cache) => {
     const client = {};
@@ -40,8 +40,8 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
     if (capabilities.category) {
       client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
     }
-    if (capabilities.cartPayment) {
-      client.cartPayment = new CommercetoolsCartPaymentProvider(configuration, CartPaymentInstructionSchema, cache);
+    if (capabilities.checkout) {
+      client.checkout = new CommercetoolsCheckoutProvider(configuration, CheckoutSchema, cache);
     }
     return client;
   };

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@reactionary/provider-commercetools",
-  "version": "0.0.48",
+  "version": "0.0.51",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.0.48",
-    "@reactionary/otel": "0.0.48",
+    "@reactionary/core": "0.0.51",
+    "@reactionary/otel": "0.0.51",
+    "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",
     "@commercetools/platform-sdk": "^8.8.0"

package/providers/cart.provider.js

@@ -279,13 +279,21 @@ class CommercetoolsCartProvider extends CartProvider {
   async applyActions(cart, actions, reqCtx) {
     const client = await this.getClient(reqCtx);
     const ctId = cart;
-    const response = await client.carts.withId({ ID: ctId.key }).post({
-      body: {
-        version: ctId.version,
-        actions
+    try {
+      const response = await client.carts.withId({ ID: ctId.key }).post({
+        body: {
+          version: ctId.version,
+          actions
+        }
+      }).execute();
+      if (response.error) {
+        console.error(response.error);
       }
-    }).execute();
-    return this.parseSingle(response.body, reqCtx);
+      return this.parseSingle(response.body, reqCtx);
+    } catch (e) {
+      console.error("Error applying actions to cart:", e);
+      throw e;
+    }
   }
   async getClient(reqCtx) {
     const client = await new CommercetoolsClient(this.config).getClient(reqCtx);

package/providers/checkout.provider.js

@@ -0,0 +1,457 @@
+import { AddressSchema, CheckoutItemSchema, CheckoutProvider, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, PaymentMethodIdentifierSchema, ShippingInstructionSchema, ShippingMethodSchema } from "@reactionary/core";
+import { CommercetoolsClient } from "../core/client";
+import { CommercetoolsCartIdentifierSchema, CommercetoolsCheckoutIdentifierSchema, CommercetoolsOrderIdentifierSchema } from "../schema/commercetools.schema";
+class CheckoutNotReadyForFinalizationError extends Error {
+  constructor(checkoutIdentifier) {
+    super("Checkout is not ready for finalization. Ensure all required fields are set and valid. " + (checkoutIdentifier ? `Checkout ID: ${JSON.stringify(checkoutIdentifier)}` : ""));
+    this.checkoutIdentifier = checkoutIdentifier;
+    this.name = "CheckoutNotReadyForFinalizationError";
+  }
+}
+class CommercetoolsCheckoutProvider extends CheckoutProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  async getClient(reqCtx) {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    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()
+    };
+  }
+  async initiateCheckoutForCart(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const cart = await client.carts.withId({ ID: payload.cart.key }).get().execute();
+    const replicationResponse = await client.carts.replicate().post({
+      body: {
+        reference: {
+          typeId: "cart",
+          id: cart.body.id
+        }
+      }
+    }).execute();
+    const actions = [
+      {
+        action: "setCustomType",
+        type: {
+          typeId: "type",
+          key: "reactionaryCheckout"
+        },
+        fields: {
+          commerceToolsCartId: payload.cart.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 || ""
+        }
+      });
+    }
+    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);
+  }
+  async getById(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const checkoutResponse = await client.carts.withId({ ID: payload.identifier.key }).get({
+      queryArgs: {
+        expand: ["paymentInfo.payments[*]", "shippingInfo.shippingMethod"]
+      }
+    }).execute();
+    return this.parseSingle(checkoutResponse.body, reqCtx);
+  }
+  async setShippingAddress(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const version = payload.checkout.version;
+    const checkoutResponse = await client.carts.withId({ ID: payload.checkout.key }).post({
+      body: {
+        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);
+  }
+  async getAvailableShippingMethods(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const shippingMethodsResponse = await client.shippingMethods.matchingCart().get({
+      queryArgs: {
+        cartId: payload.checkout.key
+      }
+    }).execute();
+    const result = [];
+    const inputShippingMethods = shippingMethodsResponse.body.results;
+    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 }
+      });
+      result.push(shippingMethod);
+    }
+    return result;
+  }
+  async getAvailablePaymentMethods(payload, reqCtx) {
+    const staticMethods = this.getStaticPaymentMethods(payload.checkout, reqCtx);
+    const dynamicMethods = [];
+    return [...staticMethods, ...dynamicMethods];
+  }
+  async addPaymentInstruction(payload, reqCtx) {
+    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
+          },
+          paymentInterface: payload.paymentInstruction.paymentMethod.paymentProcessor
+        },
+        custom: {
+          type: {
+            typeId: "type",
+            key: "reactionaryPaymentCustomFields"
+          },
+          fields: {
+            "commerceToolsCartId": payload.checkout.key
+          }
+        }
+      }
+    }).execute();
+    const version = payload.checkout.version;
+    const actions = [
+      {
+        action: "addPayment",
+        payment: {
+          typeId: "payment",
+          id: response.body.id
+        }
+      }
+    ];
+    return this.applyActions(payload.checkout, actions, reqCtx);
+  }
+  async removePaymentInstruction(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const checkout = await this.getById({ identifier: payload.checkout }, reqCtx);
+    return checkout;
+  }
+  async setShippingInstruction(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const ctId = payload.checkout;
+    const actions = [];
+    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
+    });
+    return this.applyActions(payload.checkout, actions, reqCtx);
+  }
+  async finalizeCheckout(payload, reqCtx) {
+    const checkout = await this.getById({ identifier: payload.checkout }, reqCtx);
+    if (!checkout || !checkout.readyForFinalization) {
+      throw new CheckoutNotReadyForFinalizationError(payload.checkout);
+    }
+    const client = await this.getClient(reqCtx);
+    const ctId = payload.checkout;
+    const orderResponse = await client.orders.post({
+      body: {
+        id: ctId.key,
+        version: ctId.version
+      }
+    }).execute();
+    const actions = [];
+    actions.push({
+      action: "setCustomField",
+      name: "commerceToolsOrderId",
+      value: orderResponse.body.id
+    });
+    return this.applyActions(payload.checkout, actions, reqCtx);
+  }
+  async applyActions(checkout, actions, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const ctId = checkout;
+    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);
+      }
+      return this.parseSingle(response.body, reqCtx);
+    } catch (e) {
+      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
+   */
+  getStaticPaymentMethods(_checkout, reqCtx) {
+    return this.config.paymentMethods || [];
+  }
+  getResourceName() {
+    return "checkout";
+  }
+  parseSingle(remote, reqCtx) {
+    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;
+    result.price = {
+      totalTax: {
+        value: taxTotal / 100,
+        currency
+      },
+      totalDiscount: {
+        value: discountTotal / 100,
+        currency
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency: remote.shippingInfo?.price.currencyCode
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency
+      }
+    };
+    for (const remoteItem of remote.lineItems) {
+      const item = CheckoutItemSchema.parse({});
+      item.identifier.key = remoteItem.id;
+      item.sku.key = remoteItem.variant.sku || "";
+      item.quantity = remoteItem.quantity;
+      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;
+      item.price = {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency
+        },
+        totalPrice: {
+          value: (totalPrice || 0) / 100,
+          currency
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency
+        }
+      };
+      result.items.push(item);
+    }
+    result.readyForFinalization = this.isReadyForFinalization(result);
+    result.meta = {
+      cache: {
+        hit: false,
+        key: this.generateCacheKeySingle(result.identifier, reqCtx)
+      },
+      placeholder: false
+    };
+    return this.assert(result);
+  }
+  isReadyForFinalization(checkout) {
+    if (!checkout.billingAddress)
+      return false;
+    if (!checkout.shippingInstruction)
+      return false;
+    if (!checkout.shippingAddress && !checkout.shippingInstruction.pickupPoint)
+      return false;
+    if (checkout.paymentInstructions.length === 0)
+      return false;
+    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;
+    return true;
+  }
+  parsePaymentInstruction(remote, reqCtx) {
+    const newModel = PaymentInstructionSchema.parse({});
+    newModel.identifier = PaymentInstructionIdentifierSchema.parse({ key: remote.id || "" });
+    newModel.amount = {
+      value: remote.amountPlanned.centAmount / 100,
+      currency: remote.amountPlanned.currencyCode
+    };
+    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"
+    });
+    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";
+    }
+    return PaymentInstructionSchema.parse(newModel);
+  }
+  parseAddress(remote, reqCtx) {
+    return AddressSchema.parse({
+      countryCode: remote.country || "",
+      firstName: remote.firstName || "",
+      lastName: remote.lastName || "",
+      streetAddress: remote.streetName || "",
+      streetNumber: remote.streetNumber || "",
+      postalCode: remote.postalCode || "",
+      city: remote.city || ""
+    });
+  }
+  parseShippingInstruction(remote) {
+    if (!remote.shippingInfo)
+      return void 0;
+    const instructions = remote.custom?.fields["shippingInstruction"] || "";
+    const consentForUnattendedDelivery = remote.custom?.fields["consentForUnattendedDelivery"] === "true" || false;
+    const pickupPoint = remote.custom?.fields["pickupPointId"] || "";
+    const shippingInstruction = ShippingInstructionSchema.parse({
+      amount: {
+        value: (remote.shippingInfo.price.centAmount || 0) / 100,
+        currency: remote.shippingInfo.price.currencyCode
+      },
+      shippingMethod: {
+        key: remote.shippingInfo.shippingMethod?.obj?.key || ""
+      },
+      pickupPoint: pickupPoint || "",
+      instructions: instructions || "",
+      consentForUnattendedDelivery: consentForUnattendedDelivery || false
+    });
+    return shippingInstruction;
+  }
+}
+export {
+  CheckoutNotReadyForFinalizationError,
+  CommercetoolsCheckoutProvider
+};