@reactionary/core 0.0.48 → 0.0.51

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactionary/core",
-  "version": "0.0.48",
+  "version": "0.0.51",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
     "zod": "4.1.9",
     "@upstash/redis": "^1.34.9",
-    "@reactionary/otel": "0.0.48",
+    "@reactionary/otel": "0.0.51",
     "node-object-hash": "^3.1.1"
   }
 }

package/providers/checkout.provider.js

@@ -0,0 +1,6 @@
+import { BaseProvider } from "./base.provider";
+class CheckoutProvider extends BaseProvider {
+}
+export {
+  CheckoutProvider
+};

package/providers/index.js

@@ -1,8 +1,8 @@
 export * from "./analytics.provider";
 export * from "./base.provider";
-export * from "./cart-payment.provider";
 export * from "./cart.provider";
 export * from "./category.provider";
+export * from "./checkout.provider";
 export * from "./identity.provider";
 export * from "./inventory.provider";
 export * from "./price.provider";
@@ -10,3 +10,4 @@ export * from "./product.provider";
 export * from "./profile.provider";
 export * from "./search.provider";
 export * from "./store.provider";
+export * from "./order.provider";

package/providers/order.provider.js

@@ -0,0 +1,15 @@
+import { BaseProvider } from "./base.provider";
+class OrderProvider extends BaseProvider {
+  createEmptyOrder() {
+    const order = this.newModel();
+    order.meta = { placeholder: true, cache: { hit: true, key: "empty-order" } };
+    order.identifier = { key: "" };
+    return order;
+  }
+  getResourceName() {
+    return "order";
+  }
+}
+export {
+  OrderProvider
+};

package/schemas/capabilities.schema.js

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

package/schemas/models/cart.model.js

@@ -1,23 +1,7 @@
 import { z } from "zod";
 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."),
-  totalSurcharge: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of surcharge applied to the cart."),
-  totalShipping: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of shipping fees for the cart."),
-  totalProductPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price of products in the cart."),
-  grandTotal: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price for the cart including all taxes, discounts, and shipping.")
-});
-const ItemCostBreakdownSchema = z.looseObject({
-  unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The price per single unit of the item."),
-  unitDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The discount applied per single unit of the item."),
-  totalPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price for all units of the item."),
-  totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total discount applied to all units of the item.")
-});
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model";
 const CartItemSchema = z.looseObject({
   identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
   product: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})),
@@ -31,14 +15,9 @@ const CartSchema = BaseModelSchema.extend({
   items: z.array(CartItemSchema).default(() => []),
   price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
   name: z.string().default(""),
-  description: z.string().default(""),
-  shippingAddress: AddressSchema.optional(),
-  billingAddress: AddressSchema.optional(),
-  shippingMethod: ShippingMethodSchema.optional()
+  description: z.string().default("")
 });
 export {
   CartItemSchema,
-  CartSchema,
-  CostBreakDownSchema,
-  ItemCostBreakdownSchema
+  CartSchema
 };

package/schemas/models/checkout.model.js

@@ -0,0 +1,44 @@
+import { z } from "zod";
+import { BaseModelSchema } from "./base.model";
+import { CartIdentifierSchema, CheckoutIdentifierSchema, CheckoutItemIdentifierSchema, OrderIdentifierSchema, SKUIdentifierSchema } from "./identifiers.model";
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model";
+import { AddressSchema } from "./profile.model";
+import { ShippingInstructionSchema } from "./shipping-method.model";
+import { PaymentInstructionSchema } from "./payment.model";
+const CheckoutItemSchema = z.looseObject({
+  identifier: CheckoutItemIdentifierSchema.default(() => CheckoutItemIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+  quantity: z.number().default(0),
+  price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({}))
+});
+const CheckoutSchema = BaseModelSchema.extend({
+  identifier: CheckoutIdentifierSchema.default(() => CheckoutIdentifierSchema.parse({})),
+  /**
+   * Do we need this?
+   */
+  originalCartReference: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  /**
+   * If the checkout has been completed, this will point to the resulting order.
+   */
+  resultingOrder: OrderIdentifierSchema.optional(),
+  items: z.array(CheckoutItemSchema).default(() => []),
+  price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
+  name: z.string().default(""),
+  description: z.string().default(""),
+  billingAddress: AddressSchema.optional(),
+  /**
+   * Shipping and billing details can be changed on the checkout, but not items or quantities.
+   */
+  shippingAddress: AddressSchema.optional(),
+  shippingInstruction: ShippingInstructionSchema.optional(),
+  paymentInstructions: z.array(PaymentInstructionSchema).default(() => []),
+  /**
+   * Indicates if the checkout has all the required information to be finalized into an order.
+   * This does not mean it will succeed, as there may be issues with payment or shipping, but all required information is present.
+   */
+  readyForFinalization: z.boolean().default(false).describe("Indicates if the checkout has all the required information to be finalized into an order. This does not mean it will succeed, as there may be issues with payment or shipping, but all required information is present.")
+});
+export {
+  CheckoutItemSchema,
+  CheckoutSchema
+};

