@reactionary/source 0.3.18 → 0.6.2

package/providers/commercetools/src/factories/checkout/checkout.factory.ts

@@ -0,0 +1,338 @@
+import type {
+  Address as CTAddress,
+  Cart as CTCart,
+  LineItem,
+  Payment as CTPayment,
+  ShippingMethod as CTShippingMethod,
+} from '@commercetools/platform-sdk';
+import type {
+  CheckoutSchema,
+  PaymentMethodSchema,
+  ShippingMethodSchema} from '@reactionary/core';
+import {
+  CheckoutItemSchema,
+  type Address,
+  type AnyCheckoutSchema,
+  type AnyPaymentMethodSchema,
+  type AnyShippingMethodSchema,
+  type Checkout,
+  type CheckoutFactory,
+  type CheckoutIdentifier,
+  type CheckoutItem,
+  type CostBreakDown,
+  type Currency,
+  type MonetaryAmount,
+  type PaymentInstruction,
+  type PaymentInstructionIdentifier,
+  type PaymentMethod,
+  type PaymentMethodIdentifier,
+  type PaymentStatus,
+  type RequestContext,
+  type ShippingInstruction,
+  type ShippingMethod,
+  type ShippingMethodIdentifier,
+} from '@reactionary/core';
+import type * as z from 'zod';
+import type {
+  CommercetoolsCartIdentifier,
+  CommercetoolsCheckoutIdentifier,
+} from '../../schema/commercetools.schema.js';
+
+export class CommercetoolsCheckoutFactory<
+  TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema,
+  TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema,
+  TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema,
+> implements
+    CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema>
+{
+  public readonly checkoutSchema: TCheckoutSchema;
+  public readonly shippingMethodSchema: TShippingMethodSchema;
+  public readonly paymentMethodSchema: TPaymentMethodSchema;
+
+  constructor(
+    checkoutSchema: TCheckoutSchema,
+    shippingMethodSchema: TShippingMethodSchema,
+    paymentMethodSchema: TPaymentMethodSchema,
+  ) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+
+  public parseCheckout(
+    context: RequestContext,
+    data: CTCart,
+  ): z.output<TCheckoutSchema> {
+    const identifier = {
+      key: data.id,
+      version: data.version || 0,
+    } satisfies CommercetoolsCheckoutIdentifier;
+
+    const originalCartReference = {
+      key: data.custom?.fields['commerceToolsCartId'] || '',
+      version: 0,
+    } satisfies CommercetoolsCartIdentifier;
+
+    let shippingAddress: Address | undefined;
+    if (data.shippingAddress) {
+      shippingAddress = this.parseAddress(data.shippingAddress);
+    }
+
+    let billingAddress: Address | undefined;
+    if (data.billingAddress) {
+      billingAddress = this.parseAddress(data.billingAddress);
+    }
+
+    const paymentInstructions: PaymentInstruction[] = [];
+    for (const payment of data.paymentInfo?.payments || []) {
+      if (payment.obj) {
+        paymentInstructions.push(this.parsePaymentInstruction(context, payment.obj));
+      }
+    }
+
+    const grandTotal = data.totalPrice.centAmount || 0;
+    const shippingTotal = data.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = data.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal = data.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = data.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,
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency,
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency,
+      },
+    } satisfies CostBreakDown;
+
+    const items: CheckoutItem[] = [];
+    for (const lineItem of data.lineItems) {
+      items.push(this.parseCheckoutItem(lineItem));
+    }
+
+    const shippingInstruction = this.parseShippingInstruction(data);
+    const readyForFinalization = this.isReadyForFinalization(
+      price,
+      paymentInstructions,
+      billingAddress,
+      shippingAddress,
+      shippingInstruction,
+    );
+
+    const result = {
+      identifier,
+      originalCartReference,
+      name: data.custom?.fields['name'] || '',
+      description: data.custom?.fields['description'] || '',
+      readyForFinalization,
+      billingAddress,
+      shippingAddress,
+      shippingInstruction,
+      paymentInstructions,
+      items,
+      price,
+    } satisfies Checkout;
+
+    return this.checkoutSchema.parse(result);
+  }
+
+  public parseShippingMethod(
+    context: RequestContext,
+    data: CTShippingMethod,
+  ): z.output<TShippingMethodSchema> {
+    const identifier = {
+      key: data.key || '',
+    } satisfies ShippingMethodIdentifier;
+
+    const result = {
+      deliveryTime: '',
+      description: data.localizedDescription?.[context.languageContext.locale] || '',
+      identifier,
+      name: data.name,
+      price: data.zoneRates[0].shippingRates[0].price
+        ? {
+            value: (data.zoneRates[0].shippingRates[0].price.centAmount || 0) / 100,
+            currency:
+              (data.zoneRates[0].shippingRates[0].price.currencyCode as Currency) ||
+              context.languageContext.currencyCode,
+          }
+        : { value: 0, currency: context.languageContext.currencyCode },
+    } satisfies ShippingMethod;
+
+    return this.shippingMethodSchema.parse(result);
+  }
+
+  public parsePaymentMethod(
+    _context: RequestContext,
+    data: PaymentMethod,
+  ): z.output<TPaymentMethodSchema> {
+    return this.paymentMethodSchema.parse(data);
+  }
+
+  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 / 100,
+          currency,
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency,
+        },
+      },
+    } satisfies CheckoutItem;
+
+    return CheckoutItemSchema.parse(item);
+  }
+
+  protected isReadyForFinalization(
+    price: CostBreakDown,
+    paymentInstructions: PaymentInstruction[],
+    billingAddress?: Address,
+    shippingAddress?: Address,
+    shippingInstruction?: ShippingInstruction,
+  ): boolean {
+    if (!billingAddress) return false;
+    if (!shippingInstruction) return false;
+    if (!shippingAddress && !shippingInstruction.pickupPoint) return false;
+    if (paymentInstructions.length === 0) return false;
+
+    const authorizedPayments = paymentInstructions
+      .filter((paymentInstruction) => paymentInstruction.status === 'authorized')
+      .map((paymentInstruction) => paymentInstruction.amount.value)
+      .reduce((sum, value) => sum + value, 0);
+
+    if (price.grandTotal.value !== authorizedPayments) return false;
+
+    return true;
+  }
+
+  protected parsePaymentInstruction(
+    context: RequestContext,
+    data: CTPayment,
+  ): PaymentInstruction {
+    const identifier = {
+      key: data.id,
+    } satisfies PaymentInstructionIdentifier;
+
+    const amount = {
+      value: data.amountPlanned.centAmount / 100,
+      currency: data.amountPlanned.currencyCode as Currency,
+    } satisfies MonetaryAmount;
+
+    const method = data.paymentMethodInfo?.method || 'unknown';
+    const paymentProcessor = data.paymentMethodInfo?.paymentInterface || method;
+    const paymentName = data.paymentMethodInfo.name?.[context.languageContext.locale];
+
+    const paymentMethod = {
+      method,
+      paymentProcessor,
+      name: paymentName || method || 'Unknown',
+    } satisfies PaymentMethodIdentifier;
+
+    const customData = data.custom?.fields || {};
+    const protocolData = Object.keys(customData).map((key) => ({
+      key,
+      value: customData[key],
+    }));
+
+    let status: PaymentStatus = 'pending';
+    if (data.transactions && data.transactions.length > 0) {
+      const lastTransaction = data.transactions[data.transactions.length - 1];
+      if (
+        lastTransaction.type === 'Authorization' &&
+        lastTransaction.state === 'Success'
+      ) {
+        status = 'authorized';
+      }
+    }
+
+    const result = {
+      amount,
+      identifier,
+      paymentMethod,
+      protocolData,
+      status,
+    } satisfies PaymentInstruction;
+
+    return result;
+  }
+
+  protected parseAddress(data: CTAddress): Address {
+    return {
+      countryCode: data.country || '',
+      firstName: data.firstName || '',
+      lastName: data.lastName || '',
+      streetAddress: data.streetName || '',
+      streetNumber: data.streetNumber || '',
+      postalCode: data.postalCode || '',
+      city: data.city || '',
+      identifier: {
+        nickName: '',
+      },
+      region: '',
+    } satisfies Address;
+  }
+
+  protected parseShippingInstruction(data: CTCart): ShippingInstruction | undefined {
+    if (!data.shippingInfo) return undefined;
+
+    const instructions = data.custom?.fields['shippingInstruction'] || '';
+    const consentForUnattendedDelivery =
+      data.custom?.fields['consentForUnattendedDelivery'] === 'true';
+    const pickupPoint = data.custom?.fields['pickupPointId'] || '';
+
+    const result = {
+      shippingMethod: {
+        key: data.shippingInfo.shippingMethod?.obj?.key || '',
+      },
+      pickupPoint,
+      instructions,
+      consentForUnattendedDelivery,
+    } satisfies ShippingInstruction;
+
+    return result;
+  }
+}

