@reactionary/source 0.3.18 → 0.6.2

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

@@ -1,10 +1,12 @@
-import type { Address as CTAddress, Cart as CTCart, Payment as CTPayment, ShippingMethod as CTShippingMethod, LineItem, MyCartUpdateAction } from '@commercetools/platform-sdk';
+import type { MyCartUpdateAction } from '@commercetools/platform-sdk';
 import type {
-  Address,
   Cache,
-  Checkout,
+  CheckoutFactory,
+  CheckoutFactoryCheckoutOutput,
+  CheckoutFactoryPaymentMethodOutput,
+  CheckoutFactoryShippingMethodOutput,
+  CheckoutFactoryWithOutput,
   CheckoutIdentifier,
-  CheckoutItem,
   CheckoutMutationAddPaymentInstruction,
   CheckoutMutationFinalizeCheckout,
   CheckoutMutationInitiateCheckout,
@@ -14,23 +16,12 @@ import type {
   CheckoutQueryById,
   CheckoutQueryForAvailablePaymentMethods,
   CheckoutQueryForAvailableShippingMethods,
-  CostBreakDown,
-  Currency,
-  MonetaryAmount,
   NotFoundError,
-  PaymentInstruction,
-  PaymentInstructionIdentifier,
   PaymentMethod,
-  PaymentMethodIdentifier,
-  PaymentStatus,
   RequestContext,
   Result,
-  ShippingInstruction,
-  ShippingMethod,
-  ShippingMethodIdentifier,
 } from '@reactionary/core';
 import {
-  CheckoutItemSchema,
   CheckoutMutationAddPaymentInstructionSchema,
   CheckoutMutationFinalizeCheckoutSchema,
   CheckoutMutationInitiateCheckoutSchema,
@@ -51,11 +42,9 @@ import {
 } from '@reactionary/core';
 import * as z from 'zod';
 import type { CommercetoolsAPI } from '../core/client.js';
-import {
-  type CommercetoolsCartIdentifier,
-  type CommercetoolsCheckoutIdentifier,
-} from '../schema/commercetools.schema.js';
+import { type CommercetoolsCheckoutIdentifier } from '../schema/commercetools.schema.js';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsCheckoutFactory } from '../factories/checkout/checkout.factory.js';
 
 export class CheckoutNotReadyForFinalizationError extends Error {
   constructor(public checkoutIdentifier: CheckoutIdentifier) {
@@ -69,20 +58,29 @@ export class CheckoutNotReadyForFinalizationError extends Error {
   }
 }
 
-export class CommercetoolsCheckoutProvider extends CheckoutProvider {
+export class CommercetoolsCheckoutProvider<
+  TFactory extends CheckoutFactory = CommercetoolsCheckoutFactory,
+> extends CheckoutProvider<
+  CheckoutFactoryCheckoutOutput<TFactory>,
+  CheckoutFactoryShippingMethodOutput<TFactory>,
+  CheckoutFactoryPaymentMethodOutput<TFactory>
+> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: CheckoutFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: CheckoutFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   protected async getClient() {
@@ -113,7 +111,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async initiateCheckoutForCart(
     payload: CheckoutMutationInitiateCheckout
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     // so......we could copy the cart......
 
     const client = await this.getClient();
@@ -187,14 +185,14 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
       })
       .execute();
 
-    return success(this.parseSingle(checkoutResponse.body));
+    return success(this.factory.parseCheckout(this.context, checkoutResponse.body));
   }
 
   @Reactionary({
     inputSchema: CheckoutQueryByIdSchema,
     outputSchema: CheckoutSchema.nullable(),
   })
-  public async getById(payload: CheckoutQueryById): Promise<Result<Checkout, NotFoundError>> {
+  public async getById(payload: CheckoutQueryById): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>, NotFoundError>> {
     const client = await this.getClient();
     const checkoutResponse = await client.carts
       .withId({ ID: payload.identifier.key })
@@ -205,7 +203,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
       })
       .execute();
 
-    const checkout = this.parseSingle(checkoutResponse.body);
+    const checkout = this.factory.parseCheckout(this.context, checkoutResponse.body);
 
     if (checkoutResponse.body.cartState === 'Ordered') {
       const order = await client.orders
@@ -230,7 +228,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async setShippingAddress(
     payload: CheckoutMutationSetShippingAddress
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const client = await this.getClient();
 
     const version = (payload.checkout as CommercetoolsCheckoutIdentifier)
@@ -258,7 +256,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
       })
       .execute();
 
-    return success(this.parseSingle(checkoutResponse.body));
+    return success(this.factory.parseCheckout(this.context, checkoutResponse.body));
   }
 
   @Reactionary({
@@ -267,7 +265,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async getAvailableShippingMethods(
     payload: CheckoutQueryForAvailableShippingMethods
-  ): Promise<Result<ShippingMethod[]>> {
+  ): Promise<Result<CheckoutFactoryShippingMethodOutput<TFactory>[]>> {
     const client = await this.getClient();
     const shippingMethodsResponse = await client.shippingMethods
       .matchingCart()
@@ -278,33 +276,10 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
       })
       .execute();
 
-    const result: Array<ShippingMethod> = [];
-    const inputShippingMethods: CTShippingMethod[] = shippingMethodsResponse
-      .body.results as CTShippingMethod[];
-    for (const sm of inputShippingMethods) {
-      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;
+    const result = shippingMethodsResponse.body.results.map((shippingMethod) =>
+      this.factory.parseShippingMethod(this.context, shippingMethod),
+    );
 
-      result.push(shippingMethod);
-    }
     return success(result);
   }
 
@@ -314,7 +289,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async getAvailablePaymentMethods(
     payload: CheckoutQueryForAvailablePaymentMethods
-  ): Promise<Result<PaymentMethod[]>> {
+  ): Promise<Result<CheckoutFactoryPaymentMethodOutput<TFactory>[]>> {
     // 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);
@@ -322,7 +297,11 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
     const dynamicMethods: PaymentMethod[] = [];
     // later we will also fetch any stored payment methods the user has...
 
-    return success([...staticMethods, ...dynamicMethods]);
+    const result = [...staticMethods, ...dynamicMethods].map((paymentMethod) =>
+      this.factory.parsePaymentMethod(this.context, paymentMethod),
+    );
+
+    return success(result);
   }
 
   @Reactionary({
@@ -331,7 +310,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async addPaymentInstruction(
     payload: CheckoutMutationAddPaymentInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const client = await this.getClient();
 
     const response = await client.payments
@@ -391,7 +370,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async removePaymentInstruction(
     payload: CheckoutMutationRemovePaymentInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     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
@@ -458,7 +437,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async setShippingInstruction(
     payload: CheckoutMutationSetShippingInstruction
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const actions: MyCartUpdateAction[] = [];
     actions.push({
       action: 'setShippingMethod',
@@ -497,7 +476,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   })
   public async finalizeCheckout(
     payload: CheckoutMutationFinalizeCheckout
-  ): Promise<Result<Checkout>> {
+  ): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>> {
     const checkout = await this.getById({ identifier: payload.checkout });
     if (!checkout.success || !checkout.value.readyForFinalization) {
       throw new CheckoutNotReadyForFinalizationError(payload.checkout);
@@ -507,7 +486,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
     const ctId = payload.checkout as CommercetoolsCheckoutIdentifier;
 
     // create the order from the cart
-    const orderResponse = await client.orders
+    await client.orders
       .post({
         body: {
           id: ctId.key,
@@ -516,15 +495,21 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
       })
       .execute();
 
-    return this.getById({
+    const result = await this.getById({
       identifier: payload.checkout,
-    }) as unknown as Result<Checkout>;
+    });
+
+    if (!result.success) {
+      throw new Error('Unable to fetch checkout after finalization.');
+    }
+
+    return success(result.value);
   }
 
   protected async applyActions(
     checkout: CheckoutIdentifier,
     actions: MyCartUpdateAction[]
-  ): Promise<Checkout> {
+  ): Promise<CheckoutFactoryCheckoutOutput<TFactory>> {
     const client = await this.getClient();
     const ctId = checkout as CommercetoolsCheckoutIdentifier;
 
@@ -546,7 +531,7 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
         console.error(response.error);
       }
 
-      const p = this.parseSingle(response.body);
+      const p = this.factory.parseCheckout(this.context, response.body);
 
       return p;
     } catch (e: any) {
@@ -566,261 +551,4 @@ export class CommercetoolsCheckoutProvider extends CheckoutProvider {
   ): PaymentMethod[] {
     return this.config.paymentMethods || [];
   }
-
-  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,
-        },
-        unitDiscount: {
-          value: unitDiscount / 100,
-          currency,
-        },
-        totalPrice: {
-          value: (totalPrice || 0) / 100,
-          currency,
-        },
-        totalDiscount: {
-          value: totalDiscount / 100,
-          currency,
-        },
-      },
-    } satisfies CheckoutItem;
-
-    return CheckoutItemSchema.parse(item);
-  }
-
-  protected parseSingle(remote: CTCart): Checkout {
-    const identifier = {
-      key: remote.id,
-      version: remote.version || 0,
-    } satisfies CommercetoolsCheckoutIdentifier;
-
-    const originalCartReference = {
-      key: remote.custom?.fields['commerceToolsCartId'] || '',
-      version: 0,
-    } satisfies CommercetoolsCartIdentifier;
-
-    let shippingAddress: Address | undefined;
-    if (remote.shippingAddress) {
-      shippingAddress = this.parseAddress(remote.shippingAddress);
-    }
-
-    let billingAddress: Address | undefined;
-    if (remote.billingAddress) {
-      billingAddress = this.parseAddress(remote.billingAddress);
-    }
-
-    const paymentInstructions = new Array<PaymentInstruction>();
-    for (const p of remote.paymentInfo?.payments || []) {
-      if (p.obj) {
-        paymentInstructions.push(this.parsePaymentInstruction(p.obj));
-      }
-    }
-
-    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;
-
-    const items = new Array<CheckoutItem>();
-    for (const remoteItem of remote.lineItems) {
-      const item = this.parseCheckoutItem(remoteItem);
-      items.push(item);
-    }
-
-    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;
-
-    return result;
-  }
-
-  protected isReadyForFinalization(
-    price: CostBreakDown,
-    paymentInstructions: Array<PaymentInstruction>,
-    billingAddress?: Address,
-    shippingAddress?: Address,
-    shippingInstruction?: ShippingInstruction
-  ): boolean {
-    // we should have a billing address
-    if (!billingAddress) return false;
-
-    // we should know how to ship it
-    if (!shippingInstruction) return false;
-
-    // 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;
-
-    return true;
-  }
-
-  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';
-      }
-    } else {
-      status = 'pending';
-    }
-
-    const result = {
-      amount,
-      identifier,
-      paymentMethod,
-      protocolData,
-      status
-    } satisfies PaymentInstruction;
-
-    return result;
-  }
-
-  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;
-  }
-
-  protected parseShippingInstruction(
-    remote: CTCart
-  ): ShippingInstruction | undefined {
-    if (!remote.shippingInfo) return undefined;
-
-    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;
-  }
 }

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

