@reactionary/source 0.0.41 → 0.0.42

package/core/src/schemas/mutations/cart.mutation.ts

@@ -1,10 +1,13 @@
 import { z } from 'zod';
 import { BaseMutationSchema } from './base.mutation';
-import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
+import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifier, SKUIdentifierSchema } from '../models/identifiers.model';
+import { AddressSchema } from '../models/profile.model';
+import { CurrencySchema } from '../models/currency.model';
+import { MonetaryAmountSchema } from '../models/price.model';
 
 export const CartMutationItemAddSchema = BaseMutationSchema.extend({
     cart: CartIdentifierSchema.nonoptional(),
-    product: ProductIdentifierSchema.nonoptional(),
+    sku: SKUIdentifierSchema.nonoptional(),
     quantity: z.number()
 });
 
@@ -19,6 +22,62 @@ export const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
     quantity: z.number()
 });
 
+export const CartMutationDeleteCartSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required()
+});
+
+export const CartMutationSetShippingInfoSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    shippingMethod: ShippingMethodIdentifier.optional(),
+    shippingAddress: AddressSchema.optional(),
+});
+
+export const CartMutationSetBillingAddressSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    billingAddress: AddressSchema.required(),
+    notificationEmailAddress: z.string().optional(),
+    notificationPhoneNumber: z.string().optional(),
+});
+
+export const CartMutationApplyCouponSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    couponCode: z.string().default('').nonoptional()
+});
+
+export const CartMutationRemoveCouponSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    couponCode: z.string().default('').nonoptional()
+});
+
+export const CartMutationCheckoutSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required()
+});
+
+export const CartMutationAddPaymentMethodSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    paymentMethodId: PaymentMethodIdentifierSchema.required(),
+    amount: MonetaryAmountSchema.optional().describe('The amount to authorize for the payment method. If not provided, the full remaining balance of the cart will be authorized.')
+});
+
+export const CartMutationRemovePaymentMethodSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+});
+
+export const CartMutationChangeCurrencySchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    newCurrency: CurrencySchema.default(() => CurrencySchema.parse({})).describe('The new currency to set for the cart.')
+});
+
+
+export type CartMutationChangeCurrency = z.infer<typeof CartMutationChangeCurrencySchema>;
+export type CartMutationAddPaymentMethod = z.infer<typeof CartMutationAddPaymentMethodSchema>;
+export type CartMutationRemovePaymentMethod = z.infer<typeof CartMutationRemovePaymentMethodSchema>;
+export type CartMutationCheckout = z.infer<typeof CartMutationCheckoutSchema>;
 export type CartMutationItemAdd = z.infer<typeof CartMutationItemAddSchema>;
 export type CartMutationItemRemove = z.infer<typeof CartMutationItemRemoveSchema>;
-export type CartMutationItemQuantityChange = z.infer<typeof CartMutationItemQuantityChangeSchema>;
+export type CartMutationItemQuantityChange = z.infer<typeof CartMutationItemQuantityChangeSchema>;
+export type CartMutationDeleteCart = z.infer<typeof CartMutationDeleteCartSchema>;
+export type CartMutationSetShippingInfo = z.infer<typeof CartMutationSetShippingInfoSchema>;
+export type CartMutationSetBillingAddress = z.infer<typeof CartMutationSetBillingAddressSchema>;
+export type CartMutationApplyCoupon = z.infer<typeof CartMutationApplyCouponSchema>;
+export type CartMutationRemoveCoupon = z.infer<typeof CartMutationRemoveCouponSchema>;

package/core/src/schemas/mutations/identity.mutation.ts

