@reactionary/core 0.0.42 → 0.0.51

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

@@ -1,8 +1,9 @@
-import { z } from 'zod';
-import { BaseModel, createPaginatedResponseSchema } from '../schemas/models/base.model';
-import { Cache } from '../cache/cache.interface';
-import { Session } from '../schemas/session.schema';
-import { IdentifierType } from '../schemas/models/identifiers.model';
+import type { z } from 'zod';
+import type { BaseModel } from '../schemas/models/base.model';
+import { createPaginatedResponseSchema } from '../schemas/models/base.model';
+import type { Cache } from '../cache/cache.interface';
+import type { RequestContext } from '../schemas/session.schema';
+import type { IdentifierType } from '../schemas/models/identifiers.model';
 /**
  * Base capability provider, responsible for mutations (changes) and queries (fetches)
  * for a given business object domain.
@@ -24,10 +25,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, session: Session): T;
-    protected parsePaginatedResult(_body: unknown, session: Session): z.infer<ReturnType<typeof createPaginatedResponseSchema<typeof this.schema>>>;
-    protected generateCacheKeyPaginatedResult(resultSetName: string, res: ReturnType<typeof this.parsePaginatedResult>, session: Session): string;
-    protected generateCacheKeySingle(identifier: IdentifierType, session: Session): string;
+    protected parseSingle(_body: unknown, reqCtx: RequestContext): T;
+    protected parsePaginatedResult(_body: unknown, reqCtx: RequestContext): 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;
     /**
      * Returns the abstract resource name provided by the remote system.
      */

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

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

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

@@ -1,6 +1,6 @@
-import { Category } from "../schemas/models/category.model";
-import { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query";
-import { Session } from "../schemas/session.schema";
+import type { Category } from "../schemas/models/category.model";
+import type { CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "../schemas/queries/category.query";
+import type { RequestContext } from "../schemas/session.schema";
 import { BaseProvider } from "./base.provider";
 /**
  * CategoryProvider
@@ -22,11 +22,11 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * For now, the result will be en empty category, but we should probably throw an error instead.
      *
      * Use case: You have received a list of category ids from a recommendation engine, and you need to show a tile of this.
-     * Future optimization: getByIds(ids: CategoryIdentifier[], session: Session): Promise<T[]>
+     * Future optimization: getByIds(ids: CategoryIdentifier[], reqCtx: RequestContext): Promise<T[]>
      * @param id
      * @param session
      */
-    abstract getById(payload: CategoryQueryById, session: Session): Promise<T>;
+    abstract getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T>;
     /**
      * Gets a single category by its seo slug
      *
@@ -34,7 +34,7 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param slug the slug
      * @param session
      */
-    abstract getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null>;
+    abstract getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): 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 +43,7 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param id
      * @param session
      */
-    abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]>;
+    abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]>;
     /**
      * Finds all child categories of a given category.
      *
@@ -54,7 +54,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, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+    abstract findChildCategories(payload: CategoryQueryForChildCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>>;
     /**
      * Returns all top categories, i.e. categories without a parent.
      *
@@ -62,6 +62,6 @@ export declare abstract class CategoryProvider<T extends Category = Category> ex
      * @param paginationOptions
      * @param session
      */
-    abstract findTopCategories(payload: CategoryQueryForTopCategories, session: Session): Promise<ReturnType<typeof this.parsePaginatedResult>>;
+    abstract findTopCategories(payload: CategoryQueryForTopCategories, reqCtx: RequestContext): Promise<ReturnType<typeof this.parsePaginatedResult>>;
     protected getResourceName(): string;
 }

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

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

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

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

package/src/providers/index.d.ts

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

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

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

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

@@ -0,0 +1,16 @@
+import { BaseProvider } from "./base.provider";
+import type { RequestContext } from "../schemas/session.schema";
+import type { Order } from "../schemas/models";
+import type { OrderQueryById } from "../schemas/queries";
+export declare abstract class OrderProvider<T extends Order = Order> extends BaseProvider<T> {
+    /**
+     * Get order by ID.
+     *
+     * Usecase: Fetch order after checkout, to check if we are fully paid and can continue to order confirmation page.
+     * @param payload
+     * @param session
+     */
+    abstract getById(payload: OrderQueryById, reqCtx: RequestContext): Promise<T>;
+    protected createEmptyOrder(): T;
+    protected getResourceName(): string;
+}

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

