@reactionary/source 0.0.40 → 0.0.42

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

@@ -40,7 +40,7 @@ export class CommercetoolsIdentityProvider<
 
         if (current.success) {
           current.data.meta = {
-            cache: { hit: false, key: session.identity.id || 'anonymous' },
+            cache: { hit: false, key: session.identity.id.userId || 'anonymous' },
             placeholder: false
           };
           return current.data;
@@ -66,16 +66,24 @@ export class CommercetoolsIdentityProvider<
     const base = this.newModel();
 
     if (remote && remote.access_token) {
+      base.id = { userId: this.extractCustomerIdFromScopes(remote.scope) };
+
+      base.keyring = base.keyring.filter(x => x.service !== 'commercetools');
+      base.keyring.push({
+        service: 'commercetools',
+        token: remote.access_token,
+        issued: new Date(),
+        expiry: new Date(new Date().getTime() + 3600 * 1000),
+      });
       base.issued = new Date();
       base.expiry = new Date();
       base.expiry.setSeconds(base.expiry.getSeconds() + remote.expires_in);
-      base.id = this.extractCustomerIdFromScopes(remote.scope);
       base.token = remote.access_token;
       base.type = 'Registered';
     }
 
     base.meta = {
-      cache: { hit: false, key: base.id || 'anonymous' },
+      cache: { hit: false, key: base.id.userId || 'anonymous' },
       placeholder: false
     };
 
@@ -111,4 +119,4 @@ export class CommercetoolsIdentityProvider<
 
     return id || '';
   }
-}
+}

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

@@ -25,6 +25,16 @@ export class CommercetoolsInventoryProvider<
     this.config = config;
   }
 
+  protected getClient(session: Session) {
+    const token = session.identity.keyring.find(x => x.service === 'commercetools')?.token;
+    const client = new CommercetoolsClient(this.config).getClient(
+      token
+    );
+    return client.withProjectKey({ projectKey: this.config.projectKey }).inventory();
+  }
+
+
+
   public override async getBySKU(
     payload: InventoryQuery,
     session: Session

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

@@ -1,4 +1,5 @@
-import { Price, PriceProvider, PriceQueryBySku, Session, Cache, Currency, TieredPriceSchema, MonetaryAmountSchema, TieredPrice } from '@reactionary/core';
+import { Price, PriceProvider, Cache, Currency, TieredPriceSchema, TieredPrice } from '@reactionary/core';
+import type { PriceQueryBySku, Session } from '@reactionary/core';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
@@ -14,11 +15,17 @@ export class CommercetoolsPriceProvider<
     this.config = config;
   }
 
-  public getClient(session: Session) {
-    return new CommercetoolsClient(this.config).getClient(session.identity?.token).withProjectKey({ projectKey: this.config.projectKey }).standalonePrices();
+
+  protected getClient(session: Session) {
+    const token = session.identity.keyring.find(x => x.service === 'commercetools')?.token;
+    const client = new CommercetoolsClient(this.config).getClient(
+      token
+    );
+    return client.withProjectKey({ projectKey: this.config.projectKey }).standalonePrices();
   }
 
 
+
   public override async getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]> {
 
     const client = this.getClient(session);
@@ -40,7 +47,7 @@ export class CommercetoolsPriceProvider<
       if (matched && matched.length > 0) {
         result.push(this.parseSingle(matched[0], session));
       } else {
-        result.push(this.getEmptyPriceResult(p.sku.key, session.languageContext.currencyCode ));
+        result.push(this.createEmptyPriceResult(p.sku.key, session.languageContext.currencyCode ));
       }
     }
 
@@ -70,7 +77,7 @@ export class CommercetoolsPriceProvider<
       if (matched && matched.length > 0) {
         return this.parseSingle(matched[0], session);
       }
-      return this.getEmptyPriceResult(payload.sku.key, session.languageContext.currencyCode );
+      return this.createEmptyPriceResult(payload.sku.key, session.languageContext.currencyCode );
   }
 
 

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

