@reactionary/source 0.0.41 → 0.0.48

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

@@ -1,15 +1,13 @@
 import {
-  ProductProvider,
-  Product,
-  ProductQueryById,
-  ProductQueryBySlug,
-  Session,
-  Cache,
+  ProductProvider
 } 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 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 { Cache } from '@reactionary/core';
 
 export class CommercetoolsProductProvider<
   T extends Product = Product
@@ -22,29 +20,37 @@ 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 async getClient(reqCtx: RequestContext) {
+
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
   }
 
+  @traced()
   public override async getById(
     payload: ProductQueryById,
-    session: Session
+    reqCtx: RequestContext
   ): Promise<T> {
-    const client = this.getClient(session);
+    const client = await this.getClient(reqCtx);
 
-    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, reqCtx);
+    } catch(error) {
+      return this.createEmptyProduct(payload.id);
+    }
   }
 
+  @traced()
   public override async getBySlug(
     payload: ProductQueryBySlug,
-    session: Session
-  ): Promise<T> {
-    const client = this.getClient(session);
+    reqCtx: RequestContext
+  ): Promise<T | null> {
+    const client = await this.getClient(reqCtx);
 
     const remote = await client
       .get({
@@ -55,23 +61,23 @@ 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);
+    return this.parseSingle(remote.body.results[0], reqCtx);
   }
 
-  protected override parseSingle(dataIn: unknown, session: Session): T {
+  protected override parseSingle(dataIn: unknown, reqCtx: RequestContext): T {
     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];
+    base.name = data.name[reqCtx.languageContext.locale];
+    base.slug = data.slug[reqCtx.languageContext.locale];
 
     if (data.description) {
-      base.description = data.description[session.languageContext.locale];
+      base.description = data.description[reqCtx.languageContext.locale];
     }
 
     if (data.masterVariant.images && data.masterVariant.images.length > 0) {
@@ -92,7 +98,7 @@ export class CommercetoolsProductProvider<
     }
 
     base.meta = {
-      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, session) },
+      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, reqCtx) },
       placeholder: false
     };
 

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

@@ -0,0 +1,61 @@
+import type {
+  Profile,
+  ProfileMutationUpdate,
+  ProfileQuerySelf,
+  RequestContext,
+} from '@reactionary/core';
+import { ProfileProvider } from '@reactionary/core';
+import type z from 'zod';
+import { CommercetoolsClient } from '../core/client';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import type { Cache } from '@reactionary/core';
+import type { Customer } from '@commercetools/platform-sdk';
+
+export class CommercetoolsProfileProvider<
+  T extends Profile = Profile
+> extends ProfileProvider<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 });
+  }
+
+  public override async getSelf(
+    payload: ProfileQuerySelf,
+    reqCtx: RequestContext
+  ): Promise<T> {
+    const client = await this.getClient(reqCtx);
+
+    const remote = await client.me().get().execute();
+    const model = this.parseSingle(remote.body, reqCtx);
+
+    return model;
+  }
+
+  public override async update(
+    payload: ProfileMutationUpdate,
+    reqCtx: RequestContext
+  ): Promise<T> {
+    throw new Error('Method not implemented.');
+  }
+
+  protected override parseSingle(body: Customer, reqCtx: RequestContext): T {
+    const model = this.newModel();
+
+    model.email = body.email;
+    model.emailVerified = body.isEmailVerified;
+
+    return model;
+  }
+}

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

@@ -4,12 +4,12 @@ import type {
   SearchResultProduct,
   Cache,
   SearchQueryByTerm,
-  Session,
+  Session, RequestContext,
 } from '@reactionary/core';
 
 import { CommercetoolsClient } from '../core/client';
-import z from 'zod';
-import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import type z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { traced } from '@reactionary/otel';
 
 export class CommercetoolsSearchProvider<
@@ -28,32 +28,36 @@ export class CommercetoolsSearchProvider<
   }
 
   @traced()
