@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,169 +1,195 @@
 import {
+  CartIdentifierSchema,
   CartItemSchema,
-  CartProvider
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationDeleteCartSchema,
+  CartMutationItemAddSchema,
+  CartMutationItemQuantityChangeSchema,
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartProvider,
+  CartQueryByIdSchema,
+  CartSchema,
+  Reactionary,
+  success,
+  error,
+  unwrapValue,
+  assertSuccess,
 } from '@reactionary/core';
 import type {
+  CartItem,
   CartMutationItemAdd,
   CartMutationItemQuantityChange,
   CartMutationItemRemove,
   CartQueryById,
-  CartIdentifier, CartMutationApplyCoupon,
-  CartMutationCheckout,
+  CartIdentifier,
+  CartMutationApplyCoupon,
   CartMutationDeleteCart,
-  CartMutationRemoveCoupon, CartMutationSetBillingAddress,
-  CartMutationSetShippingInfo,
-  CartMutationChangeCurrency, OrderIdentifier,
+  CartMutationRemoveCoupon,
+  CartMutationChangeCurrency,
   RequestContext,
   Cart,
-  Currency
-,
-  Cache
+  Currency,
+  Cache,
+  CostBreakDown,
+  Result,
+  NotFoundError,
 } from '@reactionary/core';
-
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { z } from 'zod';
-import { CommercetoolsClient } from '../core/client.js';
 import type {
   Cart as CTCart,
+  LineItem,
   MyCartUpdateAction,
 } from '@commercetools/platform-sdk';
-import type {
-  CommercetoolsCartIdentifier} from '../schema/commercetools.schema.js';
-import {
-  CommercetoolsCartIdentifierSchema,
-  CommercetoolsOrderIdentifierSchema,
-} from '../schema/commercetools.schema.js';
+import type { CommercetoolsCartIdentifier } from '../schema/commercetools.schema.js';
+import { CommercetoolsCartIdentifierSchema } from '../schema/commercetools.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
 
