@reactionary/source 0.0.48 → 0.0.51

package/core/src/client/client.ts

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

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

@@ -0,0 +1,156 @@
+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 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
+   */
+  public 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
+   */
+  public 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.
+   */
+  public 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
+   */
+  public 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
+   */
+  public 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.
+   */
+  public 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
+   */
+  public 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
+   */
+  public 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
+   */
+  public 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/core/src/providers/index.ts

@@ -1,12 +1,13 @@
 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';
 export * from './product.provider';
 export * from './profile.provider';
 export * from './search.provider';
-export * from './store.provider';
+export * from './store.provider';
+export * from './order.provider'

package/core/src/providers/order.provider.ts

@@ -0,0 +1,31 @@
+import { BaseProvider } from "./base.provider";
+import type { RequestContext } from "../schemas/session.schema";
+import type { Order } from "../schemas/models";
+import type { OrderQueryById } from "../schemas/queries";
+
+export abstract class OrderProvider<
+  T extends Order = Order
+> extends BaseProvider<T> {
+
+  /**
+   * Get order by ID.
+   *
+   * Usecase: Fetch order after checkout, to check if we are fully paid and can continue to order confirmation page.
+   * @param payload
+   * @param session
+   */
+  public abstract getById(payload: OrderQueryById, reqCtx: RequestContext): Promise<T>;
+
+  protected createEmptyOrder(): T {
+    const order = this.newModel();
+    order.meta = { placeholder: true, cache: { hit: true, key: 'empty-order' } };
+    order.identifier = { key: '' };
+    return order;
+  }
+
+  protected override getResourceName(): string {
+    return 'order';
+  }
+}
+
+

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

@@ -1,14 +1,14 @@
 import type { Product } from '../schemas/models/product.model';
 import { BaseProvider } from './base.provider';
 import type { RequestContext } from '../schemas/session.schema';