package/providers/commercetools/src/factories/identity/identity.factory.ts

@@ -0,0 +1,26 @@
+import type {
+  IdentitySchema} from '@reactionary/core';
+import {
+  type AnyIdentitySchema,
+  type IdentityFactory,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsIdentityFactory<
+  TIdentitySchema extends AnyIdentitySchema = typeof IdentitySchema,
+> implements IdentityFactory<TIdentitySchema>
+{
+  public readonly identitySchema: TIdentitySchema;
+
+  constructor(identitySchema: TIdentitySchema) {
+    this.identitySchema = identitySchema;
+  }
+
+  public parseIdentity(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TIdentitySchema> {
+    return this.identitySchema.parse(data);
+  }
+}

package/providers/commercetools/src/factories/inventory/inventory.factory.ts

@@ -0,0 +1,49 @@
+import type { InventoryEntry } from '@commercetools/platform-sdk';
+import type {
+  InventorySchema} from '@reactionary/core';
+import {
+  type AnyInventorySchema,
+  type Inventory,
+  type InventoryFactory,
+  type InventoryIdentifier,
+  type InventoryStatus,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsInventoryFactory<
+  TInventorySchema extends AnyInventorySchema = typeof InventorySchema,
+> implements InventoryFactory<TInventorySchema>
+{
+  public readonly inventorySchema: TInventorySchema;
+
+  constructor(inventorySchema: TInventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+
+  public parseInventory(
+    _context: RequestContext,
+    data: InventoryEntry,
+  ): z.output<TInventorySchema> {
+    const identifier = {
+      variant: { sku: data.sku || '' },
+      fulfillmentCenter: {
+        key: data.supplyChannel?.obj?.key || '',
+      },
+    } satisfies InventoryIdentifier;
+
+    const quantity = data.availableQuantity || 0;
+    let status: InventoryStatus = 'outOfStock';
+    if (quantity > 0) {
+      status = 'inStock';
+    }
+
+    const result = {
+      identifier,
+      quantity,
+      status,
+    } satisfies Inventory;
+
+    return this.inventorySchema.parse(result);
+  }
+}

package/providers/commercetools/src/factories/order/order.factory.ts

@@ -0,0 +1,149 @@
+import type { Order as CTOrder } from '@commercetools/platform-sdk';
+import type {
+  OrderSchema} from '@reactionary/core';
+import {
+  type AnyOrderSchema,
+  type CostBreakDown,
+  type Currency,
+  type ItemCostBreakdown,
+  type Order,
+  type OrderFactory,
+  type OrderIdentifier,
+  type OrderItem,
+  type OrderStatus,
+  type ProductVariantIdentifier,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+import type { CommercetoolsOrderIdentifier } from '../../schema/commercetools.schema.js';
+
+export class CommercetoolsOrderFactory<
+  TOrderSchema extends AnyOrderSchema = typeof OrderSchema,
+> implements OrderFactory<TOrderSchema>
+{
+  public readonly orderSchema: TOrderSchema;
+
+  constructor(orderSchema: TOrderSchema) {
+    this.orderSchema = orderSchema;
+  }
+
+  public parseOrder(
+    _context: RequestContext,
+    data: CTOrder,
+  ): z.output<TOrderSchema> {
+    const identifier = {
+      key: data.id,
+      version: data.version || 0,
+    } satisfies CommercetoolsOrderIdentifier;
+
+    const name = data.custom?.fields['name'] || '';
+    const description = data.custom?.fields['description'] || '';
+
+    const grandTotal = data.totalPrice.centAmount || 0;
+    const shippingTotal = data.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = data.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal = data.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = data.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: data.shippingInfo?.price.currencyCode as Currency,
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency,
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency,
+      },
+    } satisfies CostBreakDown;
+
+    let orderStatus: OrderStatus = 'AwaitingPayment';
+    if (data.paymentState === 'Paid' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (data.shipmentState === 'Ready' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (
+      (data.shipmentState === 'Shipped' || data.shipmentState === 'Delivered') &&
+      data.orderState === 'Completed'
+    ) {
+      orderStatus = 'Shipped';
+    }
+
+    const items: OrderItem[] = [];
+    for (const remoteItem of data.lineItems) {
+      const lineIdentifier = {
+        key: remoteItem.id,
+      } satisfies OrderIdentifier;
+      const variant = {
+        sku: remoteItem.variant.sku || '',
+      } satisfies ProductVariantIdentifier;
+
+      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 linePrice = {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency,
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency,
+        },
+        totalPrice: {
+          value: totalPrice / 100,
+          currency,
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency,
+        },
+      } satisfies ItemCostBreakdown;
+
+      items.push({
+        identifier: lineIdentifier,
+        inventoryStatus: 'NotAllocated',
+        price: linePrice,
+        quantity: remoteItem.quantity,
+        variant,
+      } satisfies OrderItem);
+    }
+
+    const result = {
+      identifier,
+      name,
+      description,
+      price,
+      items,
+      inventoryStatus: 'NotAllocated',
+      paymentInstructions: [],
+      userId: {
+        userId: '',
+      },
+      orderStatus,
+    } satisfies Order;
+
+    return this.orderSchema.parse(result);
+  }
+}

package/providers/commercetools/src/factories/order-search/order-search.factory.ts

@@ -0,0 +1,108 @@
+import type {
+  Address as CTAddress,
+  Order as CTOrder,
+  OrderPagedQueryResponse,
+} from '@commercetools/platform-sdk';
+import type {
+  OrderSearchResultSchema} from '@reactionary/core';
+import {
+  type Address,
+  type AnyOrderSearchResultSchema,
+  type Currency,
+  type IdentityIdentifier,
+  type MonetaryAmount,
+  type OrderSearchFactory,
+  type OrderSearchQueryByTerm,
+  type OrderSearchResult,
+  type OrderSearchResultItem,
+  type OrderStatus,
+  type RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class CommercetoolsOrderSearchFactory<
+  TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema,
+> implements OrderSearchFactory<TOrderSearchResultSchema>
+{
+  public readonly orderSearchResultSchema: TOrderSearchResultSchema;
+
+  constructor(orderSearchResultSchema: TOrderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+
+  public parseOrderSearchResult(
+    context: RequestContext,
+    data: OrderPagedQueryResponse,
+    query: OrderSearchQueryByTerm,
+  ): z.output<TOrderSearchResultSchema> {
+    const result = {
+      identifier: {
+        ...query.search,
+      },
+      pageNumber: (Math.ceil(data.offset / data.limit) || 0) + 1,
+      pageSize: data.limit,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total || 0) / data.limit || 0) + 1,
+      items: data.results.map((order) => this.parseOrderSearchItem(context, order)),
+    } satisfies OrderSearchResult;
+
+    return this.orderSearchResultSchema.parse(result);
+  }
+
+  protected parseAddress(data: CTAddress): Address {
+    return {
+      countryCode: data.country || '',
+      firstName: data.firstName || '',
+      lastName: data.lastName || '',
+      streetAddress: data.streetName || '',
+      streetNumber: data.streetNumber || '',
+      postalCode: data.postalCode || '',
+      city: data.city || '',
+      identifier: {
+        nickName: '',
+      },
+      region: '',
+    } satisfies Address;
+  }
+
+  protected parseOrderSearchItem(
+    context: RequestContext,
+    data: CTOrder,
+  ): OrderSearchResultItem {
+    const userId: IdentityIdentifier = {
+      userId: data.customerId || data.anonymousId || '',
+    };
+
+    let orderStatus: OrderStatus = 'AwaitingPayment';
+    if (data.paymentState === 'Paid' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (data.shipmentState === 'Ready' && data.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (
+      (data.shipmentState === 'Shipped' || data.shipmentState === 'Delivered') &&
+      data.orderState === 'Completed'
+    ) {
+      orderStatus = 'Shipped';
+    }
+
+    const totalAmount: MonetaryAmount = {
+      currency: data.totalPrice
+        ? (data.totalPrice.currencyCode as Currency)
+        : context.languageContext.currencyCode,
+      value: data.totalPrice ? data.totalPrice.centAmount / 100 : 0,
+    };
+
+    return {
+      identifier: { key: data.id },
+      userId,
+      customerName: `${data.billingAddress?.firstName} ${data.billingAddress?.lastName}`,
+      shippingAddress: this.parseAddress(data.shippingAddress!),
+      orderDate: data.createdAt,
+      orderStatus,
+      inventoryStatus: orderStatus === 'Shipped' ? 'Allocated' : 'NotAllocated',
+      totalAmount,
+    } satisfies OrderSearchResultItem;
+  }
+}