-export class CommercetoolsCartProvider<
-  T extends Cart = Cart
-> extends CartProvider<T> {
+export class CommercetoolsCartProvider extends CartProvider {
   protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
   constructor(
     config: CommercetoolsConfiguration,
-    schema: z.ZodType<T>,
-    cache: Cache
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
   ) {
-    super(schema, cache);
+    super(cache, context);
+
     this.config = config;
+    this.commercetools = commercetools;
   }
 
-  public override async getById(
-    payload: CartQueryById,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    try {
-      const client = await this.getClient(reqCtx);
-
-      const ctId = payload.cart as CommercetoolsCartIdentifier;
+  @Reactionary({
+    inputSchema: CartQueryByIdSchema,
+    outputSchema: CartSchema,
+  })
+  public override async getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>> {
+    const client = await this.getClient();
+    const ctId = payload.cart as CommercetoolsCartIdentifier;
 
+    try {
       const remote = await client.carts.withId({ ID: ctId.key }).get().execute();
 
-      return this.parseSingle(remote.body, reqCtx);
-    } catch (e) {
-      return this.createEmptyCart();
+      return success(this.parseSingle(remote.body));
+    } catch(err) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: ctId
+      });
     }
   }
 
-  public override async add(
-    payload: CartMutationItemAdd,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
-
+  @Reactionary({
+    inputSchema: CartMutationItemAddSchema,
+    outputSchema: CartSchema,
+  })
+  public override async add(payload: CartMutationItemAdd): Promise<Result<Cart>> {
     let cartIdentifier = payload.cart;
-    if (!cartIdentifier.key) {
-      cartIdentifier = await this.createCart(reqCtx);
+    if (!cartIdentifier) {
+      cartIdentifier = await this.createCart();
     }
 
-    return this.applyActions(
-      cartIdentifier,
-      [
-        {
-          action: 'addLineItem',
-          quantity: payload.quantity,
-          sku: payload.sku.key,
-        },
-        {
-          action: 'recalculate',
+    const result = await this.applyActions(cartIdentifier, [
+      {
+        action: 'addLineItem',
+        quantity: payload.quantity,
+        sku: payload.variant.sku,
+        // FIXME: This should be dynamic, probably as part of the context...
+        distributionChannel: {
+          typeId: 'channel',
+          key: 'OnlineFfmChannel',
         },
-      ],
-      reqCtx
-    );
+      },
+      {
+        action: 'recalculate',
+      },
+    ]);
+
+    return success(result);
   }
 
-  public override async remove(
-    payload: CartMutationItemRemove,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    return this.applyActions(
-      payload.cart,
-      [
-        {
-          action: 'removeLineItem',
-          lineItemId: payload.item.key,
-        },
-        {
-          action: 'recalculate',
-        },
-      ],
-      reqCtx
-    );
+  @Reactionary({
+    inputSchema: CartMutationItemRemoveSchema,
+    outputSchema: CartSchema,
+  })
+  public override async remove(payload: CartMutationItemRemove): Promise<Result<Cart>> {
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: 'removeLineItem',
+        lineItemId: payload.item.key,
+      },
+      {
+        action: 'recalculate',
+      },
+    ]);
+
+    return success(result);
   }
 
+  @Reactionary({
+    inputSchema: CartMutationItemQuantityChangeSchema,
+    outputSchema: CartSchema,
+  })
   public override async changeQuantity(
-    payload: CartMutationItemQuantityChange,
-    reqCtx: RequestContext
-  ): Promise<T> {
+    payload: CartMutationItemQuantityChange
+  ): Promise<Result<Cart>> {
     if (payload.quantity === 0) {
       // Changing quantity to 0 is not allowed. Use the remove call instead. This is done to avoid accidental removal of item.
       // Calls with quantity 0 will just be ignored.
-      return this.getById({ cart: payload.cart }, reqCtx);
+      const existing = await this.getById({ cart: payload.cart });
+
+      // TODO: Should we instead allow returning NotFound here, if that is indeed the case?
+      assertSuccess(existing);
+
+      return existing;
     }
 
-    return this.applyActions(
-      payload.cart,
-      [
-        {
-          action: 'changeLineItemQuantity',
-          lineItemId: payload.item.key,
-          quantity: payload.quantity,
-        },
-        {
-          action: 'recalculate',
-        },
-      ],
-      reqCtx
-    );
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: 'changeLineItemQuantity',
+        lineItemId: payload.item.key,
+        quantity: payload.quantity,
+      },
+      {
+        action: 'recalculate',
+      },
+    ]);
+
+    return success(result);
   }
 
