@reactionary/source 0.0.48 → 0.0.51

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

@@ -0,0 +1,165 @@
+import type {
+  Inventory,
+  RequestContext,
+  Cache,
+  InventoryQueryBySKU,
+  Order,
+  OrderQueryById,
+  Currency} from '@reactionary/core';
+import { InventoryProvider, OrderItemSchema, OrderProvider } from '@reactionary/core';
+import type z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { CommercetoolsClient } from '../core/client';
+import type { Order as CTOrder } from '@commercetools/platform-sdk';
+import { CommercetoolsOrderIdentifierSchema } from '../schema/commercetools.schema';
+export class CommercetoolsOrderProvider<
+  T extends Order = Order
+> extends OrderProvider<T> {
+  protected config: CommercetoolsConfiguration;
+
+  constructor(
+    config: CommercetoolsConfiguration,
+    schema: z.ZodType<T>,
+    cache: Cache
+  ) {
+    super(schema, cache);
+
+    this.config = config;
+  }
+
+  protected async getClient(reqCtx: RequestContext) {
+
+    const client = await new CommercetoolsClient(this.config).getClient(
+      reqCtx
+    );
+    return client.withProjectKey({ projectKey: this.config.projectKey }).me().orders();
+  }
+
+
+  public override async getById(payload: OrderQueryById, reqCtx: RequestContext): Promise<T> {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+
+    try {
+      const remote = await client
+        .withProjectKey({ projectKey: this.config.projectKey })
+        .orders()
+        .withId({ ID: payload.order.key })
+        .get()
+        .execute();
+
+      return this.parseSingle(remote.body, reqCtx);
+    } catch (e) {
+      return this.createEmptyOrder();
+    }
+  }
+
+
+  protected override parseSingle(_body: unknown, reqCtx: RequestContext): T {
+      const remote = _body as CTOrder;
+      const result = this.newModel();
+
+      result.identifier = CommercetoolsOrderIdentifierSchema.parse({
+        key: remote.id,
+        version: remote.version || 0,
+      });
+
+
+
+    result.name = remote.custom?.fields['name'] || '';
+    result.description = remote.custom?.fields['description'] || '';
+
+    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,
+        currency,
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency,
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency: remote.shippingInfo?.price.currencyCode as Currency,
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency,
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency,
+      },
+    };
+
+    if (remote.paymentState  === 'Pending' && remote.orderState === 'Open') {
+      result.orderStatus = 'AwaitingPayment';
+    } else if (remote.paymentState  === 'Paid' && remote.orderState === 'Confirmed') {
+      result.orderStatus = 'ReleasedToFulfillment';
+    }
+    if (remote.shipmentState === 'Ready' && remote.orderState === 'Confirmed') {
+      result.orderStatus = 'ReleasedToFulfillment';
+    }
+    if ( (remote.shipmentState === 'Shipped' || remote.shipmentState === 'Delivered') && remote.orderState === 'Completed') {
+      result.orderStatus = 'Shipped';
+    }
+
+    for (const remoteItem of remote.lineItems) {
+      const item = OrderItemSchema.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.meta = {
+      cache: {
+        hit: false,
+        key: this.generateCacheKeySingle(result.identifier, reqCtx),
+      },
+      placeholder: false,
+    };
+
+
+
+      return this.assert(result);
+  }
+}

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