package/schemas/models/cost.model.js

@@ -0,0 +1,20 @@
+import z from "zod";
+import { MonetaryAmountSchema } from "./price.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."),
+  totalSurcharge: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of surcharge applied to the cart."),
+  totalShipping: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The amount of shipping fees for the cart."),
+  totalProductPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price of products in the cart."),
+  grandTotal: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price for the cart including all taxes, discounts, and shipping.")
+});
+const ItemCostBreakdownSchema = z.looseObject({
+  unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The price per single unit of the item."),
+  unitDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The discount applied per single unit of the item."),
+  totalPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total price for all units of the item."),
+  totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe("The total discount applied to all units of the item.")
+});
+export {
+  CostBreakDownSchema,
+  ItemCostBreakdownSchema
+};

package/schemas/models/identifiers.model.js

@@ -39,6 +39,12 @@ const OrderIdentifierSchema = z.looseObject({
 const OrderItemIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
+const CheckoutIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
+const CheckoutItemIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
 const WebStoreIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
@@ -68,11 +74,16 @@ const AddressIdentifierSchema = z.looseObject({
 const PaymentInstructionIdentifierSchema = z.looseObject({
   key: z.string().default("").nonoptional()
 });
+const PickupPointIdentifierSchema = z.looseObject({
+  key: z.string().default("").nonoptional()
+});
 export {
   AddressIdentifierSchema,
   CartIdentifierSchema,
   CartItemIdentifierSchema,
   CategoryIdentifierSchema,
+  CheckoutIdentifierSchema,
+  CheckoutItemIdentifierSchema,
   FacetIdentifierSchema,
   FacetValueIdentifierSchema,
   FulfillmentCenterIdentifierSchema,
@@ -82,6 +93,7 @@ export {
   OrderItemIdentifierSchema,
   PaymentInstructionIdentifierSchema,
   PaymentMethodIdentifierSchema,
+  PickupPointIdentifierSchema,
   PriceIdentifierSchema,
   ProductIdentifierSchema,
   SKUIdentifierSchema,

package/schemas/models/identity.model.js

@@ -2,18 +2,21 @@ import { z } from "zod";
 import { BaseModelSchema } from "./base.model";
 import { IdentityIdentifierSchema } from "./identifiers.model";
 const AnonymousIdentitySchema = BaseModelSchema.extend({
-  type: z.literal("Anonymous")
+  type: z.literal("Anonymous").default("Anonymous"),
+  token: z.string().optional(),
+  refresh_token: z.string().optional(),
+  expiry: z.coerce.date().default(/* @__PURE__ */ new Date())
 });
 const GuestIdentitySchema = BaseModelSchema.extend({
   id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-  type: z.literal("Guest"),
+  type: z.literal("Guest").default("Guest"),
   token: z.string().optional(),
   refresh_token: z.string().optional(),
   expiry: z.coerce.date().default(/* @__PURE__ */ new Date())
 });
 const RegisteredIdentitySchema = BaseModelSchema.extend({
   id: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
-  type: z.literal("Registered"),
+  type: z.literal("Registered").default("Registered"),
   logonId: z.string().default(""),
   token: z.string().optional(),
   refresh_token: z.string().optional(),

package/schemas/models/index.js

@@ -13,3 +13,7 @@ export * from "./profile.model";
 export * from "./search.model";
 export * from "./shipping-method.model";
 export * from "./store.model";
+export * from "./order.model";
+export * from "./cost.model";
+export * from "./checkout.model";
+export * from "./payment.model";

package/schemas/models/order.model.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, SKUIdentifierSchema } from "../models/identifiers.model";
+import { BaseModelSchema } from "./base.model";
+import { AddressSchema } from "./profile.model";
+import { ShippingMethodSchema } from "./shipping-method.model";
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from "./cost.model";
+import { PaymentInstructionSchema } from "./payment.model";
+const OrderStatusSchema = z.enum(["AwaitingPayment", "ReleasedToFulfillment", "Shipped", "Cancelled"]).default("AwaitingPayment").describe("The current status of the order.");
+const OrderInventoryStatusSchema = z.enum(["NotAllocated", "Allocated", "Backordered", "Preordered"]).default("Allocated").describe("The inventory release status of the order.");
+const OrderItemSchema = z.looseObject({
+  identifier: CartItemIdentifierSchema.default(() => CartItemIdentifierSchema.parse({})),
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+  quantity: z.number().default(0),
+  price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({})),
+  inventoryStatus: OrderInventoryStatusSchema.default("Allocated").describe("The inventory release status of the order item.")
+});
+const OrderSchema = BaseModelSchema.extend({
+  identifier: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({})),
+  userId: IdentityIdentifierSchema.default(() => IdentityIdentifierSchema.parse({})),
+  items: z.array(OrderItemSchema).default(() => []),
+  price: CostBreakDownSchema.default(() => CostBreakDownSchema.parse({})),
+  name: z.string().default(""),
+  description: z.string().default(""),
+  shippingAddress: AddressSchema.optional(),
+  billingAddress: AddressSchema.optional(),
+  shippingMethod: ShippingMethodSchema.optional(),
+  orderStatus: OrderStatusSchema.default("AwaitingPayment"),
+  inventoryStatus: OrderInventoryStatusSchema.default("Allocated"),
+  paymentInstructions: z.array(PaymentInstructionSchema).default(() => []),
+  cartReference: CartIdentifierSchema.optional().describe("Reference to the cart from which this order was created.")
+});
+export {
+  OrderInventoryStatusSchema,
+  OrderItemSchema,
+  OrderSchema,
+  OrderStatusSchema
+};

package/schemas/models/payment.model.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { BaseModelSchema, ImageSchema } from "./base.model";
-import { CartIdentifierSchema, PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from "./identifiers.model";
+import { 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({
@@ -20,16 +20,7 @@ const PaymentInstructionSchema = BaseModelSchema.extend({
   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,

package/schemas/models/product.model.js

@@ -1,8 +1,11 @@
 import { z } from "zod";
-import { ProductIdentifierSchema } from "./identifiers.model";
+import { ProductIdentifierSchema, SKUIdentifierSchema } from "./identifiers.model";
 import { BaseModelSchema } from "./base.model";
 const SKUSchema = z.looseObject({
-  identifier: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({}))
+  identifier: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
+  /*    name: z.string().default(''),
+      slug: z.string().default(''),
+      image: ImageSchema.default(() => ImageSchema.parse({})), */
 });
 const ProductAttributeSchema = z.looseObject({
   id: z.string(),

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

@@ -1,15 +1,37 @@
 import z from "zod";
 import { ShippingMethodIdentifierSchema } from "./identifiers.model";
 import { MonetaryAmountSchema } from "./price.model";
-import { ImageSchema } from "./base.model";
+import { BaseModelSchema, ImageSchema } from "./base.model";
+import { AddressSchema } from "./profile.model";
+const PickupPointSchema = z.looseObject({
+  identifier: z.object({
+    key: z.string().default("").nonoptional()
+  }).default(() => ({ key: "" })),
+  name: z.string().default(""),
+  description: z.string().default(""),
+  address: AddressSchema.default(() => AddressSchema.parse({})),
+  openingHours: z.string().default("").optional().describe('The opening hours of the pickup point, if applicable. This could be a string like "Mon-Fri 9am-5pm".'),
+  contactPhone: z.string().default("").optional().describe("The contact phone number for the pickup point, if applicable."),
+  contactEmail: z.string().default("").optional().describe("The contact email for the pickup point, if applicable."),
+  instructions: z.string().default("").optional().describe("Any special instructions for picking up from this point.")
+});
 const ShippingMethodSchema = z.looseObject({
   identifier: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
   name: z.string().default(""),
   description: z.string().default(""),
   logo: ImageSchema.optional(),
   price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
-  deliveryTime: z.string().default("")
+  deliveryTime: z.string().default(""),
+  carrier: z.string().default("").optional()
+});
+const ShippingInstructionSchema = BaseModelSchema.extend({
+  shippingMethod: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
+  pickupPoint: z.string().default("").describe("An optional pickup point for the shipping method. This could be a physical store, a locker, or similar. If not set, it means home delivery to the shipping address."),
+  instructions: z.string().default("").describe("Optional instructions for the shipping. This could be delivery instructions, or similar."),
+  consentForUnattendedDelivery: z.boolean().default(false).describe("Indicates if the customer has given consent for unattended delivery, if applicable.")
 });
 export {
+  PickupPointSchema,
+  ShippingInstructionSchema,
   ShippingMethodSchema
 };

package/schemas/mutations/checkout.mutation.js

@@ -0,0 +1,36 @@
+import z from "zod";
+import { CartIdentifierSchema, AddressSchema, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, ShippingInstructionSchema } from "../models";
+import { BaseMutationSchema } from "./base.mutation";
+const CheckoutMutationInitiateCheckoutSchema = BaseMutationSchema.extend({
+  cart: CartIdentifierSchema.required(),
+  billingAddress: AddressSchema.omit({ identifier: true }).optional(),
+  notificationEmail: z.string().optional(),
+  notificationPhone: z.string().optional()
+});
+const CheckoutMutationSetShippingAddressSchema = BaseMutationSchema.extend({
+  checkout: CartIdentifierSchema.required(),
+  shippingAddress: AddressSchema.omit({ identifier: true }).required()
+});
+const CheckoutMutationFinalizeCheckoutSchema = BaseMutationSchema.extend({
+  checkout: CartIdentifierSchema.required()
+});
+const CheckoutMutationAddPaymentInstruction = BaseMutationSchema.extend({
+  paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+  checkout: CartIdentifierSchema.required()
+});
+const CheckoutMutationRemovePaymentInstruction = BaseMutationSchema.extend({
+  paymentInstruction: PaymentInstructionIdentifierSchema.required(),
+  checkout: CartIdentifierSchema.required()
+});
+const CheckoutMutationSetShippingInstruction = BaseMutationSchema.extend({
+  shippingInstruction: ShippingInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+  checkout: CartIdentifierSchema.required()
+});
+export {
+  CheckoutMutationAddPaymentInstruction,
+  CheckoutMutationFinalizeCheckoutSchema,
+  CheckoutMutationInitiateCheckoutSchema,
+  CheckoutMutationRemovePaymentInstruction,
+  CheckoutMutationSetShippingAddressSchema,
+  CheckoutMutationSetShippingInstruction
+};

package/schemas/mutations/index.js

@@ -1,6 +1,5 @@
 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";
@@ -8,3 +7,4 @@ export * from "./price.mutation";
 export * from "./product.mutation";
 export * from "./profile.mutation";
 export * from "./search.mutation";
+export * from "./checkout.mutation";

package/schemas/queries/checkout.query.js

@@ -0,0 +1,16 @@
+import { BaseQuerySchema } from "./base.query";
+import { CheckoutIdentifierSchema } from "../models/identifiers.model";
+const CheckoutQueryByIdSchema = BaseQuerySchema.extend({
+  identifier: CheckoutIdentifierSchema.required()
+});
+const CheckoutQueryForAvailableShippingMethodsSchema = BaseQuerySchema.extend({
+  checkout: CheckoutIdentifierSchema.required()
+});
+const CheckoutQueryForAvailablePaymentMethodsSchema = BaseQuerySchema.extend({
+  checkout: CheckoutIdentifierSchema.required()
+});
+export {
+  CheckoutQueryByIdSchema,
+  CheckoutQueryForAvailablePaymentMethodsSchema,
+  CheckoutQueryForAvailableShippingMethodsSchema
+};

package/schemas/queries/index.js

@@ -1,6 +1,5 @@
 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";
@@ -10,3 +9,5 @@ export * from "./product.query";
 export * from "./profile.query";
 export * from "./search.query";
 export * from "./store.query";
+export * from "./order.query";
+export * from "./checkout.query";

package/schemas/queries/order.query.js

@@ -0,0 +1,8 @@
+import { BaseQuerySchema } from "./base.query";
+import { OrderIdentifierSchema } from "../models/identifiers.model";
+const OrderQueryByIdSchema = BaseQuerySchema.extend({
+  order: OrderIdentifierSchema.required()
+});
+export {
+  OrderQueryByIdSchema
+};

package/schemas/queries/product.query.js

@@ -1,12 +1,17 @@
 import { z } from "zod";
 import { BaseQuerySchema } from "./base.query";
+import { SKUIdentifierSchema } from "../models";
 const ProductQueryBySlugSchema = BaseQuerySchema.extend({
   slug: z.string()
 });
 const ProductQueryByIdSchema = BaseQuerySchema.extend({
   id: z.string()
 });
+const ProductQueryBySKUSchema = BaseQuerySchema.extend({
+  sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({}))
+});
 export {
   ProductQueryByIdSchema,
+  ProductQueryBySKUSchema,
   ProductQueryBySlugSchema
 };

package/src/client/client.d.ts

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

package/src/providers/checkout.provider.d.ts

@@ -0,0 +1,135 @@
+import type { Checkout, PaymentMethod, ShippingMethod } from "../schemas/models";
+import type { RequestContext } from "../schemas/session.schema";
+import { BaseProvider } from "./base.provider";
+import type { CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationSetShippingAddress, CheckoutMutationAddPaymentInstruction, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingInstruction } from "../schemas/mutations/checkout.mutation";
+import type { CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods } from "../schemas/queries";
+export declare abstract class CheckoutProvider<T extends Checkout = Checkout> extends BaseProvider<T> {
+    /**
+     * This starts a new checkout session for the given cart. The checkout might duplicate the cart, or just reference it, depending on implementation, but changes to the cart,
+     * is not reflected in the checkout, and vice versa. The checkout is a snapshot of the cart at the time of initiation.
+     * The checkout will typically copy over addresses from the user profile, if available, or from the anonymous profile in the session.
+     *
+     * Usecase: User has filled out cart, and is ready to checkout. You call this to create a checkout object, that you can then use to set shipping method, payment method etc.
+     * @param cartId The cart you are trying to checkout
+     * @param billingAddress the billing/shipping address to start with. This affects available shipping methods, and may be required by some payment providers.
+     * @param reqCtx
+     */
+    abstract initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout, reqCtx: RequestContext): Promise<T>;
+    /**
+     * Fetches an existing checkout by its identifier.
+     *
+     * Usecase: User has navigated to the checkout page, or reloaded on it , or has been redirected back from the payment provider.
+     * @param payload
+     * @param reqCtx
+     */
+    abstract getById(payload: CheckoutQueryById, reqCtx: RequestContext): Promise<T | null>;
+    /**
+     * Updates the shipping address for the checkout and recalculates the shipping methods and totals.
+     *
+     * Usecase: User has chosen home delivery and you have allowed them to change the address on the checkout page.
+     *
+     * NOTE: Unsure this is really needed.
+     * @param shippingAddress The updated shipping address. Note: This may also be the billing address, if your store does not differentiate.
+     */
+    abstract setShippingAddress(payload: CheckoutMutationSetShippingAddress, reqCtx: RequestContext): Promise<T>;
+    /**
+     * Returns all available shipping methods for the given checkout. This will typically depend on the shipping address, and possibly also the items in the checkout.
+     *
+     * Usecase: User has filled out shipping address, and you need to show available shipping methods.
+     *
+     * @param checkoutId The checkout you want to get shipping methods for.
+     * @param reqCtx
+     */
+    abstract getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods, reqCtx: RequestContext): Promise<ShippingMethod[]>;
+    /**
+     * Returns all available payment methods for the given checkout. This will typically depend mostly on the billing address and jurisdiction.
+     *
+     * Usecase: User has chosen shipping method, and you need to show available payment methods.
+     *
+     * @param checkoutId The checkout you want to get payment methods for.
+     * @param reqCtx
+     */
+    abstract getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods, reqCtx: RequestContext): Promise<PaymentMethod[]>;
+    /**
+     * Adds a payment instruction to the checkout. This will typically create a payment intent in the payment provider, and return whatever is needed to continue the payment process, e.g. a client secret for Stripe, or a redirect URL for PayPal.
+     *
+     * Usecase: User has chosen a payment method, and you need to start the payment process.
+     */
+    abstract addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction, reqCtx: RequestContext): Promise<T>;
+    /**
+     * Removes a payment instruction from the checkout. This will typically void the payment intent in the payment provider, and remove the payment instruction from the checkout.
+     *
+     * Usecase: User has decided to change payment method, or has cancelled the payment process.
+     * @param paymentInstructionId
+     */
+    abstract removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction, reqCtx: RequestContext): Promise<T>;
+    /**
+     * Sets the shipping method and optional pickup point for the checkout. The pickup point can be a physical store, a locker, or similar.
+     * If it is unset, it means home delivery to the shipping address.
+     *
+     *
+     * Usecase: record all the users shipping choices, and any special instructions they may have added.
+     *
+     * @param shippingMethodId
+     * @param pickupPoint
+     */
+    abstract setShippingInstruction(payload: CheckoutMutationSetShippingInstruction, reqCtx: RequestContext): Promise<T>;
+    /**
+     * Finalizes the checkout process. This typically involves creating an order from the checkout and processing payment.
+     *
+     * Usecase: User has completed all necessary steps in the checkout process and is ready to place the order.
+     *
+     * @param payload
+     * @param reqCtx
+     */
+    abstract finalizeCheckout(payload: CheckoutMutationFinalizeCheckout, reqCtx: RequestContext): Promise<T>;
+}
+/**
+ *
+ *
+ * How would this be used?
+ * // navigated to /payment
+ *
+ * const cart = await cartProvider.getById({id: 'cart-123'}, reqCtx);
+ *
+ * let address = null;
+ * if (reqCtx.identity.isAuthenticated) {
+ *  const profile = await profileProvider.getByUserId({userId: reqCtx.identity.userId}, reqCtx);
+ *   address = profile?.addresses?.[0];
+ * }
+ * if (!address) {
+ *    address = reqCtx.session.anonymousProfile?.addresses?.[0];
+ * }
+ *
+ * // ok we are ready for checkout...
+ * const checkout = await checkoutProvider.initiateCheckoutForCart(cart.identifier, address, reqCtx);
+ *
+ * const paymentMethods = await paymentProvider.getAvailablePaymentMethods(checkout, reqCtx);
+ * const shippingMethods = await shippingProvider.getAvailableShippingMethods(checkout, reqCtx);
+ *
+ *
+ * onShippingSelected = async (shippingMethodId, pickupPoint) => {
+ *   const checkout = await checkoutProvider.setShippingMethod(checkout.identifier, shippingMethodId, pickupPoint);
+ *   return checkout;
+ * }
+ *
+ * onPaymentSelected = async (paymentMethodId) => {
+ *   const checkout = await checkoutProvider.addPaymentInstruction(checkout.identifier, paymentMethodId);
+ *   return checkout;
+ * }
+ *
+ * if (checkout.paymentInstructions.length === 0) {
+ *    // show payment method selection
+ *     return <PaymentMethodSelection methods={paymentMethods} onSelect={onPaymentSelected} />
+ *
+ * } else {
+ * if (checkout.paymentInstructions[0].status !== 'Authorized') {
+ *    const pi = checkout.paymentInstructions[0];
+ *    if (pi.provider === 'stripe') {
+ *         return new StripeForm(pi.protocolData.find(x => x.key === 'clientSecret').value, onPaymentAuthorized);
+ *    } else if (pi.provider === 'adyen') {
+ *         return new RedirectTo(pi.protocolData.find(x => x.key === 'punchoutUrl').value);
+ *    }
+ *   }
+ * })
+ */

package/src/providers/index.d.ts

@@ -1,8 +1,8 @@
 export * from './analytics.provider';
 export * from './base.provider';
-export * from './cart-payment.provider';
 export * from './cart.provider';
 export * from './category.provider';
+export * from './checkout.provider';
 export * from './identity.provider';
 export * from './inventory.provider';
 export * from './price.provider';
@@ -10,3 +10,4 @@ export * from './product.provider';
 export * from './profile.provider';
 export * from './search.provider';
 export * from './store.provider';
+export * from './order.provider';