-  public override async getActiveCartId(
-    reqCtx: RequestContext
-  ): Promise<CartIdentifier> {
-    const client = await this.getClient(reqCtx);
+  @Reactionary({
+    outputSchema: CartIdentifierSchema,
+  })
+  public override async getActiveCartId(): Promise<Result<CartIdentifier, NotFoundError>> {
+    const client = await this.getClient();
     try {
-      const carts = await client.activeCart
-        .get()
-        .execute();
-
-      return CommercetoolsCartIdentifierSchema.parse({
+      const carts = await client.activeCart.get().execute();
+      const result = await CommercetoolsCartIdentifierSchema.parse({
         key: carts.body.id,
-        version: carts.body.version || 0
+        version: carts.body.version || 0,
       });
-    } catch (e: any) {
 
-      return CommercetoolsCartIdentifierSchema.parse({
-        key: '',
-      version: 0
-      });
+      return success(result);
+    } catch (e: any) {
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: {}
+      })
     }
   }
 
+  @Reactionary({
+    inputSchema: CartMutationDeleteCartSchema,
+    outputSchema: CartSchema,
+  })
   public override async deleteCart(
-    payload: CartMutationDeleteCart,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
+    payload: CartMutationDeleteCart
+  ): Promise<Result<void>> {
+    const client = await this.getClient();
     if (payload.cart.key) {
       const ctId = payload.cart as CommercetoolsCartIdentifier;
 
@@ -178,154 +204,65 @@ export class CommercetoolsCartProvider<
         .execute();
     }
 
-    const activeCartId = await this.getActiveCartId(reqCtx);
-    return this.getById({ cart: activeCartId }, reqCtx);
+    return success(undefined);
   }
 
-  public override async setShippingInfo(
-    payload: CartMutationSetShippingInfo,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
-    const ctId = payload.cart as CommercetoolsCartIdentifier;
-
-    const actions: MyCartUpdateAction[] = new Array<MyCartUpdateAction>();
-    if (payload.shippingMethod) {
-      actions.push({
-        action: 'setShippingMethod',
-        shippingMethod: {
-          typeId: 'shipping-method',
-          id: payload.shippingMethod.key,
-        },
-      });
-    }
-
-    if (payload.shippingAddress) {
-      actions.push({
-        action: 'setShippingAddress',
-        address: {
-          country: payload.shippingAddress.countryCode || reqCtx.taxJurisdiction.countryCode || 'US',
-          firstName: payload.shippingAddress.firstName,
-          lastName: payload.shippingAddress.lastName,
-          city: payload.shippingAddress.city,
-          postalCode: payload.shippingAddress.postalCode,
-          streetName: payload.shippingAddress.streetAddress,
-          streetNumber: payload.shippingAddress.streetNumber,
-        },
-      });
-    }
-
-    return this.applyActions(payload.cart, actions, reqCtx);
-  }
+  @Reactionary({
+    inputSchema: CartMutationApplyCouponSchema,
+    outputSchema: CartSchema,
+  })
+  public override async  applyCouponCode(
+    payload: CartMutationApplyCoupon
+  ): Promise<Result<Cart>> {
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: 'addDiscountCode',
+        code: payload.couponCode,
+      },
+      {
+        action: 'recalculate',
+      },
+    ]);
 
-  public override setBillingAddress(
-    payload: CartMutationSetBillingAddress,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    return this.applyActions(
-      payload.cart,
-      [
-        {
-          action: 'setBillingAddress',
-          address: {
-            email: payload.notificationEmailAddress,
-            mobile: payload.notificationPhoneNumber,
-            country: payload.billingAddress.countryCode || reqCtx.taxJurisdiction.countryCode || 'US',
-            firstName: payload.billingAddress.firstName,
-            lastName: payload.billingAddress.lastName,
-            city: payload.billingAddress.city,
-            postalCode: payload.billingAddress.postalCode,
-            streetName: payload.billingAddress.streetAddress,
-            streetNumber: payload.billingAddress.streetNumber,
-          },
-        },
-        {
-          action: 'setCustomerEmail',
-          email: payload.notificationEmailAddress,
-        },
-        {
-          action: 'setCountry',
-          country: payload.billingAddress.countryCode || reqCtx.taxJurisdiction.countryCode || 'US',
-        },
-      ],
-      reqCtx
-    );
+    return success(result);
   }
 
