@reactionary/source 0.0.42 → 0.0.51

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

@@ -1,12 +0,0 @@
-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/providers/commercetools/src/providers/cart-payment.provider.ts

@@ -1,192 +0,0 @@
-
-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);
-  }
-
-
-}

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

@@ -1,149 +0,0 @@
-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/trpc/src/test-utils.ts

@@ -1,31 +0,0 @@
-import { Session } from '@reactionary/core';
-
-export function createAnonymousTestSession(): Session {
-  return {
-    id: 'test-session-id',
-    identity: {
-      type: 'Anonymous',
-      meta: {
-        cache: { hit: false, key: '' },
-        placeholder: false,
-      },
-      id: { userId: 'anonymous' },
-      token: undefined,
-      issued: new Date(),
-      expiry: new Date(new Date().getTime() + 3600 * 1000),
-      logonId: "",
-      createdAt: "",
-      updatedAt: "",
-      keyring: [],
-      currentService: undefined
-    },
-    languageContext: {
-      locale: 'en-US',
-      currencyCode: 'USD',
-      countryCode: 'US',
-    },
-    storeIdentifier: {
-      key: 'the-good-store',
-    },
-  };
-}