@@ -1,5 +1,7 @@
 import {
-  type Identity,
+  type IdentityFactory,
+  type IdentityFactoryOutput,
+  type IdentityFactoryWithOutput,
   type IdentityMutationLogin,
   type IdentityQuerySelf,
   type RequestContext,
@@ -16,29 +18,38 @@ import {
 } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsIdentityFactory } from '../factories/identity/identity.factory.js';
 
-export class CommercetoolsIdentityProvider extends IdentityProvider {
+export class CommercetoolsIdentityProvider<
+  TFactory extends IdentityFactory = CommercetoolsIdentityFactory,
+> extends IdentityProvider<IdentityFactoryOutput<TFactory>> {
   protected config: CommercetoolsConfiguration;
   protected commercetools: CommercetoolsAPI;
+  protected factory: IdentityFactoryWithOutput<TFactory>;
 
   constructor(
     config: CommercetoolsConfiguration,
     cache: Cache,
     context: RequestContext,
-    commercetools: CommercetoolsAPI
+    commercetools: CommercetoolsAPI,
+    factory: IdentityFactoryWithOutput<TFactory>,
   ) {
     super(cache, context);
 
     this.config = config;
     this.commercetools = commercetools;
+    this.factory = factory;
   }
 
   @Reactionary({
     inputSchema: IdentityQuerySelfSchema,
     outputSchema: IdentitySchema,
   })
-  public override async getSelf(payload: IdentityQuerySelf): Promise<Result<Identity>> {
-    const identity = await this.commercetools.introspect();
+  public override async getSelf(payload: IdentityQuerySelf): Promise<Result<IdentityFactoryOutput<TFactory>>> {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.introspect(),
+    );
 
     this.updateIdentityContext(identity);
 
@@ -49,10 +60,13 @@ export class CommercetoolsIdentityProvider extends IdentityProvider {
     inputSchema: IdentityMutationLoginSchema,
     outputSchema: IdentitySchema,
   })
-  public override async login(payload: IdentityMutationLogin): Promise<Result<Identity>> {
-    const identity = await this.commercetools.login(
-      payload.username,
-      payload.password
+  public override async login(payload: IdentityMutationLogin): Promise<Result<IdentityFactoryOutput<TFactory>>> {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.login(
+        payload.username,
+        payload.password
+      )
     );
 
     this.updateIdentityContext(identity);
@@ -63,8 +77,11 @@ export class CommercetoolsIdentityProvider extends IdentityProvider {
   @Reactionary({
     outputSchema: IdentitySchema,
   })
-  public override async logout(payload: Record<string, never>): Promise<Result<Identity>> {
-    const identity = await this.commercetools.logout();
+  public override async logout(payload: Record<string, never>): Promise<Result<IdentityFactoryOutput<TFactory>>> {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.logout(),
+    );
 
     this.updateIdentityContext(identity);
 
@@ -77,10 +94,13 @@ export class CommercetoolsIdentityProvider extends IdentityProvider {
   })
   public override async register(
     payload: IdentityMutationRegister
-  ): Promise<Result<Identity>> {
-    const identity = await this.commercetools.register(
-      payload.username,
-      payload.password
+  ): Promise<Result<IdentityFactoryOutput<TFactory>>> {
+    const identity = this.factory.parseIdentity(
+      this.context,
+      await this.commercetools.register(
+        payload.username,
+        payload.password
+      )
     );
 
     this.updateIdentityContext(identity);