-  public override applyCouponCode(
-    payload: CartMutationApplyCoupon,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    return this.applyActions(
-      payload.cart,
-      [
-        {
-          action: 'addDiscountCode',
-          code: payload.couponCode,
+  @Reactionary({
+    inputSchema: CartMutationRemoveCouponSchema,
+    outputSchema: CartSchema,
+  })
+  public override async removeCouponCode(
+    payload: CartMutationRemoveCoupon
+  ): Promise<Result<Cart>> {
+    const result = await this.applyActions(payload.cart, [
+      {
+        action: 'removeDiscountCode',
+        discountCode: {
+          id: payload.couponCode,
+          typeId: 'discount-code',
         },
-        {
-          action: 'recalculate',
-        },
-      ],
-      reqCtx
-    );
-  }
+      },
+      {
+        action: 'recalculate',
+      },
+    ]);
 
-  public override removeCouponCode(
-    payload: CartMutationRemoveCoupon,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    return this.applyActions(
-      payload.cart,
-      [
-        {
-          action: 'removeDiscountCode',
-          discountCode: {
-            id: payload.couponCode,
-            typeId: 'discount-code',
-          },
-        },
-        {
-          action: 'recalculate',
-        },
-      ],
-      reqCtx
-    );
-  }
-
-  public override async checkout(
-    payload: CartMutationCheckout,
-    reqCtx: RequestContext
-  ): Promise<OrderIdentifier> {
-    // In Commercetools, checkout is done by creating an order from the cart.
-
-    const client = await this.getClient(reqCtx);
-    const ctId = payload.cart as CommercetoolsCartIdentifier;
-
-    const orderResponse = await client.orders
-      .post({
-        body: {
-          version: ctId.version,
-          id: ctId.key,
-        }
-      })
-      .execute();
-    return CommercetoolsOrderIdentifierSchema.parse({
-      key: orderResponse.body.id,
-      version: orderResponse.body.version || 0,
-    });
+    return success(result);
   }
 
+  @Reactionary({
+    inputSchema: CartMutationChangeCurrencySchema,
+    outputSchema: CartSchema,
+  })
   public override async changeCurrency(
-    payload: CartMutationChangeCurrency,
-    reqCtx: RequestContext
-  ): Promise<T> {
+    payload: CartMutationChangeCurrency
+  ): Promise<Result<Cart>> {
     // ok, to do this we have to actually build a new cart, copy over all the items, and then delete the old cart.
     // because Commercetools does not support changing currency of an existing cart.
 
     // This is obviously not ideal, but it is what it is.
 
-    const client = await this.getClient(reqCtx);
+    const client = await this.getClient();
     const currentCart = await client.carts
       .withId({ ID: payload.cart.key })
       .get()
@@ -334,7 +271,7 @@ export class CommercetoolsCartProvider<
       .post({
         body: {
           currency: payload.newCurrency,
-          locale: reqCtx.languageContext.locale,
+          locale: this.context.languageContext.locale,
         },
       })
       .execute();
@@ -352,16 +289,12 @@ export class CommercetoolsCartProvider<
       })
     );
 
-    const response = await this.applyActions(
-      newCartId,
-      [
-        ...cartItemAdds,
-        {
-          action: 'recalculate',
-        },
-      ],
-      reqCtx
-    );
+    const response = await this.applyActions(newCartId, [
+      ...cartItemAdds,
+      {
+        action: 'recalculate',
+      },
+    ]);
 
     // now delete the old cart.
     await client.carts
@@ -374,17 +307,17 @@ export class CommercetoolsCartProvider<
       })
       .execute();
 
-    return response;
+    return success(response);
   }
 