@@ -1,15 +1,14 @@
 import {
   ProductProvider,
   Product,
-  ProductQueryById,
-  ProductQueryBySlug,
-  Session,
   Cache,
 } from '@reactionary/core';
 import { CommercetoolsClient } from '../core/client';
 import { z } from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { ProductProjection } from '@commercetools/platform-sdk';
+import { traced } from '@reactionary/otel';
+import type { ProductQueryById, ProductQueryBySlug, Session } from '@reactionary/core';
 
 export class CommercetoolsProductProvider<
   T extends Product = Product
@@ -22,28 +21,38 @@ export class CommercetoolsProductProvider<
     this.config = config;
   }
 
-  public getClient(session: Session) {
-    return new CommercetoolsClient(this.config).getClient(session.identity?.token).withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+  protected getClient(session: Session) {
+    const token = session.identity.keyring.find(x => x.service === 'commercetools')?.token;
+    const client = new CommercetoolsClient(this.config).getClient(
+      token
+    );
+    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
   }
 
+  @traced()
   public override async getById(
     payload: ProductQueryById,
     session: Session
   ): Promise<T> {
     const client = this.getClient(session);
 
-    const remote = await client
-      .withId({ ID: payload.id })
-      .get()
-      .execute();
+    try {
+      const remote = await client
+        .withId({ ID: payload.id })
+        .get()
+        .execute();
 
-    return this.parseSingle(remote.body, session);
+      return this.parseSingle(remote.body, session);
+    } catch(error) {
+      return this.createEmptyProduct(payload.id);
+    }
   }
 
+  @traced()
   public override async getBySlug(
     payload: ProductQueryBySlug,
     session: Session
-  ): Promise<T> {
+  ): Promise<T | null> {
     const client = this.getClient(session);
 
     const remote = await client
@@ -55,10 +64,9 @@ export class CommercetoolsProductProvider<
       })
       .execute();
 
-    if (remote.body.results.length === 0) {
-      throw new Error(`Product with slug '${payload.slug}' not found`);
+    if (remote.body.count === 0) {
+      return null;
     }
-
     return this.parseSingle(remote.body.results[0], session);
   }
 
@@ -66,6 +74,7 @@ export class CommercetoolsProductProvider<
     const data = dataIn as ProductProjection;
     const base = this.newModel();
 
+
     base.identifier = { key: data.id };
     base.name = data.name[session.languageContext.locale];
     base.slug = data.slug[session.languageContext.locale];

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

