@reactionary/source 0.0.48 → 0.0.52

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

@@ -0,0 +1,66 @@
+
+
+import { z } from 'zod';
+import { BaseModelSchema } from './base.model.js';
+import { CartIdentifierSchema, CheckoutIdentifierSchema, CheckoutItemIdentifierSchema, OrderIdentifierSchema, SKUIdentifierSchema } from './identifiers.model.js';
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from './cost.model.js';
+import { AddressSchema } from './profile.model.js';
+import { ShippingInstructionSchema } from './shipping-method.model.js';
+import { PaymentInstructionSchema } from './payment.model.js';
+
+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.js";
+
+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

@@ -1,14 +1,17 @@
 import { z } from 'zod';
-import { BaseModelSchema } from './base.model';
-import { IdentityIdentifierSchema } from './identifiers.model';
+import { BaseModelSchema } from './base.model.js';
+import { IdentityIdentifierSchema } from './identifiers.model.js';
 
 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

@@ -1,15 +1,19 @@
-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';
-export * from './store.model';
+export * from './analytics.model.js';
+export * from './base.model.js';
+export * from './cart.model.js';
+export * from './category.model.js';
+export * from './currency.model.js';
+export * from './identifiers.model.js';
+export * from './identity.model.js';
+export * from './inventory.model.js';
+export * from './payment.model.js';
+export * from './price.model.js';
+export * from './product.model.js';
+export * from './profile.model.js';
+export * from './search.model.js';
+export * from './shipping-method.model.js';
+export * from './store.model.js';
+export * from './order.model.js';
+export * from './cost.model.js';
+export * from './checkout.model.js';
+export * from './payment.model.js';

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { BaseModelSchema } from './base.model';
-import { InventoryIdentifierSchema } from './identifiers.model';
+import { BaseModelSchema } from './base.model.js';
+import { InventoryIdentifierSchema } from './identifiers.model.js';
 
 export const InventorySchema = BaseModelSchema.extend({
     identifier: InventoryIdentifierSchema.default(() => InventoryIdentifierSchema.parse({})),

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+import { CartIdentifierSchema, CartItemIdentifierSchema, IdentityIdentifierSchema, SKUIdentifierSchema } from '../models/identifiers.model.js';
+import { BaseModelSchema } from './base.model.js';
+import { AddressSchema } from './profile.model.js';
+import { ShippingMethodSchema } from './shipping-method.model.js';
+import { CostBreakDownSchema, ItemCostBreakdownSchema } from './cost.model.js';
+import { PaymentInstructionSchema } from './payment.model.js';
+
+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 { MonetaryAmountSchema } from './price.model';
-import { describe } from 'node:test';
+import { BaseModelSchema, ImageSchema } from './base.model.js';
+import { PaymentInstructionIdentifierSchema, PaymentMethodIdentifierSchema } from './identifiers.model.js';
+import { MonetaryAmountSchema } from './price.model.js';
 
 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/price.model.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { BaseModelSchema } from './base.model';
-import { PriceIdentifierSchema } from './identifiers.model';
-import { CurrencySchema } from './currency.model';
+import { BaseModelSchema } from './base.model.js';
+import { PriceIdentifierSchema } from './identifiers.model.js';
+import { CurrencySchema } from './currency.model.js';
 
 export const MonetaryAmountSchema = z.looseObject({
     value: z.number().default(0).describe('The monetary amount in decimal-precision.'),

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.js';
+import { BaseModelSchema } from './base.model.js';
 
 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/profile.model.ts

@@ -1,6 +1,6 @@
 import z from "zod";
-import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model";
-import { BaseModelSchema } from "./base.model";
+import { AddressIdentifierSchema, IdentityIdentifierSchema } from "./identifiers.model.js";
+import { BaseModelSchema } from "./base.model.js";
 
 export const AddressSchema = BaseModelSchema.extend({
     identifier: AddressIdentifierSchema.default(() => AddressIdentifierSchema.parse({})),

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

@@ -1,7 +1,6 @@
 import { z } from 'zod';
-import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSchema, SearchIdentifierSchema } from './identifiers.model';
-import { BaseModelSchema, createPaginatedResponseSchema } from './base.model';
-import { create } from 'domain';
+import { ProductIdentifierSchema, FacetValueIdentifierSchema, FacetIdentifierSchema, SearchIdentifierSchema } from './identifiers.model.js';
+import { BaseModelSchema } from './base.model.js';
 
 export const SearchResultProductSchema = z.looseObject({
     identifier: ProductIdentifierSchema.default(ProductIdentifierSchema.parse({})),

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 { ShippingMethodIdentifierSchema } from "./identifiers.model.js";
+import { MonetaryAmountSchema } from "./price.model.js";
+import { BaseModelSchema, ImageSchema } from "./base.model.js";
+import { AddressSchema } from "./profile.model.js";
+
+
+
+
+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>;

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { BaseModelSchema } from './base.model';
-import { FulfillmentCenterIdentifierSchema, StoreIdentifierSchema } from './identifiers.model';
+import { BaseModelSchema } from './base.model.js';
+import { FulfillmentCenterIdentifierSchema, StoreIdentifierSchema } from './identifiers.model.js';
 
 export const StoreSchema = BaseModelSchema.extend({
     identifier: StoreIdentifierSchema.default(() => StoreIdentifierSchema.parse({})),

package/core/src/schemas/mutations/analytics.mutation.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation';
-import { ProductIdentifierSchema, SearchIdentifierSchema } from '../models/identifiers.model';
+import { BaseMutationSchema } from './base.mutation.js';
+import { ProductIdentifierSchema, SearchIdentifierSchema } from '../models/identifiers.model.js';
 
 export const AnalyticsMutationSearchEventSchema = BaseMutationSchema.extend({
     mutation: z.literal('search'),

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

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation';
-import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifierSchema, SKUIdentifierSchema } from '../models/identifiers.model';
-import { AddressSchema } from '../models/profile.model';
-import { CurrencySchema } from '../models/currency.model';
-import { MonetaryAmountSchema } from '../models/price.model';
+import { BaseMutationSchema } from './base.mutation.js';
+import { CartIdentifierSchema, CartItemIdentifierSchema, PaymentMethodIdentifierSchema, ShippingMethodIdentifierSchema, SKUIdentifierSchema } from '../models/identifiers.model.js';
+import { AddressSchema } from '../models/profile.model.js';
+import { CurrencySchema } from '../models/currency.model.js';
+import { MonetaryAmountSchema } from '../models/price.model.js';
 
 export const CartMutationItemAddSchema = BaseMutationSchema.extend({
     cart: CartIdentifierSchema.nonoptional(),

package/core/src/schemas/mutations/checkout.mutation.ts

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

package/core/src/schemas/mutations/identity.mutation.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation';
+import { BaseMutationSchema } from './base.mutation.js';
 
 export const IdentityMutationLoginSchema = BaseMutationSchema.extend({
     username: z.string(),

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

@@ -1,10 +1,10 @@
-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 './profile.mutation';
-export * from './search.mutation';
+export * from './analytics.mutation.js';
+export * from './base.mutation.js';
+export * from './cart.mutation.js';
+export * from './identity.mutation.js';
+export * from './inventory.mutation.js';
+export * from './price.mutation.js';
+export * from './product.mutation.js';
+export * from './profile.mutation.js';
+export * from './search.mutation.js';
+export * from './checkout.mutation.js';

package/core/src/schemas/mutations/profile.mutation.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation';
+import { BaseMutationSchema } from './base.mutation.js';
 
 export const ProfileMutationUpdateSchema = BaseMutationSchema.extend({
     email: z.email().default('base@example.com'),

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

@@ -1,6 +1,6 @@
 import type { z } from 'zod';
-import { BaseQuerySchema } from './base.query';
-import { CartIdentifierSchema } from '../models/identifiers.model';
+import { BaseQuerySchema } from './base.query.js';
+import { CartIdentifierSchema } from '../models/identifiers.model.js';
 
 export const CartQueryByIdSchema = BaseQuerySchema.extend({
     cart: CartIdentifierSchema.required()

package/core/src/schemas/queries/category.query.ts

@@ -1,7 +1,7 @@
 import z from "zod";
-import { CategoryIdentifierSchema } from "../models/identifiers.model";
-import { BaseQuerySchema } from "./base.query";
-import { PaginationOptionsSchema } from "../models/base.model";
+import { CategoryIdentifierSchema } from "../models/identifiers.model.js";
+import { BaseQuerySchema } from "./base.query.js";
+import { PaginationOptionsSchema } from "../models/base.model.js";
 
 export const CategoryQueryById = BaseQuerySchema.extend({
     id: CategoryIdentifierSchema.default(() => CategoryIdentifierSchema.parse({})),

package/core/src/schemas/queries/checkout.query.ts

@@ -0,0 +1,22 @@
+import type { z } from 'zod';
+import { BaseQuerySchema } from './base.query.js';
+import { CheckoutIdentifierSchema } from '../models/identifiers.model.js';
+
+export const CheckoutQueryByIdSchema = BaseQuerySchema.extend({
+    identifier: CheckoutIdentifierSchema.required()
+});
+
+
+export const CheckoutQueryForAvailableShippingMethodsSchema = BaseQuerySchema.extend({
+    checkout: CheckoutIdentifierSchema.required()
+});
+
+export const CheckoutQueryForAvailablePaymentMethodsSchema = BaseQuerySchema.extend({
+    checkout: CheckoutIdentifierSchema.required()
+});
+
+
+
+export type CheckoutQueryForAvailableShippingMethods = z.infer<typeof CheckoutQueryForAvailableShippingMethodsSchema>;
+export type CheckoutQueryForAvailablePaymentMethods = z.infer<typeof CheckoutQueryForAvailablePaymentMethodsSchema>;
+export type CheckoutQueryById = z.infer<typeof CheckoutQueryByIdSchema>;

package/core/src/schemas/queries/identity.query.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod';
-import { BaseQuerySchema } from './base.query';
+import { BaseQuerySchema } from './base.query.js';
 
 export const IdentityQuerySelfSchema = BaseQuerySchema.extend({
 

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

@@ -1,12 +1,13 @@
-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';
-export * from './inventory.query';
-export * from './price.query';
-export * from './product.query';
-export * from './profile.query';
-export * from './search.query';
-export * from './store.query';
+export * from './analytics.query.js';
+export * from './base.query.js';
+export * from './cart.query.js';
+export * from './category.query.js';
+export * from './identity.query.js';
+export * from './inventory.query.js';
+export * from './price.query.js';
+export * from './product.query.js';
+export * from './profile.query.js';
+export * from './search.query.js';
+export * from './store.query.js';
+export * from './order.query.js';
+export * from './checkout.query.js';

package/core/src/schemas/queries/inventory.query.ts

@@ -1,6 +1,6 @@
 import type { z } from 'zod';
-import { BaseQuerySchema } from './base.query';
-import { FulfillmentCenterIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
+import { BaseQuerySchema } from './base.query.js';
+import { FulfillmentCenterIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model.js';
 
 export const InventoryQueryBySKUSchema = BaseQuerySchema.extend({
     sku: ProductIdentifierSchema.default(() => ProductIdentifierSchema.parse({})).nonoptional(),

package/core/src/schemas/queries/order.query.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod';
+import { BaseQuerySchema } from './base.query.js';
+import { OrderIdentifierSchema } from '../models/identifiers.model.js';
+
+export const OrderQueryByIdSchema = BaseQuerySchema.extend({
+    order: OrderIdentifierSchema.required()
+});
+
+export type OrderQueryById = z.infer<typeof OrderQueryByIdSchema>;

package/core/src/schemas/queries/price.query.ts

@@ -1,6 +1,6 @@
 import type { z } from 'zod';
-import { BaseQuerySchema } from './base.query';
-import { SKUIdentifierSchema } from '../models/identifiers.model';
+import { BaseQuerySchema } from './base.query.js';
+import { SKUIdentifierSchema } from '../models/identifiers.model.js';
 
 export const PriceQueryBySkuSchema = BaseQuerySchema.extend({
     sku: SKUIdentifierSchema.required(),