-  protected async createCart(reqCtx: RequestContext): Promise<CartIdentifier> {
-    const client = await this.getClient(reqCtx);
+  protected async createCart(): Promise<CartIdentifier> {
+    const client = await this.getClient();
     const response = await client.carts
       .post({
         body: {
-          currency: reqCtx.languageContext.currencyCode || 'USD',
-          country: reqCtx.taxJurisdiction.countryCode || 'US',
-          locale: reqCtx.languageContext.locale,
+          currency: this.context.languageContext.currencyCode || 'USD',
+          country: this.context.taxJurisdiction.countryCode || 'US',
+          locale: this.context.languageContext.locale,
         },
       })
       .execute();
@@ -397,66 +330,98 @@ export class CommercetoolsCartProvider<
 
   protected async applyActions(
     cart: CartIdentifier,
-    actions: MyCartUpdateAction[],
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
+    actions: MyCartUpdateAction[]
+  ): Promise<Cart> {
+    const client = await this.getClient();
     const ctId = cart as CommercetoolsCartIdentifier;
 
+    try {
+      const response = await client.carts
+        .withId({ ID: ctId.key })
+        .post({
+          body: {
+            version: ctId.version,
+            actions,
+          },
+        })
+        .execute();
 
-       try {
-        const response = await client.carts
-          .withId({ ID: ctId.key })
-          .post({
-            body: {
-              version: ctId.version,
-              actions,
-            },
-          })
-          .execute();
-
-          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;
-       }
-
+      if (response.error) {
+        console.error(response.error);
+      }
+      return this.parseSingle(response.body);
+    } catch (e: any) {
+      console.error('Error applying actions to cart:', e);
+      throw e;
+    }
   }
 
   /**
    * Creates a new Commercetools client, optionally upgrading it from Anonymous mode to Guest mode.
    * For now, any Query or Mutation will require an upgrade to Guest mode.
    * In the future, maybe we can delay this upgrade until we actually need it.
-   *
-   * @param reqCtx
-   * @param anonymousCall
-   * @returns
    */
-  protected async getClient(reqCtx: RequestContext) {
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+
+    const clientWithProject = client.withProjectKey({
+      projectKey: this.config.projectKey,
+    });
 
-    const clientWithProject = client.withProjectKey({ projectKey: this.config.projectKey });
     return {
       carts: clientWithProject.me().carts(),
       activeCart: clientWithProject.me().activeCart(),
       orders: clientWithProject.me().orders(),
-
-    }
+    };
   }
 
-  protected override parseSingle(remote: CTCart, reqCtx: RequestContext): T {
-    const result = this.newModel();
+  protected parseCartItem(remoteItem: LineItem): CartItem {
+    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,
+      },
+      product: {
+        key: remoteItem.productId,
+      },
+      variant: {
+        sku: remoteItem.variant.sku || '',
+      },
+      quantity: remoteItem.quantity,
+      price: {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency,
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency,
+        },
+        totalPrice: {
+          value: (totalPrice || 0) / 100,
+          currency,
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency,
+        },
+      },
+    } satisfies CartItem;
+
+    return CartItemSchema.parse(item);
+  }
 
-    result.identifier = CommercetoolsCartIdentifierSchema.parse({
+  protected parseSingle(remote: CTCart): Cart {
+    const identifier = {
       key: remote.id,
       version: remote.version || 0,
-    });
-
-    result.name = remote.custom?.fields['name'] || '';
-    result.description = remote.custom?.fields['description'] || '';
+    } satisfies CommercetoolsCartIdentifier;
 
     const grandTotal = remote.totalPrice.centAmount || 0;
     const shippingTotal = remote.shippingInfo?.price.centAmount || 0;
@@ -467,7 +432,7 @@ export class CommercetoolsCartProvider<
     const surchargeTotal = 0;
     const currency = remote.totalPrice.currencyCode as Currency;
 
-    result.price = {
+    const price = {
       totalTax: {
         value: taxTotal / 100,
         currency,
@@ -482,7 +447,7 @@ export class CommercetoolsCartProvider<
       },
       totalShipping: {
         value: shippingTotal / 100,
-        currency: remote.shippingInfo?.price.currencyCode as Currency,
+        currency,
       },
       totalProductPrice: {
         value: productTotal / 100,
@@ -492,51 +457,26 @@ export class CommercetoolsCartProvider<
         value: grandTotal / 100,
         currency,
       },
-    };
+    } satisfies CostBreakDown;
 
+    const items = new Array<CartItem>();
     for (const remoteItem of remote.lineItems) {
-      const item = CartItemSchema.parse({});
-
-      item.identifier.key = remoteItem.id;
-      item.product.key = remoteItem.productId;
-      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,
-        },
-      };
+      const item = this.parseCartItem(remoteItem);
 
-      result.items.push(item);
+      items.push(item);
     }
 
-    result.meta = {
-      cache: {
-        hit: false,
-        key: this.generateCacheKeySingle(result.identifier, reqCtx),
+    const cart = {
+      identifier,
+      userId: {
+        userId: '???',
       },
-      placeholder: false,
-    };
+      name: remote.custom?.fields['name'] || '',
+      description: remote.custom?.fields['description'] || '',
+      price,
+      items,
+    } satisfies Cart;
 
-    return this.assert(result);
+    return cart;
   }
 }