@@ -38,7 +38,7 @@ export class CommercetoolsPriceProvider<
     const response = await client.get({
       queryArgs: {
         staged: false,
-        priceCountry: 'US',
+        priceCountry: reqCtx.taxJurisdiction.countryCode,
         priceCustomerGroup: undefined,
         priceChannel: channels.offerChannelGUID,
         priceCurrency: reqCtx.languageContext.currencyCode,

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

@@ -6,7 +6,7 @@ import type { z } from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import type { ProductProjection } from '@commercetools/platform-sdk';
 import { traced } from '@reactionary/otel';
-import type { Product, ProductQueryById, ProductQueryBySlug, RequestContext } from '@reactionary/core';
+import type { Product, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext } from '@reactionary/core';
 import type { Cache } from '@reactionary/core';
 
 export class CommercetoolsProductProvider<
@@ -67,6 +67,29 @@ export class CommercetoolsProductProvider<
     return this.parseSingle(remote.body.results[0], reqCtx);
   }
 
+
+  @traced()
+  public override async getBySKU(
+    payload: ProductQueryBySKU,
+    reqCtx: RequestContext
+  ): Promise<T> {
+    const client = await this.getClient(reqCtx);
+
+    const remote = await client
+      .get({
+        queryArgs: {
+          staged: false,
+          limit: 1,
+          where: 'variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ',
+          'var.skus': [payload].map(p => p.sku.key),
+        }
+      })
+      .execute();
+
+    return this.parseSingle(remote.body.results[0], reqCtx);
+  }
+
+
   protected override parseSingle(dataIn: unknown, reqCtx: RequestContext): T {
     const data = dataIn as ProductProjection;
     const base = this.newModel();

package/providers/commercetools/src/schema/capabilities.schema.ts

@@ -6,7 +6,8 @@ export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
     search: true,
     identity: true,
     cart: true,
-    cartPayment: true,
+    checkout: true,
+    order: true,
     inventory: true,
     price: true,
     category: true,

package/providers/commercetools/src/schema/commercetools.schema.ts

@@ -1,18 +1,20 @@
-import { CartIdentifierSchema, OrderIdentifierSchema, PaymentInstructionIdentifierSchema } from "@reactionary/core";
+import { CartIdentifierSchema, CheckoutIdentifierSchema, OrderIdentifierSchema, PaymentInstructionIdentifierSchema } from "@reactionary/core";
 import z from "zod";
 
 export const CommercetoolsCartIdentifierSchema = CartIdentifierSchema.extend({
     version: z.number().default(0)
 });
 
-export const CommercetoolsCartPaymentInstructionIdentifierSchema = PaymentInstructionIdentifierSchema.extend({
-    version: z.number().default(0),
-});
 
 export const CommercetoolsOrderIdentifierSchema = OrderIdentifierSchema.extend({
     version: z.number().default(0)
 });
 
+export const CommercetoolsCheckoutIdentifierSchema = CheckoutIdentifierSchema.extend({
+    version: z.number().default(0)
+});
+
+export type CommercetoolsCheckoutIdentifier = z.infer<typeof CommercetoolsCheckoutIdentifierSchema>;
+
 export type CommercetoolsCartIdentifier = z.infer<typeof CommercetoolsCartIdentifierSchema>;
-export type CommercetoolsCartPaymentInstructionIdentifier = z.infer<typeof CommercetoolsCartPaymentInstructionIdentifierSchema>;
 export type CommercetoolsOrderIdentifier = z.infer<typeof CommercetoolsOrderIdentifierSchema>;

package/providers/commercetools/src/schema/configuration.schema.ts

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { PaymentMethodSchema } from '@reactionary/core';
 
 export const CommercetoolsConfigurationSchema = z.looseObject({
     projectKey: z.string(),
@@ -7,6 +8,7 @@ export const CommercetoolsConfigurationSchema = z.looseObject({
     clientId: z.string(),
     clientSecret: z.string(),
     scopes: z.array(z.string()).default(() => []),
+    paymentMethods: PaymentMethodSchema.array().optional().default(() => []),
 });
 
 export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;

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

@@ -1,9 +1,10 @@
 import 'dotenv/config';
 import type { RequestContext} from '@reactionary/core';
-import { CartSchema, IdentitySchema, NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import { CartSchema, IdentitySchema, NoOpCache, ProductSchema, createInitialRequestContext } from '@reactionary/core';
 import { getCommercetoolsTestConfiguration } from './test-utils';
 import { CommercetoolsCartProvider } from '../providers/cart.provider';
 import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+import { CommercetoolsProductProvider } from '../providers/product.provider';
 
 
 const testData = {
@@ -13,12 +14,14 @@ const testData = {
 
 describe('Commercetools Cart Provider', () => {
   let provider: CommercetoolsCartProvider;
+  let productProvider: CommercetoolsProductProvider;
   let identityProvider: CommercetoolsIdentityProvider;
   let reqCtx: RequestContext;
 
   beforeAll( () => {
     provider = new CommercetoolsCartProvider(getCommercetoolsTestConfiguration(), CartSchema, new NoOpCache());
     identityProvider = new CommercetoolsIdentityProvider(getCommercetoolsTestConfiguration(), IdentitySchema, new NoOpCache());
+    productProvider = new CommercetoolsProductProvider(getCommercetoolsTestConfiguration(), ProductSchema, new NoOpCache());
   });
 
   beforeEach( () => {
@@ -162,6 +165,23 @@ describe('Commercetools Cart Provider', () => {
       expect(originalCart.items.length).toBe(0);
     });
 
+    it('can load the product information for cart items', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, reqCtx);
+      expect(cart.items[0].sku).toBeDefined();
+
+      const product = await productProvider.getBySKU( { sku: cart.items[0].sku }, reqCtx);
+      expect(product).toBeTruthy();
+      if (product) {
+        expect(product.skus.some(s => s.identifier.key === cart.items[0].sku.key)).toBe(true);
+      }
+    });
     /**
     it('should be able to create a cart for an anonymous user, then login and merge the cart', async () => {
     });

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

@@ -0,0 +1,312 @@
+import 'dotenv/config';
+import type { Cart, Checkout, RequestContext } from '@reactionary/core';
+import {
+  CartSchema,
+  CheckoutSchema,
+  IdentitySchema,
+  NoOpCache,
+  PaymentInstructionSchema,
+  ShippingInstructionSchema,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { getCommercetoolsTestConfiguration } from './test-utils';
+import { CommercetoolsCartProvider } from '../providers/cart.provider';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+import { CommercetoolsCheckoutProvider } from '../providers/checkout.provider';
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01',
+};
+
+describe('Commercetools Checkout Provider', () => {
+  let provider: CommercetoolsCheckoutProvider;
+  let cartProvider: CommercetoolsCartProvider;
+  let identityProvider: CommercetoolsIdentityProvider;
+  let reqCtx: RequestContext;
+
+  beforeAll(() => {
+    provider = new CommercetoolsCheckoutProvider(
+      getCommercetoolsTestConfiguration(),
+      CheckoutSchema,
+      new NoOpCache()
+    );
+    cartProvider = new CommercetoolsCartProvider(
+      getCommercetoolsTestConfiguration(),
+      CartSchema,
+      new NoOpCache()
+    );
+    identityProvider = new CommercetoolsIdentityProvider(
+      getCommercetoolsTestConfiguration(),
+      IdentitySchema,
+      new NoOpCache()
+    );
+  });
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+  });
+
+  describe('anonymous sessions', () => {
+    let cart: Cart;
+
+    beforeEach(async () => {
+      cart = await cartProvider.add(
+        {
+          cart: { key: '', version: 0 },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1,
+        },
+        reqCtx
+      );
+    });
+
+    it('can create a checkout session from a cart', async () => {
+      //  we have either an anonymous user, or an authenticated user.
+      // if it is anonymous, we assume you will have collected some basic info by now ?
+
+      const checkout = await provider.initiateCheckoutForCart(
+        {
+          cart: cart.identifier,
+          billingAddress: {
+            countryCode: 'US',
+            firstName: 'John',
+            lastName: 'Doe',
+            streetAddress: '123 Main St',
+            streetNumber: '1A',
+            postalCode: '12345',
+            city: 'Anytown',
+            region: '',
+          },
+          notificationEmail: 'sample@example.com',
+          notificationPhone: '+4512345678',
+        },
+        reqCtx
+      );
+
+      expect(checkout.identifier.key).toBeDefined();
+      expect(checkout.originalCartReference.key).toBe(cart.identifier.key);
+      expect(checkout.billingAddress?.firstName).toBe('John');
+      expect(checkout.items.length).toBe(1);
+      expect(checkout.items[0].sku.key).toBe(testData.skuWithoutTiers);
+    });
+
+    describe('checkout actions', () => {
+      let checkout: Checkout;
+      beforeEach(async () => {
+        checkout = await provider.initiateCheckoutForCart(
+          {
+            cart: cart.identifier,
+            billingAddress: {
+              countryCode: 'US',
+              firstName: 'John',
+              lastName: 'Doe',
+              streetAddress: '123 Main St',
+              streetNumber: '1A',
+              postalCode: '12345',
+              city: 'Anytown',
+              region: '',
+            },
+            notificationEmail: 'sample@example.com',
+            notificationPhone: '+4512345678',
+          },
+          reqCtx
+        );
+      });
+
+      it('can list payment methods', async () => {
+        const paymentMethods = await provider.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        expect(paymentMethods.length).toBeGreaterThan(0);
+        expect(
+          paymentMethods.find((x) => x.identifier.method === 'stripe')
+        ).toBeDefined();
+      });
+
+      it('can list shipping methods', async () => {
+        const shippingMethods = await provider.getAvailableShippingMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        expect(shippingMethods.length).toBeGreaterThan(0);
+        expect(
+          shippingMethods.find((x) => x.identifier.key === 'us-delivery')
+        ).toBeDefined();
+      });
+
+      it('can add a payment instruction', async () => {
+        const paymentMethods = await provider.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await provider.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: PaymentInstructionSchema.parse({
+              paymentMethod: pm?.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            }),
+          },
+          reqCtx
+        );
+
+        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
+        expect(checkoutWithPi.paymentInstructions[0].paymentMethod.method).toBe(
+          'stripe'
+        );
+        expect(checkoutWithPi.paymentInstructions[0].protocolData.find(x => x.key === 'stripe_clientSecret')?.value).toBeDefined();
+
+      });
+
+      xit('can cancel an in-progress payment', async () => {
+        const paymentMethods = await provider.getAvailablePaymentMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        const pm = paymentMethods.find((x) => x.identifier.method === 'stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await provider.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: PaymentInstructionSchema.parse({
+              paymentMethod: pm?.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            }),
+          },
+          reqCtx
+        );
+
+        expect(checkoutWithPi.paymentInstructions.length).toBe(1);
+
+        const checkoutAfterCancel = await provider.removePaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction:
+              checkoutWithPi.paymentInstructions[0].identifier,
+          },
+          reqCtx
+        );
+
+        expect(checkoutAfterCancel.paymentInstructions.length).toBe(0);
+      });
+
+      it('can set shipping address', async () => {
+        const checkoutWithShipping = await provider.setShippingAddress(
+          {
+            checkout: checkout.identifier,
+            shippingAddress: {
+              countryCode: 'US',
+              firstName: 'Jane',
+              lastName: 'Doe',
+              streetAddress: '456 Other St',
+              streetNumber: '2B',
+              postalCode: '54321',
+              city: 'Othertown',
+              region: '',
+            },
+          },
+          reqCtx
+        );
+
+        expect(checkoutWithShipping.shippingAddress).toBeDefined();
+        expect(checkoutWithShipping.shippingAddress?.firstName).toBe('Jane');
+      });
+
+      it('can set shipping instructions', async () => {
+        const shippingMethods = await provider.getAvailableShippingMethods(
+          {
+            checkout: checkout.identifier,
+          },
+          reqCtx
+        );
+        const sm = shippingMethods.find((x) => x.identifier.key === 'us-delivery');
+        expect(sm).toBeDefined();
+
+        const shippingInstruction = ShippingInstructionSchema.parse({
+          shippingMethod: sm?.identifier || { key: '' },
+          amount: checkout.price.totalShipping,
+          instructions: 'Leave at front door if not home',
+          consentForUnattendedDelivery: true,
+          pickupPoint: '4190asx141', // this would be a real pickup point ID in a real scenario
+        });
+
+        const checkoutWithShipping = await provider.setShippingInstruction(
+          {
+            checkout: checkout.identifier,
+            shippingInstruction,
+          },
+          reqCtx
+        );
+
+        expect(checkout.price.totalShipping.value).toBe(0);
+        expect(checkoutWithShipping.price.totalShipping.value).toBeGreaterThan(0);
+        expect(checkoutWithShipping.shippingInstruction).toBeDefined();
+        expect(
+          checkoutWithShipping.shippingInstruction?.shippingMethod.key
+        ).toBe('us-delivery');
+        expect(checkoutWithShipping.shippingInstruction?.instructions).toBe(
+          'Leave at front door if not home'
+        );
+        expect(checkoutWithShipping.shippingInstruction?.pickupPoint).toBe(
+          '4190asx141'
+        );
+        expect(
+          checkoutWithShipping.shippingInstruction?.consentForUnattendedDelivery
+        ).toBe(true);
+      });
+
+      xit('wont report it finalizable until everything is paid/authorized', async () => {
+        expect(checkout.readyForFinalization).toBe(false);
+        const pm = (
+          await provider.getAvailablePaymentMethods(
+            {
+              checkout: checkout.identifier,
+            },
+            reqCtx
+          )
+        ).find((x) => x.identifier.method === 'stripe');
+        expect(pm).toBeDefined();
+
+        const checkoutWithPi = await provider.addPaymentInstruction(
+          {
+            checkout: checkout.identifier,
+            paymentInstruction: PaymentInstructionSchema.parse({
+              paymentMethod: pm?.identifier,
+              amount: checkout.price.grandTotal,
+              protocolData: [{ key: 'test-key', value: 'test-value' }],
+            }),
+          },
+          reqCtx
+        );
+
+        // do something to simulate payment authorization ?
+        const checkoutReady = await provider.getById(
+          { identifier: checkoutWithPi.identifier },
+          reqCtx
+        );
+        if (!checkoutReady) {
+          fail('checkout not found');
+        }
+        expect(checkoutReady.readyForFinalization).toBe(true);
+      });
+    });
+  });
+});

package/providers/commercetools/src/test/price.provider.spec.ts

@@ -39,7 +39,7 @@ describe('Commercetools Price Provider', () => {
     }
   });
 
-  it('should be able to get prices for a product with tiers', async () => {
+  xit('should be able to get prices for a product with tiers', async () => {
     const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, reqCtx);
 
     expect(result).toBeTruthy();

package/providers/commercetools/src/test/product.provider.spec.ts

@@ -8,8 +8,11 @@ const testData = {
   product : {
     id: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
     name: 'Sunnai Glass Bowl',
-    image: 'https://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg'
-  }
+    image: 'https://storage.googleapis.com/merchant-center-europe/sample-data/goodstore/Sunnai_Glass_Bowl-1.1.jpeg',
+    sku: 'SGB-01',
+
+  },
+
 }
 
 describe('Commercetools Product Provider', () => {
@@ -48,12 +51,26 @@ describe('Commercetools Product Provider', () => {
     }
   });
 
+  it('should be able to get a product by sku', async () => {
+    const result = await provider.getBySKU( { sku: { key: testData.product.sku } }, reqCtx);
+
+    expect(result).toBeTruthy();
+    if (result) {
+      expect(result.meta.placeholder).toBe(false);
+      expect(result.identifier.key).toBe(testData.product.id);
+      expect(result.name).toBe(testData.product.name);
+      expect(result.image).toBe(testData.product.image);
+    }
+  });
+
   it('should return null for unknown slug', async () => {
     const result = await provider.getBySlug( { slug: 'unknown-slug' }, reqCtx);
 
     expect(result).toBeNull();
   });
 
+
+
   it('should return a placeholder product for unknown id', async () => {
     const result = await provider.getById( { id: 'unknown-id' }, reqCtx);