@reactionary/source 0.0.41 → 0.0.42

package/.env-template

@@ -1,8 +1,11 @@
-COMMERCETOOLS_API_URL=https://api.europe-west1.gcp.commercetools.com
-COMMERCETOOLS_AUTH_URL=https://auth.europe-west1.gcp.commercetools.com
-COMMERCETOOLS_CLIENT_ID=
-COMMERCETOOLS_CLIENT_SECRET=
-COMMERCETOOLS_PROJECT_KEY=
+CTP_PROJECT_KEY=
+CTP_CLIENT_SECRET=
+CTP_CLIENT_ID=
+CTP_AUTH_URL=https://auth.europe-west1.gcp.commercetools.com
+CTP_API_URL=https://api.europe-west1.gcp.commercetools.com
+CTP_SCOPES=
+
+
 
 OTEL_SERVICE_NAME=reactionary
 OTEL_LOG_LEVEL=info

package/README.md

@@ -37,3 +37,44 @@ The following is a short list of commonly used terms and phrases, to keep guessi
 - *Fake:* an implementation that provides a functional response, but with in a limited capacity. A fake provider may, for example, provide *Cart* functionality, but only store it in-memory and throw it away on a whim. As such it can be used for prototyping, but never for a production scenario.
 - *Product Analytics:* structured analytics that relate to how the the product is being used.
 - *Microsite:* an application of a limited scope. It may focus solely on this limited functionality, making it ideal for demonstration purposes.
+
+
+
+## TODO:
+
+
+
+### Core
+- [ ] Figure a way to get a correlation id from the caller
+- [ ] Maybe rework session so its not languageContext but requestContext, and this could have the correlation id in it?
+
+
+### Search
+- [ ] Add support for filters, not just facets
+
+### Marketing
+- [ ] Add marketing provider (input: (name, url, user, segments, productid, categoryid) => output { Array<Product | Category | Image | Text>}
+
+
+### Inventory
+- [ ] Invent and document some notational standard for cannel-key to purpose.
+- [ ] Be traced and cached
+
+### Profile
+- [ ] Be able to register new account
+- [ ] Create profile provider
+
+
+### Organization
+- [ ] Create organization provider
+- [ ] Create business user provider
+- [ ] Create role provider
+
+### Cart
+- [ ] Add B2B/organization identifier
+
+### Price
+- [ ] Add list price
+
+### Order
+- [ ] Add Order

package/core/src/client/client.ts

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

package/core/src/index.ts

@@ -8,36 +8,11 @@ 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/core/src/providers/cart-payment.provider.ts

@@ -0,0 +1,56 @@
+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 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
+   */
+  public 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
+   */
+  public 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
+   */
+  public abstract cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, session: Session): Promise<T>;
+
+  protected override getResourceName(): string {
+    return 'cart-payment-instruction';
+  }
+}

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

@@ -2,17 +2,141 @@ import { BaseProvider } from "./base.provider";
 import { Cart } from "../schemas/models/cart.model";
 import { CartQueryById } from "../schemas/queries/cart.query";
 import { Session } from "../schemas/session.schema";