@@ -1,7 +1,7 @@
-import { Currency } from '../schemas/models/currency.model';
-import { Price } from '../schemas/models/price.model';
-import { PriceQueryBySku } from '../schemas/queries/price.query';
-import { Session } from '../schemas/session.schema';
+import type { Currency } from '../schemas/models/currency.model';
+import type { Price } from '../schemas/models/price.model';
+import type { PriceQueryBySku } from '../schemas/queries/price.query';
+import type { RequestContext } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 export declare abstract class PriceProvider<T extends Price = Price> extends BaseProvider<T> {
     /**
@@ -14,7 +14,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, session: Session): Promise<T>;
+    abstract getBySKU(payload: PriceQueryBySku, reqCtx: RequestContext): Promise<T>;
     /**
      * Fetch prices for multiple SKUs in one go.
      *
@@ -22,7 +22,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[], session: Session): Promise<T[]>;
+    abstract getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): 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.

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

@@ -1,10 +1,11 @@
-import { Product } from '../schemas/models/product.model';
+import type { Product } from '../schemas/models/product.model';
 import { BaseProvider } from './base.provider';
-import { Session } from '../schemas/session.schema';
-import { ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
+import type { RequestContext } from '../schemas/session.schema';
+import type { ProductQueryById, ProductQueryBySKU, ProductQueryBySlug } from '../schemas/queries/product.query';
 export declare abstract class ProductProvider<T extends Product = Product> extends BaseProvider<T> {
-    abstract getById(payload: ProductQueryById, session: Session): Promise<T>;
-    abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T | null>;
+    abstract getById(payload: ProductQueryById, reqCtx: RequestContext): Promise<T>;
+    abstract getBySlug(payload: ProductQueryBySlug, reqCtx: RequestContext): Promise<T | null>;
+    abstract getBySKU(payload: ProductQueryBySKU | ProductQueryBySKU[], reqCtx: RequestContext): Promise<T>;
     protected createEmptyProduct(id: string): T;
     /**
      * The resource name, used for caching and logging.

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

@@ -0,0 +1,10 @@
+import type { Profile } from '../schemas/models';
+import type { ProfileMutationUpdate } from '../schemas/mutations';
+import type { ProfileQuerySelf } from '../schemas/queries';
+import type { RequestContext } from '../schemas/session.schema';
+import { BaseProvider } from './base.provider';
+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>;
+    protected getResourceName(): string;
+}

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

@@ -1,8 +1,8 @@
-import { SearchResult } from '../schemas/models/search.model';
-import { SearchQueryByTerm } from '../schemas/queries/search.query';
-import { Session } from '../schemas/session.schema';
+import type { SearchResult } from '../schemas/models/search.model';
+import type { SearchQueryByTerm } from '../schemas/queries/search.query';
+import type { RequestContext } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 export declare abstract class SearchProvider<T extends SearchResult = SearchResult> extends BaseProvider<T> {
-    abstract queryByTerm(payload: SearchQueryByTerm, session: Session): Promise<SearchResult>;
+    abstract queryByTerm(payload: SearchQueryByTerm, reqCtx: RequestContext): Promise<SearchResult>;
     protected getResourceName(): string;
 }

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

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

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

@@ -5,9 +5,11 @@ export declare const CapabilitiesSchema: z.ZodObject<{
     analytics: z.ZodBoolean;
     identity: z.ZodBoolean;
     cart: z.ZodBoolean;
-    cartPayment: z.ZodBoolean;
+    checkout: z.ZodBoolean;
+    order: z.ZodBoolean;
     inventory: z.ZodBoolean;
     price: z.ZodBoolean;
     category: z.ZodBoolean;
+    store: z.ZodBoolean;
 }, z.core.$loose>;
 export type Capabilities = z.infer<typeof CapabilitiesSchema>;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 export declare const AnalyticsEventSchema: z.ZodObject<{
     meta: z.ZodDefault<z.ZodObject<{
         cache: z.ZodDefault<z.ZodObject<{