@reactionary/core 0.0.41 → 0.0.42

package/index.js

@@ -5,32 +5,9 @@ export * from "./cache/noop-cache";
 export * from "./client/client";
 export * from "./client/client-builder";
 export * from "./decorators/reactionary.decorator";
-export * from "./providers/analytics.provider";
-export * from "./providers/base.provider";
-export * from "./providers/cart.provider";
-export * from "./providers/identity.provider";
-export * from "./providers/inventory.provider";
-export * from "./providers/price.provider";
-export * from "./providers/product.provider";
-export * from "./providers/search.provider";
-export * from "./providers/category.provider";
+export * from "./providers/";
 export * from "./schemas/capabilities.schema";
 export * from "./schemas/session.schema";
-export * from "./schemas/models/base.model";
-export * from "./schemas/models/cart.model";
-export * from "./schemas/models/currency.model";
-export * from "./schemas/models/identifiers.model";
-export * from "./schemas/models/identity.model";
-export * from "./schemas/models/inventory.model";
-export * from "./schemas/models/price.model";
-export * from "./schemas/models/product.model";
-export * from "./schemas/models/search.model";
-export * from "./schemas/models/category.model";
-export * from "./schemas/mutations/base.mutation";
-export * from "./schemas/mutations/cart.mutation";
-export * from "./schemas/mutations/identity.mutation";
-export * from "./schemas/mutations/inventory.mutation";
-export * from "./schemas/mutations/price.mutation";
-export * from "./schemas/mutations/product.mutation";
-export * from "./schemas/mutations/search.mutation";
+export * from "./schemas/models/";
+export * from "./schemas/mutations/";
 export * from "./schemas/queries";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/core",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {

package/providers/cart-payment.provider.js

@@ -0,0 +1,9 @@
+import { BaseProvider } from "./base.provider";
+class CartPaymentProvider extends BaseProvider {
+  getResourceName() {
+    return "cart-payment-instruction";
+  }
+}
+export {
+  CartPaymentProvider
+};

package/providers/cart.provider.js