-import type { ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
+import type { ProductQueryById, ProductQueryBySKU, ProductQueryBySlug } from '../schemas/queries/product.query';
 
 export abstract class ProductProvider<
   T extends Product = Product
 > extends BaseProvider<T> {
   public abstract getById(payload: ProductQueryById, reqCtx: RequestContext): Promise<T>;
   public abstract getBySlug(payload: ProductQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
-
+  public abstract getBySKU(payload: ProductQueryBySKU | ProductQueryBySKU[], reqCtx: RequestContext): Promise<T>;
 
   protected createEmptyProduct(id: string): T {
     const product = this.newModel();

package/core/src/schemas/capabilities.schema.ts

@@ -6,7 +6,8 @@ export 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/core/src/schemas/models/cart.model.ts

@@ -4,22 +4,9 @@ import { BaseModelSchema } from './base.model';
 import { MonetaryAmountSchema } from './price.model';
 import { AddressSchema } from './profile.model';
 import { ShippingMethodSchema } from './shipping-method.model';
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from './cost.model';
 
-export 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.'),
-});
 
-export 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 const CartItemSchema = z.looseObject({
@@ -41,14 +28,8 @@ export const CartSchema = BaseModelSchema.extend({
     description: z.string().default(''),
 
 
-    shippingAddress: AddressSchema.optional(),
-    billingAddress: AddressSchema.optional(),
-    shippingMethod: ShippingMethodSchema.optional(),
 });
 
 
-
-export type CostBreakDown = z.infer<typeof CostBreakDownSchema>;
-export type ItemCostBreakdown = z.infer<typeof ItemCostBreakdownSchema>;
 export type CartItem = z.infer<typeof CartItemSchema>;
 export type Cart = z.infer<typeof CartSchema>;

package/core/src/schemas/models/checkout.model.ts

@@ -0,0 +1,68 @@
+
+
+import { z } from 'zod';
+import { BaseModelSchema, ImageSchema } from './base.model';
+import { CartIdentifierSchema, CheckoutIdentifierSchema, CheckoutItemIdentifierSchema, FulfillmentCenterIdentifierSchema, OrderIdentifierSchema, ProductIdentifierSchema, SKUIdentifierSchema } from './identifiers.model';
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from './cost.model';
+import { AddressSchema } from './profile.model';
+import { ShippingInstructionSchema, ShippingMethodSchema } from './shipping-method.model';
+import { PaymentInstructionSchema } from './payment.model';
+
+
+
+export const CheckoutItemSchema = z.looseObject({
+    identifier: CheckoutItemIdentifierSchema.default(() => CheckoutItemIdentifierSchema.parse({})),
+    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+    quantity: z.number().default(0),
+    price: ItemCostBreakdownSchema.default(() => ItemCostBreakdownSchema.parse({})),
+});
+
+
+/**
+ * A checkout represents  the data entity that is used to create an order.
+ * The checkout is "stable", meaning you cannot change items or quantities on it. Only shipping, billing, and payment details.
+ *
+ * This means, a cart is never checked out. Rather you provide the cart and other fixed info to the checkout, and from there you get
+ * payments and shipping methods.
+ */
+export 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 type CheckoutItem = z.infer<typeof CheckoutItemSchema>;
+export type Checkout = z.infer<typeof CheckoutSchema>;

package/core/src/schemas/models/cost.model.ts

@@ -0,0 +1,21 @@
+import z from "zod";
+import { MonetaryAmountSchema } from "./price.model";
+
+export 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.'),
+});
+
+export 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 type CostBreakDown = z.infer<typeof CostBreakDownSchema>;
+export type ItemCostBreakdown = z.infer<typeof ItemCostBreakdownSchema>;

package/core/src/schemas/models/identifiers.model.ts

@@ -52,6 +52,15 @@ export const OrderItemIdentifierSchema = z.looseObject({
   key: z.string().default('').nonoptional(),
 });
 
+
+export const CheckoutIdentifierSchema = z.looseObject({
+    key: z.string().default('').nonoptional()
+});
+
+export const CheckoutItemIdentifierSchema = z.looseObject({
+    key: z.string().default('').nonoptional()
+});
+
 /**
  * The target store the user is interacting with. Can change over time, and is not necessarily the same as the default store.
  */
@@ -75,7 +84,7 @@ export const IdentityIdentifierSchema = z.looseObject({
 });
 
 export const ShippingMethodIdentifierSchema = z.looseObject({
-  key: z.string().default('').nonoptional(),
+    key: z.string().default('').nonoptional(),
 });
 
 export const PaymentMethodIdentifierSchema = z.looseObject({
@@ -92,6 +101,10 @@ export const PaymentInstructionIdentifierSchema = z.looseObject({
   key: z.string().default('').nonoptional(),
 });
 
+export const PickupPointIdentifierSchema = z.looseObject({
+    key: z.string().default('').nonoptional()
+});
+
 export type ProductIdentifier = z.infer<typeof ProductIdentifierSchema>;
 export type SearchIdentifier = z.infer<typeof SearchIdentifierSchema>;
 export type FacetIdentifier = z.infer<typeof FacetIdentifierSchema>;
@@ -118,6 +131,10 @@ export type PaymentInstructionIdentifier = z.infer<
 >;
 export type OrderIdentifier = z.infer<typeof OrderIdentifierSchema>;
 export type OrderItemIdentifier = z.infer<typeof OrderItemIdentifierSchema>;
+
+export type CheckoutIdentifier = z.infer<typeof CheckoutIdentifierSchema>;
+export type CheckoutItemIdentifier = z.infer<typeof CheckoutItemIdentifierSchema>;
+export type PickupPointIdentifier = z.infer<typeof PickupPointIdentifierSchema>;
 export type StoreIdentifier = z.infer<typeof StoreIdentifierSchema>;
 
 export type IdentifierType =
@@ -138,4 +155,8 @@ export type IdentifierType =
   | AddressIdentifier
   | PaymentInstructionIdentifier
   | OrderIdentifier
-  | OrderItemIdentifier;
+  | OrderItemIdentifier
+  | CheckoutIdentifier
+  | CheckoutItemIdentifier
+  | StoreIdentifier
+  | PickupPointIdentifier;

package/core/src/schemas/models/identity.model.ts

@@ -3,12 +3,15 @@ import { BaseModelSchema } from './base.model';
 import { IdentityIdentifierSchema } from './identifiers.model';
 
 export 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(new Date())
 });
 
 export 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(new Date())
@@ -16,7 +19,7 @@ export const GuestIdentitySchema = BaseModelSchema.extend({
 
 export 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/core/src/schemas/models/index.ts

@@ -12,4 +12,8 @@ export * from './product.model';
 export * from './profile.model';
 export * from './search.model';
 export * from './shipping-method.model';
-export * from './store.model';
+export * from './store.model';
+export * from './order.model';
+export * from './cost.model';
+export * from './checkout.model';
+export * from './payment.model';

package/core/src/schemas/models/order.model.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, PaymentInstructionIdentifierSchema, ProductIdentifierSchema, 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';
+
+export const OrderStatusSchema = z.enum(['AwaitingPayment', 'ReleasedToFulfillment', 'Shipped', 'Cancelled']).default('AwaitingPayment').describe('The current status of the order.');
+export const OrderInventoryStatusSchema = z.enum(['NotAllocated', 'Allocated', 'Backordered', 'Preordered']).default('Allocated').describe('The inventory release status of the order.');
+
+
+export 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.'),
+});
+
+export 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 type OrderItem = z.infer<typeof OrderItemSchema>;
+export type Order = z.infer<typeof OrderSchema>;

package/core/src/schemas/models/payment.model.ts

@@ -1,8 +1,7 @@
 import { z } from 'zod';
 import { BaseModelSchema, ImageSchema } from './base.model';
-import { CartIdentifierSchema, InventoryIdentifierSchema, PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from './identifiers.model';
+import { CartIdentifierSchema, OrderIdentifierSchema, PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from './identifiers.model';
 import { MonetaryAmountSchema } from './price.model';
-import { describe } from 'node:test';
 
 export const PaymentStatusSchema = z.enum(['pending', 'authorized', 'canceled', 'capture', 'partial_capture', 'refunded', 'partial_refund']);
 
@@ -27,15 +26,9 @@ export const PaymentInstructionSchema = BaseModelSchema.extend({
     status: PaymentStatusSchema.default('pending'),
 });
 
-export const CartPaymentInstructionSchema = PaymentInstructionSchema.extend({
-    cart: CartIdentifierSchema.default(() => CartIdentifierSchema.parse({}))
-});
 
-export const OrderPaymentInstructionSchema = PaymentInstructionSchema.extend({
-    order: z.string().default('') // OrderIdentifierSchema
-});
 
-export type CartPaymentInstruction = z.infer<typeof CartPaymentInstructionSchema>;
-export type OrderPaymentInstruction = z.infer<typeof OrderPaymentInstructionSchema>;
+
 export type PaymentInstruction = z.infer<typeof PaymentInstructionSchema>;
 export type PaymentStatus = z.infer<typeof PaymentStatusSchema>;
+export type PaymentMethod = z.infer<typeof PaymentMethodSchema>;

package/core/src/schemas/models/product.model.ts

@@ -1,9 +1,12 @@
 import { z } from 'zod';
-import { ProductIdentifierSchema } from './identifiers.model';
-import { BaseModelSchema } from './base.model';
+import { ProductIdentifierSchema, SKUIdentifierSchema } from './identifiers.model';
+import { BaseModelSchema, ImageSchema } from './base.model';
 
 export 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({})), */
 });
 
 export const ProductAttributeSchema = z.looseObject({

package/core/src/schemas/models/shipping-method.model.ts

@@ -1,7 +1,25 @@
 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";
+
+
+
+
+export 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.'),
+});
+
 
 export const ShippingMethodSchema = z.looseObject({
     identifier: ShippingMethodIdentifierSchema.default(() => ShippingMethodIdentifierSchema.parse({})),
@@ -10,5 +28,18 @@ export const ShippingMethodSchema = z.looseObject({
     logo: ImageSchema.optional(),
     price: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})),
     deliveryTime: z.string().default(''),
+    carrier: z.string().default('').optional(),
+});
+
+
+export 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 type ShippingMethod = z.infer<typeof ShippingMethodSchema>;
+export type PickupPoint = z.infer<typeof PickupPointSchema>;
+export type ShippingInstruction = z.infer<typeof ShippingInstructionSchema>;