+  protected async getClient(reqCtx: RequestContext) {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+  }
+
+
   public override async queryByTerm(
     payload: SearchQueryByTerm,
-    session: Session
+    reqCtx: RequestContext
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+    const client = await this.getClient(reqCtx);
 
     const remote = await client
-      .withProjectKey({ projectKey: this.config.projectKey })
-      .productProjections()
       .search()
       .get({
         queryArgs: {
           limit: payload.search.pageSize,
           offset: (payload.search.page - 1) * payload.search.pageSize,
-          [`text.${session.languageContext.locale}`]: payload.search.term,
+          [`text.${reqCtx.languageContext.locale}`]: payload.search.term,
         },
       })
       .execute();
 
-    return this.parseSearchResult(remote, payload, session);
+    return this.parseSearchResult(remote, payload, reqCtx);
   }
 
   protected parseSearchResult(
     remote: unknown,
     payload: SearchQueryByTerm,
-    session: Session
+    reqCtx: RequestContext
   ): T {
     const result = this.newModel();
     const remoteData = remote as {
@@ -73,8 +77,8 @@ export class CommercetoolsSearchProvider<
     for (const p of remoteData.body.results) {
       const product: SearchResultProduct = {
         identifier: { key: p.id },
-        name: p.name[session.languageContext.locale] || p.id,
-        slug: p.slug?.[session.languageContext.locale] || p.id,
+        name: p.name[reqCtx.languageContext.locale] || p.id,
+        slug: p.slug?.[reqCtx.languageContext.locale] || p.id,
         image: p.masterVariant.images?.[0]?.url || 'https://placehold.co/400',
       };
 

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

@@ -0,0 +1,78 @@
+import type {
+  RequestContext,
+  Cache,
+  StoreQueryByProximity,
+} from '@reactionary/core';
+import { StoreProvider } from '@reactionary/core';
+import type z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { CommercetoolsClient } from '../core/client';
+import type { Channel, InventoryEntry } from '@commercetools/platform-sdk';
+import type { Store } from '@reactionary/core';
+
+export class CommercetoolsStoreProvider<
+  T extends Store = Store
+> extends StoreProvider<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 });
+  }
+
+  public override async queryByProximity(
+    payload: StoreQueryByProximity,
+    reqCtx: RequestContext
+  ): Promise<Array<T>> {
+    const client = await this.getClient(reqCtx);
+
+    const remote = await client
+        .channels()
+        .get({
+            queryArgs: {
+                limit: payload.limit,
+                where: `geoLocation within circle(${ payload.longitude }, ${ payload.latitude }, ${payload.distance * 1000}) AND roles contains any ("InventorySupply")`
+            }
+        }).execute();
+
+    const results = [];
+
+    for (const r of remote.body.results) {
+        results.push(this.parseSingle(r, reqCtx));
+    }
+
+    return results;
+  }
+
+  protected override parseSingle(
+    body: Channel,
+    reqCtx: RequestContext
+  ): T {
+    const model = this.newModel();
+
+    if (body.name && body.name['la']) {
+        model.name = body.name['la'];
+    }
+
+    model.identifier = {
+        key: body.key
+    };
+
+    model.fulfillmentCenter = {
+        key: body.key
+    };
+
+    return model;
+  }
+}

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

@@ -1,14 +1,16 @@
 import { CapabilitiesSchema } from "@reactionary/core";
-import { z } from 'zod';
+import type { z } from 'zod';
 
 export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
     product: true,
     search: true,
     identity: true,
     cart: true,
+    cartPayment: true,
     inventory: true,
     price: true,
     category: true,
+    store: true,
 }).partial();
 
 export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;

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,145 @@
+import 'dotenv/config';
+import type {
+  Cart, RequestContext} from '@reactionary/core';
+import { CartPaymentInstructionSchema,
+  CartSchema,
+  IdentitySchema,
+  NoOpCache, createInitialRequestContext
+} from '@reactionary/core';
+import {
+  getCommercetoolsTestConfiguration,
+} from './test-utils';
+import { CommercetoolsCartProvider } from '../providers/cart.provider';
+import { CommercetoolsIdentityProvider } from '../providers/identity.provider';
+import { CommercetoolsCartPaymentProvider } from '../providers/cart-payment.provider';
+
+const testData = {
+  skuWithoutTiers: 'SGB-01',
+  skuWithTiers: 'GMCT-01',
+};
+
+describe('Commercetools Cart Payment Provider', () => {
+  let provider: CommercetoolsCartPaymentProvider;
+  let cartProvider: CommercetoolsCartProvider;
+  let identityProvider: CommercetoolsIdentityProvider;
+  let reqCtx: RequestContext;
+
+  beforeAll(() => {
+    provider = new CommercetoolsCartPaymentProvider(
+      getCommercetoolsTestConfiguration(),
+      CartPaymentInstructionSchema,
+      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('a new cart will return 0 payment instructions', async () => {
+      const payments = await provider.getByCartIdentifier(
+        { cart: cart.identifier, status: undefined },
+        reqCtx
+      );
+      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' }],
+          },
+        },
+        reqCtx
+      );
+
+      expect(payment.identifier.key).toBeDefined();
+
+      // verify that we can fetch it again.
+      const payments = await provider.getByCartIdentifier(
+        { cart: cart.identifier, status: undefined },
+        reqCtx
+      );
+      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' }],
+          },
+        },
+        reqCtx
+      );
+      expect(payment.identifier.key).toBeDefined();
+
+      const cancelledPayment = await provider.cancelPaymentInstruction(
+        {
+          cart: cart.identifier,
+          paymentInstruction: payment.identifier
+        },
+        reqCtx
+      );
+      expect(cancelledPayment.status).toBe('canceled');
+
+
+      // verify that it is gone
+      const payments = await provider.getByCartIdentifier(
+        { cart: cart.identifier, status: undefined },
+        reqCtx
+      );
+      expect(payments.length).toBe(0);
+      expect(payments[0].identifier.key).toBe(payment.identifier.key);
+   });
+  });
+});