@@ -1,5 +1,11 @@
 import { BaseProvider } from "./base.provider";
 class CartProvider extends BaseProvider {
+  createEmptyCart() {
+    const cart = this.newModel();
+    cart.meta = { placeholder: true, cache: { hit: true, key: "empty-cart" } };
+    cart.identifier = { key: "" };
+    return cart;
+  }
   getResourceName() {
     return "cart";
   }

package/providers/index.js

@@ -0,0 +1,10 @@
+export * from "./analytics.provider";
+export * from "./base.provider";
+export * from "./cart-payment.provider";
+export * from "./cart.provider";
+export * from "./category.provider";
+export * from "./identity.provider";
+export * from "./inventory.provider";
+export * from "./price.provider";
+export * from "./product.provider";
+export * from "./search.provider";

package/providers/price.provider.js

@@ -8,7 +8,7 @@ class PriceProvider extends BaseProvider {
    * @param currency
    * @returns
    */
-  getEmptyPriceResult(sku, currency) {
+  createEmptyPriceResult(sku, currency) {
     const base = this.newModel();
     base.identifier = {
       sku: { key: sku }

package/providers/product.provider.js

@@ -1,5 +1,15 @@
 import { BaseProvider } from "./base.provider";
 class ProductProvider extends BaseProvider {
+  createEmptyProduct(id) {
+    const product = this.newModel();
+    product.identifier = { key: id };
+    product.meta.placeholder = true;
+    return product;
+  }
+  /**
+   * The resource name, used for caching and logging.
+   * @returns
+   */
   getResourceName() {
     return "product";
   }

package/schemas/capabilities.schema.js

@@ -5,6 +5,7 @@ const CapabilitiesSchema = z.looseObject({
   analytics: z.boolean(),
   identity: z.boolean(),
   cart: z.boolean(),
+  cartPayment: z.boolean(),
   inventory: z.boolean(),
   price: z.boolean(),
   category: z.boolean()

package/schemas/models/cart.model.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
-import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from "../models/identifiers.model";
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, ProductIdentifierSchema, SKUIdentifierSchema } from "../models/identifiers.model";
 import { BaseModelSchema } from "./base.model";
 import { MonetaryAmountSchema } from "./price.model";
+import { AddressSchema } from "./profile.model";
+import { ShippingMethodSchema } from "./shipping-method.model";
 const CostBreakDownSchema = z.looseObject({
   totalTax: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of tax paid on the cart. This may include VAT, GST, sales tax, etc."),
   totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of discount applied to the cart."),
@@ -19,15 +21,20 @@ const ItemCostBreakdownSchema = z.looseObject({
 const CartItemSchema = z.looseObject({
   identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
   product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
   quantity: z.number().default(0),
   price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({}))
 });
 const CartSchema = BaseModelSchema.extend({
   identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  userId: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
   items: z.array(CartItemSchema).default(() => []),
   price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
   name: z.string().default(""),
-  description: z.string().default("")
+  description: z.string().default(""),
+  shippingAddress: AddressSchema.optional(),
+  billingAddress: AddressSchema.optional(),
+  shippingMethod: ShippingMethodSchema.optional()
 });
 export {
   CartItemSchema,

package/schemas/models/identifiers.model.js

@@ -30,6 +30,12 @@ const PriceIdentifierSchema = z.looseObject({
 const CategoryIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
+const OrderIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
+const OrderItemIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
 const WebStoreIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
@@ -40,17 +46,41 @@ const InventoryIdentifierSchema = z.looseObject({
   sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
   channelId: InventoryChannelIdentifierSchema.default(() => InventoryChannelIdentifierSchema.parse({}))
 });
+const IdentityIdentifierSchema = z.looseObject({
+  userId: z.string().default("").nonoptional()
+});
+const ShippingMethodIdentifier = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
+const PaymentMethodIdentifierSchema = z.looseObject({
+  method: z.string().default("").nonoptional(),
+  name: z.string().default("").nonoptional(),
+  paymentProcessor: z.string().default("").nonoptional()
+});
+const AddressIdentifierSchema = z.looseObject({
+  nickName: z.string().default("").nonoptional()
+});
+const PaymentInstructionIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
 export {
+  AddressIdentifierSchema,
   CartIdentifierSchema,
   CartItemIdentifierSchema,
   CategoryIdentifierSchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
+  IdentityIdentifierSchema,
   InventoryChannelIdentifierSchema,
   InventoryIdentifierSchema,
+  OrderIdentifierSchema,
+  OrderItemIdentifierSchema,
+  PaymentInstructionIdentifierSchema,
+  PaymentMethodIdentifierSchema,
   PriceIdentifierSchema,
   ProductIdentifierSchema,
   SKUIdentifierSchema,
   SearchIdentifierSchema,
+  ShippingMethodIdentifier,
   WebStoreIdentifierSchema
 };

package/schemas/models/identity.model.js

@@ -1,14 +1,29 @@
 import { z } from "zod";
 import { BaseModelSchema } from "./base.model";
+import { IdentityIdentifierSchema } from "./identifiers.model";
 const IdentityTypeSchema = z.enum(["Anonymous", "Guest", "Registered"]);
+const ServiceTokenSchema = z.object({
+  service: z.string().default(""),
+  token: z.string().default(""),
+  issued: z.coerce.date().default(/* @__PURE__ */ new Date()),
+  expiry: z.coerce.date().default(/* @__PURE__ */ new Date())
+});
 const IdentitySchema = BaseModelSchema.extend({
-  id: z.string().default(""),
+  id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
   type: IdentityTypeSchema.default("Anonymous"),
+  logonId: z.string().default(""),
+  createdAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
+  updatedAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
+  // Tokens for various services
+  keyring: z.array(ServiceTokenSchema).default(() => []),
+  // Deprecated - use serviceTokens map instead
+  currentService: z.string().optional(),
   token: z.string().optional(),
   issued: z.coerce.date().default(/* @__PURE__ */ new Date()),
   expiry: z.coerce.date().default(/* @__PURE__ */ new Date())
 });
 export {
   IdentitySchema,
-  IdentityTypeSchema
+  IdentityTypeSchema,
+  ServiceTokenSchema
 };

package/schemas/models/index.js

@@ -0,0 +1,14 @@
+export * from "./analytics.model";
+export * from "./base.model";
+export * from "./cart.model";
+export * from "./category.model";
+export * from "./currency.model";
+export * from "./identifiers.model";
+export * from "./identity.model";
+export * from "./inventory.model";
+export * from "./payment.model";
+export * from "./price.model";
+export * from "./product.model";
+export * from "./profile.model";
+export * from "./search.model";
+export * from "./shipping-method.model";

package/schemas/models/payment.model.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { BaseModelSchema, ImageSchema } from "./base.model";
+import { CartIdentifierSchema, PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from "./identifiers.model";
+import { MonetaryAmountSchema } from "./price.model";
+const PaymentStatusSchema = z.enum(["pending", "authorized", "canceled", "capture", "partial_capture", "refunded", "partial_refund"]);
+const PaymentProtocolDataSchema = z.looseObject({
+  key: z.string().default(""),
+  value: z.string().default("")
+});
+const PaymentMethodSchema = BaseModelSchema.extend({
+  identifier: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+  logo: ImageSchema.optional(),
+  description: z.string().default(""),
+  isPunchOut: z.boolean().default(true)
+});
+const PaymentInstructionSchema = BaseModelSchema.extend({
+  identifier: PaymentInstructionIdentifierSchema.default(() => PaymentInstructionIdentifierSchema.parse({})),
+  amount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
+  paymentMethod: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+  protocolData: z.array(PaymentProtocolDataSchema).default(() => []).describe("Additional protocol-specific data for processing the payment."),
+  status: PaymentStatusSchema.default("pending")
+});
+const CartPaymentInstructionSchema = PaymentInstructionSchema.extend({
+  cart: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({}))
+});
+const OrderPaymentInstructionSchema = PaymentInstructionSchema.extend({
+  order: z.string().default("")
+  // OrderIdentifierSchema
+});
+export {
+  CartPaymentInstructionSchema,
+  OrderPaymentInstructionSchema,
+  PaymentInstructionSchema,
+  PaymentMethodSchema,
+  PaymentProtocolDataSchema,
+  PaymentStatusSchema
+};

package/schemas/models/profile.model.js

@@ -0,0 +1,29 @@
+import z from "zod";
+import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model";
+const AddressSchema = z.looseObject({
+  identifier: AddressIdentifierSchema.default(() => AddressIdentifierSchema.parse({})),
+  firstName: z.string().default(""),
+  lastName: z.string().default(""),
+  streetAddress: z.string().default(""),
+  streetNumber: z.string().default(""),
+  city: z.string().default(""),
+  region: z.string().default(""),
+  postalCode: z.string().default(""),
+  countryCode: z.string().default("US")
+});
+const ProfileSchema = z.looseObject({
+  identifier: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+  email: z.string().email().default(""),
+  phone: z.string().default(""),
+  emailVerified: z.boolean().default(false),
+  phoneVerified: z.boolean().default(false),
+  createdAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
+  updatedAt: z.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
+  shippingAddress: AddressSchema.optional(),
+  billingAddress: AddressSchema.optional(),
+  alternateShippingAddresses: z.array(AddressSchema).default(() => [])
+});
+export {
+  AddressSchema,
+  ProfileSchema
+};

package/schemas/models/shipping-method.model.js

@@ -0,0 +1,15 @@
+import z from "zod";
+import { ShippingMethodIdentifier } from "./identifiers.model";
+import { MonetaryAmountSchema } from "./price.model";
+import { ImageSchema } from "./base.model";
+const ShippingMethodSchema = z.looseObject({
+  identifier: ShippingMethodIdentifier.default(() => ShippingMethodIdentifier.parse({})),
+  name: z.string().default(""),
+  description: z.string().default(""),
+  logo: ImageSchema.optional(),
+  price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
+  deliveryTime: z.string().default("")
+});
+export {
+  ShippingMethodSchema
+};

package/schemas/mutations/cart-payment.mutation.js

@@ -0,0 +1,15 @@
+import { CartIdentifierSchema, PaymentInstructionIdentifierSchema } from "../models/identifiers.model";
+import { PaymentInstructionSchema } from "../models/payment.model";
+import { BaseMutationSchema } from "./base.mutation";
+const CartPaymentMutationAddPayment = BaseMutationSchema.extend({
+  paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+  cart: CartIdentifierSchema.required()
+});
+const CartPaymentMutationCancelPayment = BaseMutationSchema.extend({
+  paymentInstruction: PaymentInstructionIdentifierSchema.required(),
+  cart: CartIdentifierSchema.required()
+});
+export {
+  CartPaymentMutationAddPayment,
+  CartPaymentMutationCancelPayment
+};

package/schemas/mutations/cart.mutation.js

@@ -1,9 +1,12 @@
 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";
 const CartMutationItemAddSchema = BaseMutationSchema.extend({
   cart: CartIdentifierSchema.nonoptional(),
-  product: ProductIdentifierSchema.nonoptional(),
+  sku: SKUIdentifierSchema.nonoptional(),
   quantity: z.number()
 });
 const CartMutationItemRemoveSchema = BaseMutationSchema.extend({
@@ -15,8 +18,54 @@ const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
   item: CartItemIdentifierSchema.nonoptional(),
   quantity: z.number()
 });
+const CartMutationDeleteCartSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required()
+});
+const CartMutationSetShippingInfoSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required(),
+  shippingMethod: ShippingMethodIdentifier.optional(),
+  shippingAddress: AddressSchema.optional()
+});
+const CartMutationSetBillingAddressSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required(),
+  billingAddress: AddressSchema.required(),
+  notificationEmailAddress: z.string().optional(),
+  notificationPhoneNumber: z.string().optional()
+});
+const CartMutationApplyCouponSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required(),
+  couponCode: z.string().default("").nonoptional()
+});
+const CartMutationRemoveCouponSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required(),
+  couponCode: z.string().default("").nonoptional()
+});
+const CartMutationCheckoutSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required()
+});
+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.")
+});
+const CartMutationRemovePaymentMethodSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required()
+});
+const CartMutationChangeCurrencySchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required(),
+  newCurrency: CurrencySchema.default(() => CurrencySchema.parse({})).describe("The new currency to set for the cart.")
+});
 export {
+  CartMutationAddPaymentMethodSchema,
+  CartMutationApplyCouponSchema,
+  CartMutationChangeCurrencySchema,
+  CartMutationCheckoutSchema,
+  CartMutationDeleteCartSchema,
   CartMutationItemAddSchema,
   CartMutationItemQuantityChangeSchema,
-  CartMutationItemRemoveSchema
+  CartMutationItemRemoveSchema,
+  CartMutationRemoveCouponSchema,
+  CartMutationRemovePaymentMethodSchema,
+  CartMutationSetBillingAddressSchema,
+  CartMutationSetShippingInfoSchema
 };