@@ -1,35 +1,49 @@
-import {
-  SearchProvider,
-  SearchQueryByTerm,
+import { SearchProvider } from '@reactionary/core';
+import type {
   SearchResult,
   SearchResultProduct,
-  Session,
   Cache,
+  SearchQueryByTerm,
+  Session,
 } from '@reactionary/core';
+
 import { CommercetoolsClient } from '../core/client';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { traced } from '@reactionary/otel';
 
 export class CommercetoolsSearchProvider<
   T extends SearchResult = SearchResult
 > extends SearchProvider<T> {
   protected config: CommercetoolsConfiguration;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
+  constructor(
+    config: CommercetoolsConfiguration,
+    schema: z.ZodType<T>,
+    cache: Cache
+  ) {
     super(schema, cache);
 
     this.config = config;
   }
 
+  @traced()
+  protected getClient(session: Session) {
+    const token = session.identity.keyring.find(x => x.service === 'commercetools')?.token;
+    const client = new CommercetoolsClient(this.config).getClient(
+      token
+    );
+    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+  }
+
+
   public override async queryByTerm(
     payload: SearchQueryByTerm,
     session: Session
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+    const client = this.getClient(session);
 
     const remote = await client
-      .withProjectKey({ projectKey: this.config.projectKey })
-      .productProjections()
       .search()
       .get({
         queryArgs: {
@@ -43,9 +57,23 @@ export class CommercetoolsSearchProvider<
     return this.parseSearchResult(remote, payload, session);
   }
 
-  protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm, session: Session): T {
+  protected parseSearchResult(
+    remote: unknown,
+    payload: SearchQueryByTerm,
+    session: Session
+  ): T {
     const result = this.newModel();
-    const remoteData = remote as { body: { results: Array<{ id: string; name: Record<string, string>; slug?: Record<string, string>; masterVariant: { images?: Array<{ url?: string }> } }>; total?: number } };
+    const remoteData = remote as {
+      body: {
+        results: Array<{
+          id: string;
+          name: Record<string, string>;
+          slug?: Record<string, string>;
+          masterVariant: { images?: Array<{ url?: string }> };
+        }>;
+        total?: number;
+      };
+    };
 
     result.identifier = payload.search;
 
@@ -54,20 +82,20 @@ export class CommercetoolsSearchProvider<
         identifier: { key: p.id },
         name: p.name[session.languageContext.locale] || p.id,
         slug: p.slug?.[session.languageContext.locale] || p.id,
-        image: p.masterVariant.images?.[0]?.url || 'https://placehold.co/400'
+        image: p.masterVariant.images?.[0]?.url || 'https://placehold.co/400',
       };
 
       result.products.push(product);
     }
 
-    result.pages = Math.ceil((remoteData.body.total || 0) / payload.search.pageSize);
+    result.pages = Math.ceil(
+      (remoteData.body.total || 0) / payload.search.pageSize
+    );
     result.meta = {
       cache: { hit: false, key: payload.search.term },
-      placeholder: false
+      placeholder: false,
     };
 
     return this.assert(result);
   }
-
-
 }

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

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

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

@@ -0,0 +1,18 @@
+import { CartIdentifierSchema, 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 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

@@ -5,7 +5,8 @@ export const CommercetoolsConfigurationSchema = z.looseObject({
     authUrl: z.string(),
     apiUrl: z.string(),
     clientId: z.string(),
-    clientSecret: z.string()
+    clientSecret: z.string(),
+    scopes: z.array(z.string()).default(() => []),
 });
 
 export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;

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

@@ -0,0 +1,149 @@
+import 'dotenv/config';
+import {
+  Cart,
+  CartMutationAddPaymentMethodSchema,
+  CartPaymentInstructionSchema,
+  CartSchema,
+  IdentitySchema,
+  NoOpCache,
+  Session,
+} from '@reactionary/core';
+import {
+  createAnonymousTestSession,
+  getCommercetoolsTestConfiguration,
+} from './test-utils';
+import { CommercetoolsCartProvider } from '../providers/cart.provider';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+import { CommercetoolsCartPaymentProvider } from '../providers/cart-payment.provider';
+import { CartPaymentMutationAddPayment } from 'core/src/schemas/mutations/cart-payment.mutation';
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01',
+};
+
+describe('Commercetools Cart Payment Provider', () => {
+  let provider: CommercetoolsCartPaymentProvider;
+  let cartProvider: CommercetoolsCartProvider;
+  let identityProvider: CommercetoolsIdentityProvider;
+  let session: Session;
+
+  beforeAll(() => {
+    provider = new CommercetoolsCartPaymentProvider(
+      getCommercetoolsTestConfiguration(),
+      CartPaymentInstructionSchema,
+      new NoOpCache()
+    );
+    cartProvider = new CommercetoolsCartProvider(
+      getCommercetoolsTestConfiguration(),
+      CartSchema,
+      new NoOpCache()
+    );
+    identityProvider = new CommercetoolsIdentityProvider(
+      getCommercetoolsTestConfiguration(),
+      IdentitySchema,
+      new NoOpCache()
+    );
+  });
+
+  beforeEach(() => {
+    session = createAnonymousTestSession();
+  });
+
+  describe('anonymous sessions', () => {
+    let cart: Cart;
+
+    beforeEach(async () => {
+      cart = await cartProvider.add(
+        {
+          cart: { key: '', version: 0 },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1,
+        },
+        session
+      );
+    });
+
+    it('a new cart will return 0 payment instructions', async () => {
+      const payments = await provider.getByCartIdentifier(
+        { cart: cart.identifier, status: undefined },
+        session
+      );
+      expect(payments.length).toBe(0);
+    });
+
+    it('can initiate a new payment', async () => {
+      const payment = await provider.initiatePaymentForCart(
+        {
+          cart: cart.identifier,
+          paymentInstruction: {
+            paymentMethod: {
+              method: 'stripe',
+              name: 'Stripe',
+              paymentProcessor: 'stripe',
+            },
+            amount: {
+              value: cart.price.grandTotal.value,
+              currency: cart.price.grandTotal.currency,
+            },
+            protocolData: [{ key: 'test-key', value: 'test-value' }],
+          },
+        },
+        session
+      );
+
+      expect(payment.identifier.key).toBeDefined();
+
+      // verify that we can fetch it again.
+      const payments = await provider.getByCartIdentifier(
+        { cart: cart.identifier, status: undefined },
+        session
+      );
+      expect(payments.length).toBe(1);
+      expect(payments[0].identifier.key).toBe(payment.identifier.key);
+    });
+
+
+    it('can cancel an in-progress payment', async () => {
+      const payment = await provider.initiatePaymentForCart(
+        {
+          cart: cart.identifier,
+          paymentInstruction: {
+            paymentMethod: {
+              method: 'stripe',
+              name: 'Stripe',
+              paymentProcessor: 'stripe',
+            },
+            amount: {
+              value: cart.price.grandTotal.value,
+              currency: cart.price.grandTotal.currency,
+            },
+            protocolData: [{ key: 'test-key', value: 'test-value' }],
+          },
+        },
+        session
+      );
+      expect(payment.identifier.key).toBeDefined();
+
+      const cancelledPayment = await provider.cancelPaymentInstruction(
+        {
+          cart: cart.identifier,
+          paymentInstruction: payment.identifier
+        },
+        session
+      );
+      expect(cancelledPayment.status).toBe('canceled');
+
+
+      // verify that it is gone
+      const payments = await provider.getByCartIdentifier(
+        { cart: cart.identifier, status: undefined },
+        session
+      );
+      expect(payments.length).toBe(0);
+      expect(payments[0].identifier.key).toBe(payment.identifier.key);
+   });
+  });
+});

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

@@ -3,6 +3,13 @@ import { CartSchema, CategorySchema, IdentitySchema, NoOpCache, ProductSchema, S
 import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
 import { CommercetoolsCartProvider } from '../providers/cart.provider';
 import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01'
+}
+
 describe('Commercetools Cart Provider', () => {
   let provider: CommercetoolsCartProvider;
   let identityProvider: CommercetoolsIdentityProvider;
@@ -32,15 +39,15 @@ describe('Commercetools Cart Provider', () => {
     it('should be able to add an item to a cart', async () => {
       const cart = await provider.add({
           cart: { key: '' },
-          product: {
-            key: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+          sku: {
+            key: testData.skuWithoutTiers,
           },
           quantity: 1
       }, session);
 
       expect(cart.identifier.key).toBeDefined();
       expect(cart.items.length).toBe(1);
-      expect(cart.items[0].product.key).toBe('4d28f98d-c446-446e-b59a-d9f718e5b98a');
+      expect(cart.items[0].sku.key).toBe(testData.skuWithoutTiers);
       expect(cart.items[0].quantity).toBe(1);
 
       expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
@@ -56,13 +63,38 @@ describe('Commercetools Cart Provider', () => {
 
     });
 
+    it('can add multiple different items to a cart', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, session);
+
+
+      const updatedCart = await provider.add({
+          cart: cart.identifier,
+          sku: {
+            key: testData.skuWithTiers,
+          },
+          quantity: 2
+      }, session);
+
+      expect(updatedCart.items.length).toBe(2);
+      expect(updatedCart.items[0].sku.key).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.items[0].quantity).toBe(1);
+      expect(updatedCart.items[1].sku.key).toBe(testData.skuWithTiers);
+      expect(updatedCart.items[1].quantity).toBe(2);
+    });
 
     it('should be able to change quantity of an item in a cart', async () => {
 
       const cart = await provider.add({
           cart: { key: '' },
-          product: {
-            key: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+          sku: {
+            key: testData.skuWithoutTiers,
           },
           quantity: 1
       }, session);
@@ -73,9 +105,9 @@ describe('Commercetools Cart Provider', () => {
         quantity: 3
       }, session);
 
-      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
+
       expect(updatedCart.items.length).toBe(1);
-      expect(updatedCart.items[0].product.key).toBe('4d28f98d-c446-446e-b59a-d9f718e5b98a');
+      expect(updatedCart.items[0].sku.key).toBe(testData.skuWithoutTiers);
       expect(updatedCart.items[0].quantity).toBe(3);
 
       expect(updatedCart.items[0].price.totalPrice.value).toBe(cart.items[0].price.totalPrice.value * 3);
@@ -88,8 +120,8 @@ describe('Commercetools Cart Provider', () => {
 
       const cart = await provider.add({
           cart: { key: '' },
-          product: {
-            key: '4d28f98d-c446-446e-b59a-d9f718e5b98a',
+          sku: {
+            key: testData.skuWithoutTiers,
           },
           quantity: 1
       }, session);
@@ -98,10 +130,37 @@ describe('Commercetools Cart Provider', () => {
         cart: cart.identifier,
         item: cart.items[0].identifier,
       }, session);
-      expect(updatedCart.identifier.key).toBe(cart.identifier.key);
+
       expect(updatedCart.items.length).toBe(0);
     });
 
+    it('should be able to delete a cart', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, session);
+
+      expect(cart.items.length).toBe(1);
+      expect(cart.identifier.key).toBeTruthy();
+
+      const deletedCart = await provider.deleteCart({
+        cart: cart.identifier,
+      }, session);
+
+      expect(deletedCart.items.length).toBe(0);
+      expect(deletedCart.identifier.key).toBe('');
+
+      const originalCart = await provider.getById({
+        cart: cart.identifier,
+      }, session);
+
+      expect(originalCart.items.length).toBe(0);
+    });
+
     /**
     it('should be able to create a cart for an anonymous user, then login and merge the cart', async () => {
     });

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

@@ -1,11 +1,7 @@
 import 'dotenv/config'
-
-    import { diag, DiagConsoleLogger, DiagLogLevel } from '@opentelemetry/api';
-
-import { CategorySchema, NoOpCache, ProductSchema, Session } from '@reactionary/core';
+import { CategorySchema, NoOpCache, Session } from '@reactionary/core';
 import { CommercetoolsCategoryProvider } from '../providers/category.provider';
 import { createAnonymousTestSession, getCommercetoolsTestConfiguration } from './test-utils';
-import { getTracer, shutdownOtel } from '@reactionary/otel';
 
 const testData = {
   topCategories: [
@@ -168,13 +164,4 @@ describe('Commercetools Category Provider', () => {
     expect(result.meta.placeholder).toBe(true);
 
   });
-
-  it('traces execution of getById', async () => {
-    const tracer = getTracer();
-    const span = tracer.startSpan('test-span');
-    const result = await provider.getById({ id: { key: 'home-decor'}}, session);
-    span.end();
-    await shutdownOtel();
-  });
-
 });

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

@@ -28,8 +28,35 @@ describe('Commercetools Product Provider', () => {
   it('should be able to get a product by id', async () => {
     const result = await provider.getById( { id: testData.product.id }, session);
 
+    expect(result).toBeTruthy();
     expect(result.identifier.key).toBe(testData.product.id);
+    expect(result.meta.placeholder).toBe(false);
     expect(result.name).toBe(testData.product.name);
     expect(result.image).toBe(testData.product.image);
   });
+
+  it('should be able to get a product by slug', async () => {
+    const result = await provider.getBySlug( { slug: 'sunnai-glass-bowl' }, session);
+
+    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' }, session);
+
+    expect(result).toBeNull();
+  });
+
+  it('should return a placeholder product for unknown id', async () => {
+    const result = await provider.getById( { id: 'unknown-id' }, session);
+
+    expect(result).toBeTruthy();
+    expect(result.meta.placeholder).toBe(true);
+  });
 });