-import { CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove } from "../schemas/mutations/cart.mutation";
+import { CartMutationAddPaymentMethod, CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationCheckout, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartMutationRemovePaymentMethod, CartMutationSetBillingAddress, CartMutationSetShippingInfo } from "../schemas/mutations/cart.mutation";
+import { CartIdentifier, OrderIdentifier } from "../schemas/models/identifiers.model";
+import { CartPaymentProvider } from "./cart-payment.provider";
 
 export abstract class CartProvider<
   T extends Cart = Cart
 > extends BaseProvider<T> {
+
+  /**
+   * Get cart by ID.
+   *
+   * Usecase: Unclear, until we support multiple carts per user.
+   * @param payload
+   * @param session
+   */
   public abstract getById(payload: CartQueryById, session: Session): Promise<T>;
+
+
+  /**
+   * Get the active cart id for the user.
+   *
+   * Usecase: Most common usecase during site load, or after login. You want to get the active cart for the user, so you can display it in the minicart.
+   * @param session
+   */
+  public abstract getActiveCartId(session: Session): Promise<CartIdentifier>;
+
+
+  /**
+   * Add item to cart. If no cart exists, create a new one. Returns the updated and recalculated cart.
+   * Does not automatically consolidate items, so if you want to have second add of same item to increase quantity,
+   * you need to handle that in your logic or on the server.
+   *
+   * Usecase: Add item to cart, create cart if none exists.
+   * @param payload
+   * @param session
+   */
   public abstract add(payload: CartMutationItemAdd, session: Session): Promise<T>;
+
+  /**
+   * Remove item from cart. If the cart is empty after removal, delete the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: Remove item from cart, delete cart if empty.
+   * @param payload
+   * @param session
+   */
   public abstract remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
+
+  /**
+   * Change quantity of item in cart. If the cart is empty after change, delete the cart. Returns the updated and recalculated cart.
+   * Changing quantity to 0 is not allowed. Use the remove call instead. This is done to avoid accidental removal of item.
+   * Calls with quantity 0 will just be ignored.
+   *
+   * Usecase: Change quantity of item in cart,  like in a minicart, or in the full cart view.
+   * @param payload
+   * @param session
+   */
   public abstract changeQuantity(payload: CartMutationItemQuantityChange, session: Session): Promise<T>;
 
 
+  /**
+   * Deletes the entire cart.
+   *
+   * Usecase: User wants to empty the cart or something is wrong with the current cart, and you want to clear it out and start fresh.
+   * @param payload
+   * @param session
+   */
+  public abstract deleteCart(payload: CartMutationDeleteCart, session: Session): Promise<T>;
+
+  /**
+   * Sets shipping method and address on the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: User selects shipping method during checkout.
+   * @param payload
+   * @param session
+   */
+  public abstract setShippingInfo(payload: CartMutationSetShippingInfo, session: Session): Promise<T>;
+
+  /**
+   * Sets billing address on the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: User enters billing address during checkout.
+   *
+   * @param payload
+   * @param session
+   */
+  public abstract setBillingAddress(payload: CartMutationSetBillingAddress, session: Session): Promise<T>;
+
+  /**
+   * Applies a coupon code to the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: User applies a coupon code during checkout.
+   * @param payload
+   * @param session
+   */
+  public abstract applyCouponCode(payload: CartMutationApplyCoupon, session: Session): Promise<T>;
+
+
+  /**
+   * Removes a coupon code from the cart. Returns the updated and recalculated cart.
+   *
+   * Usecase: User removes a coupon code during checkout.
+   * @param payload
+   * @param session
+   */
+  public abstract removeCouponCode(payload: CartMutationRemoveCoupon, session: Session): Promise<T>;
+
+
+  /**
+   * Checks out the cart. Returns the order identifier of the newly created order.
+   *
+   * Usecase: User proceeds to checkout.
+   *
+   * @param payload
+   * @param session
+   */
+  public abstract checkout(payload: CartMutationCheckout, session: Session): Promise<OrderIdentifier>;
+
+  /**
+   * Changes the currency of the cart.
+   *
+   * Usecase: User wants to change the currency for his session. This will change the currency of the cart, and recalculate prices.
+   * @param newCurrency
+   * @param session
+   */
+  public abstract changeCurrency(payload: CartMutationChangeCurrency, session: Session): Promise<T>;
+
+
+
+  protected createEmptyCart(): T {
+    const cart = this.newModel();
+    cart.meta = { placeholder: true, cache: { hit: true, key: 'empty-cart' } };
+    cart.identifier = { key: '' };
+    return cart;
+  }
+
   protected override getResourceName(): string {
     return 'cart';
   }

package/core/src/providers/index.ts

@@ -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/core/src/providers/price.provider.ts

@@ -40,7 +40,7 @@ export abstract class PriceProvider<
    * @param currency
    * @returns
    */
-  protected getEmptyPriceResult(sku: string, currency: Currency): T {
+  protected createEmptyPriceResult(sku: string, currency: Currency): T {
     const base = this.newModel();
     base.identifier = {
       sku: { key: sku }

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

@@ -7,8 +7,20 @@ export abstract class ProductProvider<
   T extends Product = Product
 > extends BaseProvider<T> {
   public abstract getById(payload: ProductQueryById, session: Session): Promise<T>;
-  public abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T>;
+  public abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T | null>;
 
+
+  protected createEmptyProduct(id: string): T {
+    const product = this.newModel();
+    product.identifier = { key: id };
+    product.meta.placeholder = true;
+    return product;
+  }
+
+  /**
+   * The resource name, used for caching and logging.
+   * @returns
+   */
   protected override getResourceName(): string {
     return 'product';
   }

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

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

@@ -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';
 
 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.'),
@@ -11,7 +13,6 @@ export const CostBreakDownSchema = z.looseObject({
     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 type CostBreakDown = z.infer<typeof CostBreakDownSchema>;
 
 export const ItemCostBreakdownSchema = z.looseObject({
     unitPrice: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The price per single unit of the item.'),
@@ -20,22 +21,34 @@ export const ItemCostBreakdownSchema = z.looseObject({
     totalDiscount: MonetaryAmountSchema.default(() => MonetaryAmountSchema.parse({})).describe('The total discount applied to all units of the item.'),
 });
 
-export type ItemCostBreakdown = z.infer<typeof ItemCostBreakdownSchema>;
 
 export 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({})),
 });
 
 export 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(''),
+
+
+    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/identifiers.model.ts

@@ -40,6 +40,15 @@ export const CategoryIdentifierSchema = z.looseObject({
   key: z.string().default('').nonoptional()
 });
 
+
+export const OrderIdentifierSchema = z.looseObject({
+    key: z.string().default('').nonoptional()
+});
+
+export const OrderItemIdentifierSchema = 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.
  */
@@ -56,6 +65,27 @@ export const InventoryIdentifierSchema = z.looseObject({
     channelId: InventoryChannelIdentifierSchema.default(() => InventoryChannelIdentifierSchema.parse({})),
 });
 
+export const IdentityIdentifierSchema = z.looseObject({
+    userId: z.string().default('').nonoptional()
+});
+
+export const ShippingMethodIdentifier = z.looseObject({
+    key: z.string().default('').nonoptional()
+});
+
+export const PaymentMethodIdentifierSchema = z.looseObject({
+    method: z.string().default('').nonoptional(),
+    name: z.string().default('').nonoptional(),
+    paymentProcessor: z.string().default('').nonoptional()
+});
+
+export const AddressIdentifierSchema = z.looseObject({
+    nickName: z.string().default('').nonoptional()
+});
+
+export const PaymentInstructionIdentifierSchema = z.looseObject({
+    key: z.string().default('').nonoptional()
+});
 
 export type ProductIdentifier = z.infer<typeof ProductIdentifierSchema>;
 export type SearchIdentifier = z.infer<typeof SearchIdentifierSchema>;
@@ -68,6 +98,16 @@ export type CategoryIdentifier = z.infer<typeof CategoryIdentifierSchema>;
 export type WebStoreIdentifier = z.infer<typeof WebStoreIdentifierSchema>;
 export type InventoryIdentifier = z.infer<typeof InventoryIdentifierSchema>;
 export type InventoryChannelIdentifier = z.infer<typeof InventoryChannelIdentifierSchema>;
-
-
-export type IdentifierType = ProductIdentifier | SearchIdentifier | FacetIdentifier | FacetValueIdentifier | CartIdentifier | CartItemIdentifier | PriceIdentifier | CategoryIdentifier | WebStoreIdentifier | InventoryIdentifier;
+export type IdentityIdentifier = z.infer<typeof IdentityIdentifierSchema>;
+export type ShippingMethodIdentifier = z.infer<typeof ShippingMethodIdentifier>;
+export type PaymentMethodIdentifier = z.infer<typeof PaymentMethodIdentifierSchema>;
+export type AddressIdentifier = z.infer<typeof AddressIdentifierSchema>;
+export type PaymentInstructionIdentifier = z.infer<typeof PaymentInstructionIdentifierSchema>;
+export type OrderIdentifier = z.infer<typeof OrderIdentifierSchema>;
+export type OrderItemIdentifier = z.infer<typeof OrderItemIdentifierSchema>;
+
+export type IdentifierType = ProductIdentifier | SearchIdentifier | FacetIdentifier | FacetValueIdentifier
+                            | CartIdentifier | CartItemIdentifier | PriceIdentifier | CategoryIdentifier
+                            | WebStoreIdentifier | InventoryIdentifier | InventoryChannelIdentifier
+                            | IdentityIdentifier | ShippingMethodIdentifier | PaymentMethodIdentifier | AddressIdentifier | PaymentInstructionIdentifier
+                            | OrderIdentifier | OrderItemIdentifier;

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

@@ -1,15 +1,35 @@
 import { z } from 'zod';
 import { BaseModelSchema } from './base.model';
+import { IdentityIdentifierSchema } from './identifiers.model';
 
 export const IdentityTypeSchema = z.enum(["Anonymous", "Guest", "Registered"]);
 
+
+export const ServiceTokenSchema = z.object({
+    service: z.string().default(''),
+    token: z.string().default(''),
+    issued: z.coerce.date().default(new Date()),
+    expiry: z.coerce.date().default(new Date())
+});
+
 export 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(() => new Date().toISOString()),
+    updatedAt: z.string().default(() => 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(new Date()),
     expiry: z.coerce.date().default(new Date())
 });
 
 export type IdentityType = z.infer<typeof IdentityTypeSchema>;
-export type Identity = z.infer<typeof IdentitySchema>;
+export type Identity = z.infer<typeof IdentitySchema>;

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

@@ -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/core/src/schemas/models/payment.model.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { BaseModelSchema, ImageSchema } from './base.model';
+import { CartIdentifierSchema, InventoryIdentifierSchema, 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']);
+
+export const PaymentProtocolDataSchema = z.looseObject({
+    key: z.string().default(''),
+    value: z.string().default(''),
+});
+
+
+export const PaymentMethodSchema = BaseModelSchema.extend({
+    identifier: PaymentMethodIdentifierSchema.default(() => PaymentMethodIdentifierSchema.parse({})),
+    logo: ImageSchema.optional(),
+    description: z.string().default(''),
+    isPunchOut: z.boolean().default(true)
+});
+
+export 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'),
+});
+
+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>;

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

@@ -0,0 +1,34 @@
+import z from "zod";
+import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model";
+
+export 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'),
+});
+
+export 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(() => new Date().toISOString()),
+    updatedAt: z.string().default(() => new Date().toISOString()),
+
+    shippingAddress: AddressSchema.optional(),
+    billingAddress: AddressSchema.optional(),
+
+    alternateShippingAddresses: z.array(AddressSchema).default(() => []),
+});
+
+export type Address = z.infer<typeof AddressSchema>;
+export type Profile = z.infer<typeof ProfileSchema>;

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

@@ -0,0 +1,14 @@
+import z from "zod";
+import { ShippingMethodIdentifier } from "./identifiers.model";
+import { MonetaryAmountSchema } from "./price.model";
+import { ImageSchema } from "./base.model";
+
+export 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(''),
+});
+

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

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