@@ -9,5 +9,6 @@ export const IdentityMutationLoginSchema = BaseMutationSchema.extend({
 export const IdentityMutationLogoutSchema = BaseMutationSchema.extend({
 });
 
+
 export type IdentityMutationLogin = z.infer<typeof IdentityMutationLoginSchema>;
-export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;
+export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;

package/core/src/schemas/mutations/index.ts

@@ -0,0 +1,9 @@
+export * from './analytics.mutation';
+export * from './base.mutation';
+export * from './cart-payment.mutation';
+export * from './cart.mutation';
+export * from './identity.mutation';
+export * from './inventory.mutation';
+export * from './price.mutation';
+export * from './product.mutation';
+export * from './search.mutation';

package/core/src/schemas/queries/cart-payment.query.ts

@@ -0,0 +1,12 @@
+import z from "zod";
+import { CartIdentifierSchema } from "../models/identifiers.model";
+import { PaymentStatusSchema } from "../models/payment.model";
+import { BaseQuerySchema } from "./base.query";
+
+
+export const CartPaymentQueryByCartSchema = BaseQuerySchema.extend({
+    cart: CartIdentifierSchema.required(),
+    status: z.array(PaymentStatusSchema).optional().describe('Optional status to filter payment instructions by'),
+});
+
+export type CartPaymentQueryByCart = z.infer<typeof CartPaymentQueryByCartSchema>;

package/core/src/schemas/queries/index.ts

@@ -1,5 +1,6 @@
 export * from './analytics.query';
 export * from './base.query';
+export * from './cart-payment.query';
 export * from './cart.query';
 export * from './category.query';
 export * from './identity.query';

package/examples/node/src/test-utils.ts

@@ -1,5 +1,7 @@
 import { Session } from '@reactionary/core';
 
+
+
 export function createAnonymousTestSession(): Session {
   return {
     id: 'test-session-id',
@@ -9,10 +11,15 @@ export function createAnonymousTestSession(): Session {
         cache: { hit: false, key: '' },
         placeholder: false,
       },
-      id: '',
+      id: { userId: 'anonymous' },
       token: undefined,
       issued: new Date(),
-      expiry: new Date(new Date().getTime() + 3600 * 1000), // 1 hour from now
+      expiry: new Date(new Date().getTime() + 3600 * 1000),
+      logonId: "",
+      createdAt: "",
+      updatedAt: "",
+      keyring: [],
+      currentService: undefined
     },
     languageContext: {
       locale: 'en-US',
@@ -23,4 +30,4 @@ export function createAnonymousTestSession(): Session {
       key: 'the-good-store',
     },
   };
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "license": "MIT",
   "private": false,
   "dependencies": {

package/providers/algolia/src/test/test-utils.ts

@@ -9,10 +9,15 @@ export function createAnonymousTestSession(): Session {
         cache: { hit: false, key: '' },
         placeholder: false,
       },
-      id: '',
+      id: { userId: 'anonymous' },
       token: undefined,
       issued: new Date(),
-      expiry: new Date(new Date().getTime() + 3600 * 1000), // 1 hour from now
+      expiry: new Date(new Date().getTime() + 3600 * 1000),
+      logonId: "",
+      createdAt: "",
+      updatedAt: "",
+      keyring: [],
+      currentService: undefined
     },
     languageContext: {
       locale: 'en-US',
@@ -23,4 +28,4 @@ export function createAnonymousTestSession(): Session {
       key: 'the-good-store',
     },
   };
-}
+}

package/providers/commercetools/README.md

@@ -9,3 +9,19 @@ Run `nx build provider-commercetools` to build the library.
 ## Running unit tests
 
 Run `nx test provider-commercetools` to execute the unit tests via [Jest](https://jestjs.io).
+
+
+## TODO List
+
+### Core
+- [ ] Figure out if we are actually running as anonymous user towards CT. It feels weird right now.
+
+### Price
+- [ ] PriceProvider should be able to use both embedded and standalone prices? Possible by querying through product-projection maybe?
+- [ ] If not, using product-projection, the logic in https://docs.commercetools.com/api/pricing-and-discounts-overview#price-selection should be replicated
+- [ ] add list price by convention. Like key: LP-<sku> or something.
+
+
+### Inventory
+- [ ] Be traced and cached
+

package/providers/commercetools/src/core/client.ts

@@ -1,29 +1,8 @@
 import { ClientBuilder } from '@commercetools/ts-client';
 import { createApiBuilderFromCtpClient } from '@commercetools/platform-sdk';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { randomUUID } from 'crypto';
 
-const ANONYMOUS_SCOPES = [
-  'view_published_products',
-  'manage_shopping_lists',
-  'view_shipping_methods',
-  'manage_customers',
-  'view_product_selections',
-  'view_categories',
-  'view_project_settings',
-  'manage_order_edits',
-  'view_sessions',
-  'view_standalone_prices',
-  'manage_orders',
-  'view_tax_categories',
-  'view_cart_discounts',
-  'view_discount_codes',
-  'create_anonymous_token',
-  'manage_sessions',
-  'view_products',
-  'view_types',
-];
-const GUEST_SCOPES = [...ANONYMOUS_SCOPES];
-const REGISTERED_SCOPES = [...GUEST_SCOPES];
 
 export class CommercetoolsClient {
   protected config: CommercetoolsConfiguration;
@@ -41,14 +20,10 @@ export class CommercetoolsClient {
   }
 
   public async login(username: string, password: string) {
-    const scopes = REGISTERED_SCOPES.map(
-      (scope) => `${scope}:${this.config.projectKey}`
-    ).join(' ');
     const queryParams = new URLSearchParams({
       grant_type: 'password',
       username: username,
       password: password,
-      scope: scopes,
     });
     const url = `${this.config.authUrl}/oauth/${
       this.config.projectKey
@@ -65,12 +40,8 @@ export class CommercetoolsClient {
   }
 
   public async guest() {
-    const scopes = GUEST_SCOPES.map(
-      (scope) => `${scope}:${this.config.projectKey}`
-    ).join(' ');
     const queryParams = new URLSearchParams({
       grant_type: 'client_credentials',
-      scope: scopes,
     });
     const url = `${this.config.authUrl}/oauth/${
       this.config.projectKey
@@ -121,9 +92,7 @@ export class CommercetoolsClient {
   }
 
   public createAnonymousClient() {
-    const scopes = ANONYMOUS_SCOPES.map(
-      (scope) => `${scope}:${this.config.projectKey}`
-    ).join(' ');
+    const scopes = this.config.scopes;
     const builder = this.createBaseClientBuilder().withClientCredentialsFlow({
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
@@ -131,7 +100,7 @@ export class CommercetoolsClient {
         clientId: this.config.clientId,
         clientSecret: this.config.clientSecret,
       },
-      scopes: [scopes],
+      scopes: [...scopes],
     });
 
     return createApiBuilderFromCtpClient(builder.build());
@@ -146,12 +115,34 @@ export class CommercetoolsClient {
     return createApiBuilderFromCtpClient(builder.build());
   }
 
+
+
+
+
+
+
   protected createBaseClientBuilder() {
     const builder = new ClientBuilder()
       .withProjectKey(this.config.projectKey)
       .withQueueMiddleware({
         concurrency: 20,
       })
+      .withConcurrentModificationMiddleware({
+        concurrentModificationHandlerFn: (version: number, request: any) => {
+          // We basically ignore concurrency issues for now.
+          // And yes, ideally the frontend would handle this, but as the customer is not really in a position to DO anything about it,
+          // we might as well just deal with it here.....
+
+          console.log(`Concurrent modification error, retry with version ${version}`);
+          const body = request.body as Record<string, any>;
+          body['version'] = version;
+          return Promise.resolve(body);
+        },
+      })
+      .withCorrelationIdMiddleware({
+        // ideally this would be pushed in as part of the session context, so we can trace it end-to-end
+        generate: () => `REACTIONARY-${randomUUID()}`,
+      })
       .withHttpMiddleware({
         retryConfig: {
           backoff: true,

package/providers/commercetools/src/core/initialize.ts

@@ -1,11 +1,11 @@
-import { 
-    CartSchema, 
-    IdentitySchema, 
-    InventorySchema, 
-    PriceSchema, 
-    ProductSchema, 
-    SearchResultSchema, 
-    Cache, 
+import {
+    CartSchema,
+    IdentitySchema,
+    InventorySchema,
+    PriceSchema,
+    ProductSchema,
+    SearchResultSchema,
+    Cache,
     CategorySchema,
     ProductProvider,
     SearchProvider,
@@ -13,7 +13,8 @@ import {
     CartProvider,
     InventoryProvider,
     PriceProvider,
-    CategoryProvider
+    CategoryProvider,
+    CartPaymentInstructionSchema
 } from "@reactionary/core";
 import { CommercetoolsCapabilities } from "../schema/capabilities.schema";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
@@ -24,8 +25,9 @@ import { CommercetoolsCartProvider } from "../providers/cart.provider";
 import { CommercetoolsInventoryProvider } from "../providers/inventory.provider";
 import { CommercetoolsPriceProvider } from "../providers/price.provider";
 import { CommercetoolsCategoryProvider } from "../providers/category.provider";
+import { CommercetoolsCartPaymentProvider } from "../providers/cart-payment.provider";
 
-type CommercetoolsClient<T extends CommercetoolsCapabilities> = 
+type CommercetoolsClient<T extends CommercetoolsCapabilities> =
     (T['cart'] extends true ? { cart: CartProvider } : object) &
     (T['product'] extends true ? { product: ProductProvider } : object) &
     (T['search'] extends true ? { search: SearchProvider } : object) &
@@ -69,6 +71,11 @@ export function withCommercetoolsCapabilities<T extends CommercetoolsCapabilitie
             client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
         }
 
+        if (capabilities.cartPayment) {
+          client.cartPayment = new CommercetoolsCartPaymentProvider(configuration, CartPaymentInstructionSchema, cache);
+        }
+
+
         return client;
     };
 }

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

@@ -0,0 +1,192 @@
+
+import { CommercetoolsConfiguration } from "../schema/configuration.schema";
+import { CommercetoolsClient } from "../core/client";
+import { Payment as CTPayment, PaymentStatus } from "@commercetools/platform-sdk";
+import { traced } from "@reactionary/otel";
+import { CommercetoolsCartIdentifier, CommercetoolsCartIdentifierSchema, CommercetoolsCartPaymentInstructionIdentifierSchema } from "../schema/commercetools.schema";
+import { Cache, CartPaymentInstruction,  CartPaymentProvider, Currency, PaymentMethodIdentifierSchema,  } from "@reactionary/core";
+import type { CartPaymentQueryByCart, CartPaymentMutationAddPayment, CartPaymentMutationCancelPayment, Session } from "@reactionary/core";
+import z from "zod";
+
+export class CommercetoolsCartPaymentProvider<
+  T extends CartPaymentInstruction = CartPaymentInstruction
+> extends CartPaymentProvider<T> {
+  protected config: CommercetoolsConfiguration;
+
+  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
+
+    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 {
+      payments: client.withProjectKey({ projectKey: this.config.projectKey }).me().payments(),
+      carts: client.withProjectKey({ projectKey: this.config.projectKey }).me().carts()
+    };
+  }
+
+
+
+  @traced()
+  public override async getByCartIdentifier(payload: CartPaymentQueryByCart, session: Session): Promise<T[]> {
+    const client = this.getClient(session);
+
+    const ctId = payload.cart as CommercetoolsCartIdentifier;
+    const ctVersion = ctId.version || 0;
+
+    const cart = await client.carts.withId({ ID: ctId.key })
+        .get({
+            queryArgs: {
+              expand: 'paymentInfo.payments[*]',
+            },
+          })
+          .execute();
+
+      let payments = (cart.body.paymentInfo?.payments || []).map(x => x.obj!).filter(x => x);
+      if (payload.status) {
+        payments = payments.filter(payment => payload.status!.some(status => payment.paymentStatus?.interfaceCode === status));
+      }
+
+      // Map over the payments and parse each one
+      const parsedPayments = payments.map(payment => this.parseSingle(payment, session));
+
+      // Commercetools does not link carts to payments, but the other way around, so for this we have to synthesize the link.
+      const returnPayments = parsedPayments.map(x => {
+        x.cart = { key: cart.body.id, version: cart.body.version || 0 };
+        return x;
+      });
+      return returnPayments;
+  }
+
+
+
+  public override async initiatePaymentForCart(payload: CartPaymentMutationAddPayment, session: Session): Promise<T> {
+    const client = this.getClient(session);
+    const cartId = payload.cart as CommercetoolsCartIdentifier;
+    const response = await client.payments.post({
+      body: {
+
+        amountPlanned: {
+          centAmount: Math.round(payload.paymentInstruction.amount.value * 100),
+          currencyCode: payload.paymentInstruction.amount.currency
+        },
+        paymentMethodInfo: {
+          method: payload.paymentInstruction.paymentMethod.method,
+          name: {
+            [session.languageContext.locale]: payload.paymentInstruction.paymentMethod.name
+          },
+          paymentInterface: payload.paymentInstruction.paymentMethod.paymentProcessor
+        },
+        custom:{
+        type: {
+          typeId: 'type',
+          key: 'reactionaryPaymentCustomFields',
+        },
+        fields: {
+          cartId: cartId.key,
+          cartVersion: cartId.version + '',
+        }},
+
+      },
+    }).execute();
+
+    // Now add the payment to the cart
+    const ctId = payload.cart as CommercetoolsCartIdentifier
+    const updatedCart = await client.carts.withId({ ID: ctId.key }).post({
+      body: {
+        version: ctId.version,
+        actions: [
+          {
+            'action': 'addPayment',
+            'payment': {
+              'typeId': 'payment',
+              'id': response.body.id
+            }
+          }
+        ]
+      }
+    }).execute();
+
+    const payment = this.parseSingle(response.body, session);
+
+    // we return the newest cart version so caller can update their cart reference, if they want to.
+    // hopefully this wont cause excessive confusion
+    payment.cart = CommercetoolsCartIdentifierSchema.parse({
+        key: updatedCart.body.id,
+        version: updatedCart.body.version || 0
+      });
+    return payment;
+  }
+
+
+  @traced()
+  public override async cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, session: Session): Promise<T> {
+    const client = this.getClient(session);
+
+    // get newest version
+    const newestVersion = await client.payments.withId({ ID: payload.paymentInstruction.key }).get().execute();
+
+
+    // we set the planned amount to 0, which effectively cancels the payment, and also allows the backend to clean it up.
+    // Note: This does NOT remove the payment from the cart, as that would be a breaking change to the cart, and we want to avoid that during checkout.
+    // Instead, the payment will remain on the cart, but with status 'canceled', and can be removed later if needed.
+    // This also allows us to keep a record of the payment instruction for auditing purposes.
+    // The cart can be re-used, and a new payment instruction can be added to it later.
+    // The frontend should ignore any payment instructions with status 'canceled' when displaying payment options to the user.
+    const response = await client.payments.withId({ ID: payload.paymentInstruction.key }).post({
+      body: {
+        version: newestVersion.body.version,
+        actions: [
+          {
+            action: 'changeAmountPlanned',
+            amount: {
+              centAmount: 0,
+              currencyCode: newestVersion.body.amountPlanned.currencyCode
+            }
+          },
+        ]
+      }
+    }).execute();
+
+    const payment = this.parseSingle(response.body, session);
+    payment.cart = payload.cart;
+    return payment;
+  }
+
+
+
+  @traced()
+  protected override parseSingle(_body: unknown, session: Session): T {
+    const body = _body as CTPayment;
+
+    const base = this.newModel();
+    base.identifier = CommercetoolsCartPaymentInstructionIdentifierSchema.parse({
+      key: body.id,
+      version: body.version || 0
+    });
+
+    base.amount = {
+      value: body.amountPlanned.centAmount / 100,
+      currency: body.amountPlanned.currencyCode as Currency,
+    };
+
+
+    base.paymentMethod = PaymentMethodIdentifierSchema.parse({
+      key: body.paymentMethodInfo?.method
+    });
+
+    // FIXME: seems wrong
+    base.status = body.paymentStatus?.interfaceCode as unknown as any;
+
+    base.cart = { key: '', version: 0 };
+
+    return this.assert(base);
+  }
+
+
+}