package/schemas/mutations/index.js

@@ -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/schemas/queries/cart-payment.query.js

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

package/schemas/queries/index.js

@@ -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/src/client/client.d.ts

@@ -7,12 +7,14 @@ import { PriceProvider } from "../providers/price.provider";
 import { InventoryProvider } from "../providers/inventory.provider";
 import { Cache } from "../cache/cache.interface";
 import { CategoryProvider } from "../providers/category.provider";
+import { CartPaymentProvider } from "../providers";
 export interface Client {
     product: ProductProvider;
     search: SearchProvider;
     identity: IdentityProvider;
     cache: Cache;
     cart: CartProvider;
+    cartPayment: CartPaymentProvider;
     analytics: Array<AnalyticsProvider>;
     price: PriceProvider;
     inventory: InventoryProvider;

package/src/index.d.ts

@@ -5,32 +5,9 @@ export * from './cache/noop-cache';
 export * from './client/client';
 export * from './client/client-builder';
 export * from './decorators/reactionary.decorator';
-export * from './providers/analytics.provider';
-export * from './providers/base.provider';
-export * from './providers/cart.provider';
-export * from './providers/identity.provider';
-export * from './providers/inventory.provider';
-export * from './providers/price.provider';
-export * from './providers/product.provider';
-export * from './providers/search.provider';
-export * from './providers/category.provider';
+export * from './providers/';
 export * from './schemas/capabilities.schema';
 export * from './schemas/session.schema';
-export * from './schemas/models/base.model';
-export * from './schemas/models/cart.model';
-export * from './schemas/models/currency.model';
-export * from './schemas/models/identifiers.model';
-export * from './schemas/models/identity.model';
-export * from './schemas/models/inventory.model';
-export * from './schemas/models/price.model';
-export * from './schemas/models/product.model';
-export * from './schemas/models/search.model';
-export * from './schemas/models/category.model';
-export * from './schemas/mutations/base.mutation';
-export * from './schemas/mutations/cart.mutation';
-export * from './schemas/mutations/identity.mutation';
-export * from './schemas/mutations/inventory.mutation';
-export * from './schemas/mutations/price.mutation';
-export * from './schemas/mutations/product.mutation';
-export * from './schemas/mutations/search.mutation';
+export * from './schemas/models/';
+export * from './schemas/mutations/';
 export * from './schemas/queries';

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

@@ -0,0 +1,42 @@
+import { CartPaymentInstruction } from '../schemas/models/payment.model';
+import { CartPaymentMutationAddPayment, CartPaymentMutationCancelPayment } from '../schemas/mutations/cart-payment.mutation';
+import { CartPaymentQueryByCart } from '../schemas/queries/cart-payment.query';
+import { Session } from '../schemas/session.schema';
+import { BaseProvider } from './base.provider';
+export declare abstract class CartPaymentProvider<T extends CartPaymentInstruction = CartPaymentInstruction> extends BaseProvider<T> {
+    /**
+     * Returns all payment instructions associated with a given cart, optionally filtered by status
+     *
+     * Usecase: Fetch all registered payment instructions to show on checkout page, in case you support multiple payments in your storefront,
+     * and need to show how far the user has come in the payment process. Also useful if user reloads page, or goes back to site or otherwise breaks the flow.
+     *
+     * Only returns payment instructions in status 'pending' or 'authorized'
+     * @param cartIdentifier
+     * @param session
+     */
+    abstract getByCartIdentifier(payload: CartPaymentQueryByCart, session: Session): Promise<T[]>;
+    /**
+     * Calls payment provider to set up a new payment intent. Returns whatever is needed to continue the payment process, e.g. a client secret for Stripe, or a redirect URL for PayPal.
+     *
+     * Usecase: User has filled out checkout form, and is ready to pay. You call this to get the payment process started.
+     *
+     * Note: The payment provider MAY change the cart during the payment process, so be sure to reload the cart object after this call.
+     *
+     * @param payload
+     * @param session
+     */
+    abstract initiatePaymentForCart(payload: CartPaymentMutationAddPayment, session: Session): Promise<T>;
+    /**
+     * Cancel a payment instruction. This will typically void the payment intent in the payment provider, and set the status of the payment instruction to 'canceled'.
+     *
+     * Usecase: User has decided to cancel the payment, e.g. by going back in the checkout process, or by closing the browser window. You call this to clean up the payment instruction.
+     *
+     * Note: The payment provider MAY change the cart during the cancellation process, so be sure to reload the cart object after this call.
+     *
+     * @param payload
+     * @param session
+     * @returns
+     */
+    abstract cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, session: Session): Promise<T>;
+    protected getResourceName(): string;
+}