@reactionary/core 0.0.62 → 0.0.63

package/client/client-builder.js

@@ -1,4 +1,7 @@
 import { NoOpCache } from "../cache/noop-cache.js";
+import {
+  RequestContextSchema
+} from "../schemas/session.schema.js";
 class ClientBuilder {
   constructor() {
     this.factories = [];
@@ -7,20 +10,36 @@ class ClientBuilder {
     const newBuilder = new ClientBuilder();
     newBuilder.factories = [...this.factories, factory];
     newBuilder.cache = this.cache;
+    newBuilder.context = this.context;
     return newBuilder;
   }
   withCache(cache) {
     const newBuilder = new ClientBuilder();
     newBuilder.factories = [...this.factories];
     newBuilder.cache = cache;
+    newBuilder.context = this.context;
+    return newBuilder;
+  }
+  withContext(context) {
+    const newBuilder = new ClientBuilder();
+    newBuilder.factories = [...this.factories];
+    newBuilder.cache = this.cache;
+    newBuilder.context = context;
     return newBuilder;
   }
   build() {
     let client = {};
     const sharedCache = this.cache || new NoOpCache();
+    const context = this.context || RequestContextSchema.parse({
+      languageContext: {
+        locale: "en-US",
+        currencyCode: "USD",
+        countryCode: "US"
+      }
+    });
     const mergedAnalytics = [];
     for (const factory of this.factories) {
-      const provider = factory(sharedCache);
+      const provider = factory(sharedCache, context);
       client = {
         ...client,
         ...provider

package/client/client.js

@@ -1,29 +1 @@
 import { RedisCache } from "../cache/redis-cache.js";
-function buildClient(providerFactories, options = {}) {
-  let client = {};
-  const sharedCache = options.cache || new RedisCache();
-  const mergedAnalytics = [];
-  for (const factory of providerFactories) {
-    const provider = factory(sharedCache);
-    client = {
-      ...client,
-      ...provider
-    };
-    if (provider.analytics) {
-      mergedAnalytics.push(...provider.analytics);
-    }
-  }
-  client.analytics = mergedAnalytics;
-  const completeClient = {
-    ...client,
-    cache: sharedCache
-  };
-  return completeClient;
-}
-function createCache() {
-  return new RedisCache();
-}
-export {
-  buildClient,
-  createCache
-};

package/package.json

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

package/providers/base.provider.js

@@ -3,9 +3,10 @@ import {
 } from "../schemas/models/base.model.js";
 import { hasher } from "node-object-hash";
 class BaseProvider {
-  constructor(schema, cache) {
+  constructor(schema, cache, context) {
     this.schema = schema;
     this.cache = cache;
+    this.context = context;
   }
   /**
    * Validates that the final domain model constructed by the provider
@@ -24,11 +25,11 @@ class BaseProvider {
    * Handler for parsing a response from a remote provider and converting it
    * into the typed domain model.
    */
-  parseSingle(_body, reqCtx) {
+  parseSingle(_body) {
     const model = this.newModel();
     return this.assert(model);
   }
-  parsePaginatedResult(_body, reqCtx) {
+  parsePaginatedResult(_body) {
     return createPaginatedResponseSchema(this.schema).parse({});
   }
   generateDependencyIdsForModel(model) {
@@ -45,19 +46,19 @@ class BaseProvider {
     const queryHash = h.hash(query);
     return `${scope}:${queryHash}`;
   }
-  generateCacheKeyPaginatedResult(resultSetName, res, reqCtx) {
+  generateCacheKeyPaginatedResult(resultSetName, res) {
     const type = this.getResourceName();
-    const langPart = reqCtx.languageContext.locale;
-    const currencyPart = reqCtx.languageContext.currencyCode || "default";
-    const storePart = reqCtx.storeIdentifier?.key || "default";
+    const langPart = this.context.languageContext.locale;
+    const currencyPart = this.context.languageContext.currencyCode || "default";
+    const storePart = this.context.storeIdentifier?.key || "default";
     return `${type}-${resultSetName}-paginated|pageNumber:${res.pageNumber}|pageSize:${res.pageSize}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
   }
-  generateCacheKeySingle(identifier, reqCtx) {
+  generateCacheKeySingle(identifier) {
     const type = this.getResourceName();
     const idPart = Object.entries(identifier).map(([k, v]) => `${k}:${v}`).join("#");
-    const langPart = reqCtx.languageContext.locale;
-    const currencyPart = reqCtx.languageContext.currencyCode || "default";
-    const storePart = reqCtx.storeIdentifier?.key || "default";
+    const langPart = this.context.languageContext.locale;
+    const currencyPart = this.context.languageContext.currencyCode || "default";
+    const storePart = this.context.storeIdentifier?.key || "default";
     return `${type}-${idPart}|store:${storePart}|lang:${langPart}|currency:${currencyPart}`;
   }
 }

package/providers/price.provider.js

@@ -8,17 +8,17 @@ class PriceProvider extends BaseProvider {
    * @param currency
    * @returns
    */
-  createEmptyPriceResult(sku, currency) {
+  createEmptyPriceResult(sku) {
     const base = this.newModel();
     base.identifier = {
       variant: { sku }
     };
     base.unitPrice = {
       value: -1,
-      currency
+      currency: this.context.languageContext.currencyCode
     };
     base.meta = {
-      cache: { hit: false, key: `price-${sku}-${currency}` },
+      cache: { hit: false, key: `price-${sku}-${this.context.languageContext.currencyCode}` },
       placeholder: true
     };
     return this.assert(base);

package/schemas/models/identity.model.js

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

package/schemas/session.schema.js

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import { IdentitySchema } from "./models/identity.model.js";
 import { WebStoreIdentifierSchema } from "./models/identifiers.model.js";
 import { CurrencySchema } from "./models/currency.model.js";
 const LanguageContextSchema = z.looseObject({
@@ -14,7 +13,6 @@ const TaxJurisdictionSchema = z.object({
   cityCode: z.string().default("")
 });
 const RequestContextSchema = z.looseObject({
-  identity: IdentitySchema.default(() => IdentitySchema.parse({})).describe("Read/Write. The identity of the current user. Caller is responsible for persisting any changes to the identity"),
   session: SessionSchema.default(() => SessionSchema.parse({})).describe("Read/Write session storage. Caller is responsible for persisting any changes. Providers will prefix own values"),
   languageContext: LanguageContextSchema.default(() => LanguageContextSchema.parse({})).describe("ReadOnly. The language and locale context for the current request."),
   storeIdentifier: WebStoreIdentifierSchema.default(() => WebStoreIdentifierSchema.parse({})).describe("ReadOnly. The identifier of the current web store making the request."),

package/src/client/client-builder.d.ts

@@ -1,12 +1,15 @@
-import type { Cache } from "../cache/cache.interface.js";
-import type { Client } from "./client.js";
-type CapabilityFactory<T> = (cache: Cache) => T;
+import type { Cache } from '../cache/cache.interface.js';
+import type { Client } from './client.js';
+import { type RequestContext } from '../schemas/session.schema.js';
+type CapabilityFactory<T> = (cache: Cache, context: RequestContext) => T;
 type MergeCapabilities<Acc, New> = Omit<Acc, keyof New> & New;
 export declare class ClientBuilder<TClient = object> {
     private factories;
     private cache;
+    private context;
     withCapability<TNew extends Partial<Client>>(factory: CapabilityFactory<TNew>): ClientBuilder<MergeCapabilities<TClient, TNew>>;
     withCache(cache: Cache): ClientBuilder<TClient>;
+    withContext(context: RequestContext): ClientBuilder<TClient>;
     build(): TClient & {
         cache: Cache;
     };

package/src/client/client.d.ts

@@ -20,8 +20,3 @@ export interface Client {
     inventory: InventoryProvider;
     category: CategoryProvider;
 }
-export interface BuildClientOptions {
-    cache?: Cache;
-}
-export declare function buildClient<T extends Partial<Client>>(providerFactories: Array<(cache: Cache) => T>, options?: BuildClientOptions): Required<T>;
-export declare function createCache(): Cache;

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

@@ -11,7 +11,8 @@ import type { IdentifierType } from '../schemas/models/identifiers.model.js';
 export declare abstract class BaseProvider<T extends BaseModel = BaseModel> {
     readonly schema: z.ZodType<T>;
     protected cache: Cache;
-    constructor(schema: z.ZodType<T>, cache: Cache);
+    protected context: RequestContext;
+    constructor(schema: z.ZodType<T>, cache: Cache, context: RequestContext);
     /**
      * Validates that the final domain model constructed by the provider
      * fulfills the schema as defined. This will throw an exception.
@@ -25,12 +26,12 @@ export declare abstract class BaseProvider<T extends BaseModel = BaseModel> {
      * Handler for parsing a response from a remote provider and converting it
      * into the typed domain model.
      */
-    protected parseSingle(_body: unknown, reqCtx: RequestContext): T;
-    protected parsePaginatedResult(_body: unknown, reqCtx: RequestContext): z.infer<ReturnType<typeof createPaginatedResponseSchema<typeof this.schema>>>;
+    protected parseSingle(_body: unknown): T;
+    protected parsePaginatedResult(_body: unknown): z.infer<ReturnType<typeof createPaginatedResponseSchema<typeof this.schema>>>;
     generateDependencyIdsForModel(model: unknown): Array<string>;
     protected generateCacheKeyForQuery(scope: string, query: object): string;
-    protected generateCacheKeyPaginatedResult(resultSetName: string, res: ReturnType<typeof this.parsePaginatedResult>, reqCtx: RequestContext): string;
-    protected generateCacheKeySingle(identifier: IdentifierType, reqCtx: RequestContext): string;
+    protected generateCacheKeyPaginatedResult(resultSetName: string, res: ReturnType<typeof this.parsePaginatedResult>): string;
+    protected generateCacheKeySingle(identifier: IdentifierType): string;
     /**
      * Returns the abstract resource name provided by the remote system.
      */

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

@@ -1,7 +1,6 @@
 import { BaseProvider } from "./base.provider.js";
 import type { Cart } from "../schemas/models/cart.model.js";
 import type { CartQueryById } from "../schemas/queries/cart.query.js";
-import type { RequestContext } from "../schemas/session.schema.js";
 import type { CartMutationApplyCoupon, CartMutationChangeCurrency, CartMutationCheckout, CartMutationDeleteCart, CartMutationItemAdd, CartMutationItemQuantityChange, CartMutationItemRemove, CartMutationRemoveCoupon, CartMutationSetBillingAddress, CartMutationSetShippingInfo } from "../schemas/mutations/cart.mutation.js";
 import type { CartIdentifier, OrderIdentifier } from "../schemas/models/identifiers.model.js";
 export declare abstract class CartProvider<T extends Cart = Cart> extends BaseProvider<T> {
@@ -12,14 +11,14 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract getById(payload: CartQueryById, reqCtx: RequestContext): Promise<T>;
+    abstract getById(payload: CartQueryById): 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
      */
-    abstract getActiveCartId(reqCtx: RequestContext): Promise<CartIdentifier>;
+    abstract getActiveCartId(): 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,
@@ -29,7 +28,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract add(payload: CartMutationItemAdd, reqCtx: RequestContext): Promise<T>;
+    abstract add(payload: CartMutationItemAdd): Promise<T>;
     /**
      * Remove item from cart. If the cart is empty after removal, delete the cart. Returns the updated and recalculated cart.
      *
@@ -37,7 +36,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract remove(payload: CartMutationItemRemove, reqCtx: RequestContext): Promise<T>;
+    abstract remove(payload: CartMutationItemRemove): 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.
@@ -47,7 +46,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract changeQuantity(payload: CartMutationItemQuantityChange, reqCtx: RequestContext): Promise<T>;
+    abstract changeQuantity(payload: CartMutationItemQuantityChange): Promise<T>;
     /**
      * Deletes the entire cart.
      *
@@ -55,7 +54,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract deleteCart(payload: CartMutationDeleteCart, reqCtx: RequestContext): Promise<T>;
+    abstract deleteCart(payload: CartMutationDeleteCart): Promise<T>;
     /**
      * Sets shipping method and address on the cart. Returns the updated and recalculated cart.
      *
@@ -63,7 +62,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract setShippingInfo(payload: CartMutationSetShippingInfo, reqCtx: RequestContext): Promise<T>;
+    abstract setShippingInfo(payload: CartMutationSetShippingInfo): Promise<T>;
     /**
      * Sets billing address on the cart. Returns the updated and recalculated cart.
      *
@@ -72,7 +71,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract setBillingAddress(payload: CartMutationSetBillingAddress, reqCtx: RequestContext): Promise<T>;
+    abstract setBillingAddress(payload: CartMutationSetBillingAddress): Promise<T>;
     /**
      * Applies a coupon code to the cart. Returns the updated and recalculated cart.
      *
@@ -80,7 +79,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract applyCouponCode(payload: CartMutationApplyCoupon, reqCtx: RequestContext): Promise<T>;
+    abstract applyCouponCode(payload: CartMutationApplyCoupon): Promise<T>;
     /**
      * Removes a coupon code from the cart. Returns the updated and recalculated cart.
      *
@@ -88,7 +87,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract removeCouponCode(payload: CartMutationRemoveCoupon, reqCtx: RequestContext): Promise<T>;
+    abstract removeCouponCode(payload: CartMutationRemoveCoupon): Promise<T>;
     /**
      * Checks out the cart. Returns the order identifier of the newly created order.
      *
@@ -97,7 +96,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param payload
      * @param session
      */
-    abstract checkout(payload: CartMutationCheckout, reqCtx: RequestContext): Promise<OrderIdentifier>;
+    abstract checkout(payload: CartMutationCheckout): Promise<OrderIdentifier>;
     /**
      * Changes the currency of the cart.
      *
@@ -105,7 +104,7 @@ export declare abstract class CartProvider<T extends Cart = Cart> extends BasePr
      * @param newCurrency
      * @param session
      */
-    abstract changeCurrency(payload: CartMutationChangeCurrency, reqCtx: RequestContext): Promise<T>;
+    abstract changeCurrency(payload: CartMutationChangeCurrency): Promise<T>;
     protected createEmptyCart(): T;
     protected getResourceName(): string;
 }

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

@@ -1,6 +1,5 @@
 import type { Category } from "../schemas/models/category.model.js";
 import type { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query.js";
-import type { RequestContext } from "../schemas/session.schema.js";
 import { BaseProvider } from "./base.provider.js";
 /**
  * CategoryProvider
@@ -26,7 +25,7 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param id
      * @param session
      */
-    abstract getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T>;
+    abstract getById(payload: CategoryQueryById): Promise<T>;
     /**
      * Gets a single category by its seo slug
      *
@@ -34,7 +33,7 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param slug the slug
      * @param session
      */
-    abstract getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
+    abstract getBySlug(payload: CategoryQueryBySlug): Promise<T | null>;
     /**
      * Gets the breadcrumb path to the category, i.e. all parents up to the root.
      * The returned order is from root to leaf.
@@ -43,7 +42,7 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param id
      * @param session
      */
-    abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]>;
+    abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<T[]>;
     /**
      * Finds all child categories of a given category.
      *
@@ -54,7 +53,7 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param id The ID of the parent category.
      * @param session The session information.
      */
-    abstract findChildCategories(payload: CategoryQueryForChildCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+    abstract findChildCategories(payload: CategoryQueryForChildCategories): Promise<ReturnType<typeof this.parsePaginatedResult>>;
     /**
      * Returns all top categories, i.e. categories without a parent.
      *
@@ -62,6 +61,6 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param paginationOptions
      * @param session
      */
-    abstract findTopCategories(payload: CategoryQueryForTopCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+    abstract findTopCategories(payload: CategoryQueryForTopCategories): Promise<ReturnType<typeof this.parsePaginatedResult>>;
     protected getResourceName(): string;
 }

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

@@ -1,5 +1,4 @@
 import type { Checkout, PaymentMethod, ShippingMethod } from "../schemas/models/index.js";
-import type { RequestContext } from "../schemas/session.schema.js";
 import { BaseProvider } from "./base.provider.js";
 import type { CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout, CheckoutMutationSetShippingAddress, CheckoutMutationAddPaymentInstruction, CheckoutMutationRemovePaymentInstruction, CheckoutMutationSetShippingInstruction } from "../schemas/mutations/checkout.mutation.js";
 import type { CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods } from "../schemas/queries/index.js";
@@ -14,7 +13,7 @@ export declare abstract class CheckoutProvider<T extends Checkout = Checkout> ex
      * @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>;
+    abstract initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<T>;
     /**
      * Fetches an existing checkout by its identifier.
      *
@@ -22,7 +21,7 @@ export declare abstract class CheckoutProvider<T extends Checkout = Checkout> ex
      * @param payload
      * @param reqCtx
      */
-    abstract getById(payload: CheckoutQueryById, reqCtx: RequestContext): Promise<T | null>;
+    abstract getById(payload: CheckoutQueryById): Promise<T | null>;
     /**
      * Updates the shipping address for the checkout and recalculates the shipping methods and totals.
      *
@@ -31,7 +30,7 @@ export declare abstract class CheckoutProvider<T extends Checkout = Checkout> ex
      * 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>;
+    abstract setShippingAddress(payload: CheckoutMutationSetShippingAddress): 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.
      *
@@ -40,7 +39,7 @@ export declare abstract class CheckoutProvider<T extends Checkout = Checkout> ex
      * @param checkoutId The checkout you want to get shipping methods for.
      * @param reqCtx
      */
-    abstract getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods, reqCtx: RequestContext): Promise<ShippingMethod[]>;
+    abstract getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<ShippingMethod[]>;
     /**
      * Returns all available payment methods for the given checkout. This will typically depend mostly on the billing address and jurisdiction.
      *
@@ -49,20 +48,20 @@ export declare abstract class CheckoutProvider<T extends Checkout = Checkout> ex
      * @param checkoutId The checkout you want to get payment methods for.
      * @param reqCtx
      */
-    abstract getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods, reqCtx: RequestContext): Promise<PaymentMethod[]>;
+    abstract getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): 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>;
+    abstract addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): 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>;
+    abstract removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): 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.
@@ -73,7 +72,7 @@ export declare abstract class CheckoutProvider<T extends Checkout = Checkout> ex
      * @param shippingMethodId
      * @param pickupPoint
      */
-    abstract setShippingInstruction(payload: CheckoutMutationSetShippingInstruction, reqCtx: RequestContext): Promise<T>;
+    abstract setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<T>;
     /**
      * Finalizes the checkout process. This typically involves creating an order from the checkout and processing payment.
      *
@@ -82,7 +81,7 @@ export declare abstract class CheckoutProvider<T extends Checkout = Checkout> ex
      * @param payload
      * @param reqCtx
      */
-    abstract finalizeCheckout(payload: CheckoutMutationFinalizeCheckout, reqCtx: RequestContext): Promise<T>;
+    abstract finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<T>;
 }
 /**
  *

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

@@ -1,12 +1,11 @@
 import type { Identity } from "../schemas/models/identity.model.js";
 import type { IdentityMutationLogin, IdentityMutationLogout, IdentityMutationRegister } from "../schemas/mutations/identity.mutation.js";
 import type { IdentityQuerySelf } from "../schemas/queries/identity.query.js";
-import type { RequestContext } from "../schemas/session.schema.js";
 import { BaseProvider } from "./base.provider.js";
 export declare abstract class IdentityProvider<T extends Identity = Identity> extends BaseProvider<T> {
-    abstract getSelf(payload: IdentityQuerySelf, reqCtx: RequestContext): Promise<T>;
-    abstract login(payload: IdentityMutationLogin, reqCtx: RequestContext): Promise<T>;
-    abstract logout(payload: IdentityMutationLogout, reqCtx: RequestContext): Promise<T>;
-    abstract register(payload: IdentityMutationRegister, reqCtx: RequestContext): Promise<T>;
+    abstract getSelf(payload: IdentityQuerySelf): Promise<T>;
+    abstract login(payload: IdentityMutationLogin): Promise<T>;
+    abstract logout(payload: IdentityMutationLogout): Promise<T>;
+    abstract register(payload: IdentityMutationRegister): Promise<T>;
     protected getResourceName(): string;
 }

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

@@ -1,8 +1,7 @@
 import type { Inventory } from '../schemas/models/inventory.model.js';
 import type { InventoryQueryBySKU } from '../schemas/queries/inventory.query.js';
-import type { RequestContext } from '../schemas/session.schema.js';
 import { BaseProvider } from './base.provider.js';
 export declare abstract class InventoryProvider<T extends Inventory = Inventory> extends BaseProvider<T> {
-    abstract getBySKU(payload: InventoryQueryBySKU, reqCtx: RequestContext): Promise<T>;
+    abstract getBySKU(payload: InventoryQueryBySKU): Promise<T>;
     protected getResourceName(): string;
 }

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

@@ -1,5 +1,4 @@
 import { BaseProvider } from "./base.provider.js";
-import type { RequestContext } from "../schemas/session.schema.js";
 import type { Order } from "../schemas/models/index.js";
 import type { OrderQueryById } from "../schemas/queries/index.js";
 export declare abstract class OrderProvider<T extends Order = Order> extends BaseProvider<T> {
@@ -10,7 +9,7 @@ export declare abstract class OrderProvider<T extends Order = Order> extends Bas
      * @param payload
      * @param session
      */
-    abstract getById(payload: OrderQueryById, reqCtx: RequestContext): Promise<T>;
+    abstract getById(payload: OrderQueryById): Promise<T>;
     protected createEmptyOrder(): T;
     protected getResourceName(): string;
 }

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

@@ -1,7 +1,5 @@
-import type { Currency } from '../schemas/models/currency.model.js';
 import type { Price } from '../schemas/models/price.model.js';
 import type { PriceQueryBySku } from '../schemas/queries/price.query.js';
-import type { RequestContext } from '../schemas/session.schema.js';
 import { BaseProvider } from './base.provider.js';
 export declare abstract class PriceProvider<T extends Price = Price> extends BaseProvider<T> {
     /**
@@ -14,7 +12,7 @@ export declare abstract class PriceProvider<T extends Price = Price> extends Bas
      * @param payload The SKU to query
      * @param session The session information
      */
-    abstract getBySKU(payload: PriceQueryBySku, reqCtx: RequestContext): Promise<T>;
+    abstract getBySKU(payload: PriceQueryBySku): Promise<T>;
     /**
      * Fetch prices for multiple SKUs in one go.
      *
@@ -22,7 +20,7 @@ export declare abstract class PriceProvider<T extends Price = Price> extends Bas
      * @param payload The SKUs to query
      * @param session The session information
      */
-    abstract getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): Promise<T[]>;
+    abstract getBySKUs(payload: PriceQueryBySku[]): Promise<T[]>;
     /**
      * Utility function to create an empty price result, with a value of -1.
      * This is used when no price is found for a given SKU + currency combination.
@@ -31,6 +29,6 @@ export declare abstract class PriceProvider<T extends Price = Price> extends Bas
      * @param currency
      * @returns
      */
-    protected createEmptyPriceResult(sku: string, currency: Currency): T;
+    protected createEmptyPriceResult(sku: string): T;
     protected getResourceName(): string;
 }

package/src/providers/product-search.provider.d.ts

@@ -1,35 +1,31 @@
 import type { FacetIdentifier, FacetValueIdentifier } from '../index.js';
 import type { ProductSearchResult, ProductSearchResultFacet, ProductSearchResultFacetValue, ProductSearchResultItem, ProductSearchResultItemVariant } from '../schemas/models/product-search.model.js';
 import type { ProductSearchQueryByTerm } from '../schemas/queries/product-search.query.js';
-import type { RequestContext } from '../schemas/session.schema.js';
 import { BaseProvider } from './base.provider.js';
 export declare abstract class ProductSearchProvider<T extends ProductSearchResultItem = ProductSearchResultItem> extends BaseProvider<T> {
-    abstract queryByTerm(payload: ProductSearchQueryByTerm, reqCtx: RequestContext): Promise<ProductSearchResult>;
     protected getResourceName(): string;
+    abstract queryByTerm(payload: ProductSearchQueryByTerm): Promise<ProductSearchResult>;
     /**
      * Parses a facet value from the search response.
      * @param facetValueIdentifier The identifier for the facet value.
      * @param label The label for the facet value.
      * @param count The count for the facet value.
-     * @param reqCtx The request context.
      */
-    protected abstract parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number, reqCtx: RequestContext): ProductSearchResultFacetValue;
+    protected abstract parseFacetValue(facetValueIdentifier: FacetValueIdentifier, label: string, count: number): ProductSearchResultFacetValue;
     /**
      * Parses a facet from the search response.
      * @param facetIdentifier The identifier for the facet.
      * @param facetValue The value for the facet.
-     * @param reqCtx The request context.
      *
      * Usecase: Override this to customize the parsing of facets.
      */
-    protected abstract parseFacet(facetIdentifier: FacetIdentifier, facetValue: unknown, reqCtx: RequestContext): ProductSearchResultFacet;
+    protected abstract parseFacet(facetIdentifier: FacetIdentifier, facetValue: unknown): ProductSearchResultFacet;
     /**
      * Parses a product variant from the search response.
      * @param variant The variant data from the search response.
      * @param product The product data from the search response.
-     * @param reqCtx The request context.
      *
      * Usecase: Override this to customize the parsing of product variants.
      */
-    protected abstract parseVariant(variant: unknown, product: unknown, reqCtx: RequestContext): ProductSearchResultItemVariant;
+    protected abstract parseVariant(variant: unknown, product: unknown): ProductSearchResultItemVariant;
 }

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

@@ -1,6 +1,5 @@
 import type { Product } from '../schemas/models/product.model.js';
 import { BaseProvider } from './base.provider.js';
-import type { RequestContext } from '../schemas/session.schema.js';
 import type { ProductQueryById, ProductQueryBySKU, ProductQueryBySlug } from '../schemas/queries/product.query.js';
 export declare abstract class ProductProvider<T extends Product = Product> extends BaseProvider<T> {
     /**
@@ -13,7 +12,7 @@ export declare abstract class ProductProvider<T extends Product = Product> exten
      * Marketing will TYPICALLY recommend products, and in some cases maybe HeroVariants of a product.
      * In that case, you would need to resolve the product to its hero variant first, and then get the SKU from there.
      */
-    abstract getById(payload: ProductQueryById, reqCtx: RequestContext): Promise<T>;
+    abstract getById(payload: ProductQueryById): Promise<T>;
     /**
      * Get a product by its slug.
      * @param payload The query payload containing the product slug.
@@ -21,7 +20,7 @@ export declare abstract class ProductProvider<T extends Product = Product> exten
      *
      * Usecase: You are rendering a product detail page, and you need to fetch the product by its slug.
      */
-    abstract getBySlug(payload: ProductQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
+    abstract getBySlug(payload: ProductQueryBySlug): Promise<T | null>;
     /**
      * Get a product by its SKU
      * @param payload
@@ -31,7 +30,7 @@ export declare abstract class ProductProvider<T extends Product = Product> exten
      * and you need to fetch the product details for that SKU. You will get the a Product back, with the variant matching the SKU set as heroSku.
      * It might also be used on a quick-order page, or product recommendations from external system.
      */
-    abstract getBySKU(payload: ProductQueryBySKU, reqCtx: RequestContext): Promise<T>;
+    abstract getBySKU(payload: ProductQueryBySKU): Promise<T>;
     /**
      * Returns a set of Products for each variant. Is a paged response, to ensure we do not build in overfetching from the start.
      *

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

@@ -1,10 +1,9 @@
 import type { Profile } from '../schemas/models/index.js';
 import type { ProfileMutationUpdate } from '../schemas/mutations/index.js';
 import type { ProfileQuerySelf } from '../schemas/queries/index.js';
-import type { RequestContext } from '../schemas/session.schema.js';
 import { BaseProvider } from './base.provider.js';
 export declare abstract class ProfileProvider<T extends Profile = Profile> extends BaseProvider<T> {
-    abstract getSelf(payload: ProfileQuerySelf, reqCtx: RequestContext): Promise<T>;
-    abstract update(payload: ProfileMutationUpdate, reqCtx: RequestContext): Promise<T>;
+    abstract getSelf(payload: ProfileQuerySelf): Promise<T>;
+    abstract update(payload: ProfileMutationUpdate): Promise<T>;
     protected getResourceName(): string;
 }

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

@@ -1,8 +1,7 @@
 import type { Store } from '../schemas/models/store.model.js';
 import type { StoreQueryByProximity } from '../schemas/queries/index.js';
-import type { RequestContext } from '../schemas/session.schema.js';
 import { BaseProvider } from './base.provider.js';
 export declare abstract class StoreProvider<T extends Store = Store> extends BaseProvider<T> {
-    abstract queryByProximity(payload: StoreQueryByProximity, reqCtx: RequestContext): Promise<Array<T>>;
+    abstract queryByProximity(payload: StoreQueryByProximity): Promise<Array<T>>;
     protected getResourceName(): string;
 }

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

@@ -8,9 +8,6 @@ export declare const AnonymousIdentitySchema: z.ZodObject<{
         placeholder: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$loose>>;
     type: z.ZodDefault<z.ZodLiteral<"Anonymous">>;
-    token: z.ZodOptional<z.ZodString>;
-    refresh_token: z.ZodOptional<z.ZodString>;
-    expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
 }, z.core.$loose>;
 export declare const GuestIdentitySchema: z.ZodObject<{
     meta: z.ZodDefault<z.ZodObject<{
@@ -24,9 +21,6 @@ export declare const GuestIdentitySchema: z.ZodObject<{
         userId: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
     }, z.core.$loose>>;
     type: z.ZodDefault<z.ZodLiteral<"Guest">>;
-    token: z.ZodOptional<z.ZodString>;
-    refresh_token: z.ZodOptional<z.ZodString>;
-    expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
 }, z.core.$loose>;
 export declare const RegisteredIdentitySchema: z.ZodObject<{
     meta: z.ZodDefault<z.ZodObject<{
@@ -40,10 +34,6 @@ export declare const RegisteredIdentitySchema: z.ZodObject<{
         userId: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
     }, z.core.$loose>>;
     type: z.ZodDefault<z.ZodLiteral<"Registered">>;
-    logonId: z.ZodDefault<z.ZodString>;
-    token: z.ZodOptional<z.ZodString>;
-    refresh_token: z.ZodOptional<z.ZodString>;
-    expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
 }, z.core.$loose>;
 export declare const IdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     meta: z.ZodDefault<z.ZodObject<{
@@ -54,9 +44,6 @@ export declare const IdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         placeholder: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$loose>>;
     type: z.ZodDefault<z.ZodLiteral<"Anonymous">>;
-    token: z.ZodOptional<z.ZodString>;
-    refresh_token: z.ZodOptional<z.ZodString>;
-    expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
 }, z.core.$loose>, z.ZodObject<{
     meta: z.ZodDefault<z.ZodObject<{
         cache: z.ZodDefault<z.ZodObject<{
@@ -69,9 +56,6 @@ export declare const IdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         userId: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
     }, z.core.$loose>>;
     type: z.ZodDefault<z.ZodLiteral<"Guest">>;
-    token: z.ZodOptional<z.ZodString>;
-    refresh_token: z.ZodOptional<z.ZodString>;
-    expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
 }, z.core.$loose>, z.ZodObject<{
     meta: z.ZodDefault<z.ZodObject<{
         cache: z.ZodDefault<z.ZodObject<{
@@ -84,10 +68,6 @@ export declare const IdentitySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
         userId: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
     }, z.core.$loose>>;
     type: z.ZodDefault<z.ZodLiteral<"Registered">>;
-    logonId: z.ZodDefault<z.ZodString>;
-    token: z.ZodOptional<z.ZodString>;
-    refresh_token: z.ZodOptional<z.ZodString>;
-    expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
 }, z.core.$loose>], "type">;
 export type AnonymousIdentity = z.infer<typeof AnonymousIdentitySchema>;
 export type GuestIdentity = z.infer<typeof GuestIdentitySchema>;

package/src/schemas/session.schema.d.ts

@@ -196,50 +196,6 @@ export declare const TaxJurisdictionSchema: z.ZodObject<{
     cityCode: z.ZodDefault<z.ZodString>;
 }, z.core.$strip>;
 export declare const RequestContextSchema: z.ZodObject<{
-    identity: z.ZodDefault<z.ZodDiscriminatedUnion<[z.ZodObject<{
-        meta: z.ZodDefault<z.ZodObject<{
-            cache: z.ZodDefault<z.ZodObject<{
-                hit: z.ZodDefault<z.ZodBoolean>;
-                key: z.ZodDefault<z.ZodString>;
-            }, z.core.$loose>>;
-            placeholder: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$loose>>;
-        type: z.ZodDefault<z.ZodLiteral<"Anonymous">>;
-        token: z.ZodOptional<z.ZodString>;
-        refresh_token: z.ZodOptional<z.ZodString>;
-        expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
-    }, z.core.$loose>, z.ZodObject<{
-        meta: z.ZodDefault<z.ZodObject<{
-            cache: z.ZodDefault<z.ZodObject<{
-                hit: z.ZodDefault<z.ZodBoolean>;
-                key: z.ZodDefault<z.ZodString>;
-            }, z.core.$loose>>;
-            placeholder: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$loose>>;
-        id: z.ZodDefault<z.ZodObject<{
-            userId: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
-        }, z.core.$loose>>;
-        type: z.ZodDefault<z.ZodLiteral<"Guest">>;
-        token: z.ZodOptional<z.ZodString>;
-        refresh_token: z.ZodOptional<z.ZodString>;
-        expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
-    }, z.core.$loose>, z.ZodObject<{
-        meta: z.ZodDefault<z.ZodObject<{
-            cache: z.ZodDefault<z.ZodObject<{
-                hit: z.ZodDefault<z.ZodBoolean>;
-                key: z.ZodDefault<z.ZodString>;
-            }, z.core.$loose>>;
-            placeholder: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$loose>>;
-        id: z.ZodDefault<z.ZodObject<{
-            userId: z.ZodNonOptional<z.ZodDefault<z.ZodString>>;
-        }, z.core.$loose>>;
-        type: z.ZodDefault<z.ZodLiteral<"Registered">>;
-        logonId: z.ZodDefault<z.ZodString>;
-        token: z.ZodOptional<z.ZodString>;
-        refresh_token: z.ZodOptional<z.ZodString>;
-        expiry: z.ZodDefault<z.ZodCoercedDate<unknown>>;
-    }, z.core.$loose>], "type">>;
     session: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodAny>>;
     languageContext: z.ZodDefault<z.ZodObject<{
         locale: z.ZodDefault<z.ZodString>;