@reactionary/core 0.0.42 → 0.0.48

package/schemas/session.schema.js

@@ -4,16 +4,30 @@ import { WebStoreIdentifierSchema } from "./models/identifiers.model";
 import { CurrencySchema } from "./models/currency.model";
 const LanguageContextSchema = z.looseObject({
   locale: z.string().default("en-US"),
-  currencyCode: CurrencySchema.default(() => CurrencySchema.parse({})),
-  countryCode: z.string().default("US")
+  currencyCode: CurrencySchema.default(() => CurrencySchema.parse({}))
 });
-const SessionSchema = z.looseObject({
-  id: z.string(),
-  identity: IdentitySchema.default(() => IdentitySchema.parse({})),
-  languageContext: LanguageContextSchema.default(() => LanguageContextSchema.parse({})),
-  storeIdentifier: WebStoreIdentifierSchema.default(() => WebStoreIdentifierSchema.parse({}))
+const SessionSchema = z.record(z.string(), z.any());
+const TaxJurisdictionSchema = z.object({
+  countryCode: z.string().default("US"),
+  stateCode: z.string().default(""),
+  countyCode: z.string().default(""),
+  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."),
+  taxJurisdiction: TaxJurisdictionSchema.default(() => TaxJurisdictionSchema.parse({})).describe("ReadOnly. The tax jurisdiction for the current request, typically derived from the store location or carts billing address"),
+  correlationId: z.string().default("").describe("A unique identifier for the request, can be used for tracing and logging purposes."),
+  isBot: z.boolean().default(false).describe("Indicates if the request is made by a bot or crawler."),
+  clientIp: z.string().default("").describe("The IP address of the client making the request, if available. Mostly for logging purposes"),
+  userAgent: z.string().default("").describe("The user agent string of the client making the request, if available."),
+  referrer: z.string().default("").describe("The referrer URL, if available.")
 });
 export {
   LanguageContextSchema,
-  SessionSchema
+  RequestContextSchema,
+  SessionSchema,
+  TaxJurisdictionSchema
 };

package/src/cache/cache.interface.d.ts

@@ -1,4 +1,9 @@
-import { z } from 'zod';
+import type { z } from 'zod';
+import type { BaseModel } from '../schemas/models';
+export interface CacheEntryOptions {
+    ttlSeconds: number;
+    dependencyIds: Array<string>;
+}
 /**
  * Generic cache interface that can be implemented by different cache backends
  * (Redis, memory, file-based, etc.)
@@ -7,30 +12,18 @@ export interface Cache {
     /**
      * Retrieves a value from cache and validates it against the provided schema
      */
-    get<T>(key: string, schema: z.ZodType<T>): Promise<T | null>;
+    get<T extends BaseModel>(key: string, schema: z.ZodType<T>): Promise<T | null>;
     /**
      * Stores a value in cache with optional expiration time
      */
-    put(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
-    /**
-     * Removes one or more keys from cache
-     * Supports wildcard patterns (implementation dependent)
-     */
-    del(keys: string | string[]): Promise<void>;
-    /**
-     * Finds all keys matching a pattern (implementation dependent)
-     */
-    keys(pattern: string): Promise<string[]>;
+    put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
     /**
-     * Clears all cache entries or entries matching a pattern
+     * Removes entries from the cache based on a set of dependency
+     * ids
      */
-    clear(pattern?: string): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
     /**
-     * Gets basic cache statistics (implementation dependent)
+     * Removes all entries from cache, wiping it completely
      */
-    getStats(): Promise<{
-        hits: number;
-        misses: number;
-        size: number;
-    }>;
+    clear(): Promise<void>;
 }

package/src/cache/memory-cache.d.ts

@@ -0,0 +1,18 @@
+import type { BaseModel } from '../schemas/models';
+import type { Cache, CacheEntryOptions } from './cache.interface';
+import type z from 'zod';
+/**
+ * Memory version of the cache. Primarily useful for local development.
+ * This is NOT suited for production use.
+ */
+export declare class MemoryCache implements Cache {
+    protected entries: {
+        key: string;
+        value: unknown;
+        options: CacheEntryOptions;
+    }[];
+    get<T extends BaseModel>(key: string, schema: z.ZodType<T>): Promise<T | null>;
+    put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
+    clear(): Promise<void>;
+}

package/src/cache/noop-cache.d.ts

@@ -1,18 +1,12 @@
-import { Cache } from './cache.interface';
-import z from 'zod';
+import type { Cache, CacheEntryOptions } from './cache.interface';
+import type z from 'zod';
 /**
  * No-op cache implementation that never stores or returns data.
  * Useful for testing or when caching should be disabled.
  */
 export declare class NoOpCache implements Cache {
     get<T>(_key: string, _schema: z.ZodType<T>): Promise<T | null>;
-    put(_key: string, _value: unknown, _ttlSeconds?: number): Promise<void>;
-    del(_keys: string | string[]): Promise<void>;
-    keys(_pattern: string): Promise<string[]>;
-    clear(_pattern?: string): Promise<void>;
-    getStats(): Promise<{
-        hits: number;
-        misses: number;
-        size: number;
-    }>;
+    put(_key: string, _value: unknown, options: CacheEntryOptions): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
+    clear(): Promise<void>;
 }

package/src/cache/redis-cache.d.ts

@@ -1,17 +1,11 @@
 import { Redis } from '@upstash/redis';
-import { Cache } from './cache.interface';
-import z from 'zod';
+import type { Cache, CacheEntryOptions } from './cache.interface';
+import type z from 'zod';
 export declare class RedisCache implements Cache {
     protected redis: Redis;
     constructor();
     get<T>(key: string, schema: z.ZodType<T>): Promise<T | null>;
-    put(key: string, value: unknown, ttlSeconds?: number): Promise<void>;
-    del(keys: string | string[]): Promise<void>;
-    keys(pattern: string): Promise<string[]>;
-    clear(pattern?: string): Promise<void>;
-    getStats(): Promise<{
-        hits: number;
-        misses: number;
-        size: number;
-    }>;
+    put(key: string, value: unknown, options: CacheEntryOptions): Promise<void>;
+    invalidate(dependencyIds: Array<string>): Promise<void>;
+    clear(): Promise<void>;
 }

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

@@ -1,5 +1,5 @@
-import { Cache } from "../cache/cache.interface";
-import { Client } from "./client";
+import type { Cache } from "../cache/cache.interface";
+import type { Client } from "./client";
 type CapabilityFactory<T> = (cache: Cache) => T;
 type MergeCapabilities<Acc, New> = Omit<Acc, keyof New> & New;
 export declare class ClientBuilder<TClient = object> {

package/src/client/client.d.ts

@@ -1,13 +1,13 @@
-import { AnalyticsProvider } from "../providers/analytics.provider";
-import { ProductProvider } from "../providers/product.provider";
-import { SearchProvider } from "../providers/search.provider";
-import { IdentityProvider } from '../providers/identity.provider';
-import { CartProvider } from "../providers/cart.provider";
-import { PriceProvider } from "../providers/price.provider";
-import { InventoryProvider } from "../providers/inventory.provider";
-import { Cache } from "../cache/cache.interface";
-import { CategoryProvider } from "../providers/category.provider";
-import { CartPaymentProvider } from "../providers";
+import type { AnalyticsProvider } from "../providers/analytics.provider";
+import type { ProductProvider } from "../providers/product.provider";
+import type { SearchProvider } from "../providers/search.provider";
+import type { IdentityProvider } from '../providers/identity.provider';
+import type { CartProvider } from "../providers/cart.provider";
+import type { PriceProvider } from "../providers/price.provider";
+import type { InventoryProvider } from "../providers/inventory.provider";
+import type { Cache } from "../cache/cache.interface";
+import type { CategoryProvider } from "../providers/category.provider";
+import type { CartPaymentProvider } from "../providers";
 export interface Client {
     product: ProductProvider;
     search: SearchProvider;

package/src/decorators/reactionary.decorator.d.ts

@@ -1 +1,34 @@
-export declare function Reactionary(options: unknown): MethodDecorator;
+import type { BaseProvider } from '../providers';
+/**
+ * The options associated with annotating a provider function and marking
+ * it as a reactionary entrypoint to be called
+ */
+export declare class ReactionaryDecoratorOptions {
+    /**
+     * Whether or not the query is eligible for caching. Queries that depend
+     * heavily on personalization, for example, are likely to be a poor fit
+     * for caching.
+     */
+    cache: boolean;
+    /**
+     * Whether or not the cache entry should be variable based on the locale
+     * of the context in which it is querried.
+     */
+    localeDependentCaching: boolean;
+    /**
+     * Whether or not the cache entry should be variable based on the currency
+     * of the context in which it is querried.
+     */
+    currencyDependentCaching: boolean;
+    /**
+     * The number of seconds which a cache entry should be considered valid for the
+     * given query.
+     */
+    cacheTimeToLiveInSeconds: number;
+}
+/**
+ * Decorator for provider functions to provide functionality such as caching, tracing and type-checked
+ * assertion through Zod. It should only be used with publically accessible queries or mutations on
+ * providers.
+ */
+export declare function Reactionary(options: Partial<ReactionaryDecoratorOptions>): (target: BaseProvider, propertyKey: string | symbol, descriptor: PropertyDescriptor) => PropertyDescriptor;

package/src/index.d.ts

@@ -1,6 +1,6 @@
 export * from './cache/cache.interface';
-export * from './cache/cache-evaluation.interface';
 export * from './cache/redis-cache';
+export * from './cache/memory-cache';
 export * from './cache/noop-cache';
 export * from './client/client';
 export * from './client/client-builder';
@@ -11,3 +11,4 @@ export * from './schemas/session.schema';
 export * from './schemas/models/';
 export * from './schemas/mutations/';
 export * from './schemas/queries';
+export * from './initialization';

package/src/initialization.d.ts

@@ -0,0 +1,2 @@
+import type { RequestContext } from "./schemas/session.schema";
+export declare function createInitialRequestContext(): RequestContext;

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

@@ -1,4 +1,4 @@
-import { AnalyticsEvent } from '../schemas/models/analytics.model';
+import type { AnalyticsEvent } from '../schemas/models/analytics.model';
 import { BaseProvider } from './base.provider';
 export declare abstract class AnalyticsProvider<T extends AnalyticsEvent = AnalyticsEvent> extends BaseProvider<T> {
     protected getResourceName(): string;

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-payment.provider.d.ts

@@ -1,7 +1,7 @@
-import { CartPaymentInstruction } from '../schemas/models/payment.model';
-import { CartPaymentMutationAddPayment, CartPaymentMutationCancelPayment } from '../schemas/mutations/cart-payment.mutation';
-import { CartPaymentQueryByCart } from '../schemas/queries/cart-payment.query';
-import { Session } from '../schemas/session.schema';
+import type { CartPaymentInstruction } from '../schemas/models/payment.model';
+import type { CartPaymentMutationAddPayment, CartPaymentMutationCancelPayment } from '../schemas/mutations/cart-payment.mutation';
+import type { CartPaymentQueryByCart } from '../schemas/queries/cart-payment.query';
+import type { RequestContext } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 export declare abstract class CartPaymentProvider<T extends CartPaymentInstruction = CartPaymentInstruction> extends BaseProvider<T> {
     /**
@@ -14,7 +14,7 @@ export declare abstract class CartPaymentProvider<T extends CartPaymentInstructi
      * @param cartIdentifier
      * @param session
      */
-    abstract getByCartIdentifier(payload: CartPaymentQueryByCart, session: Session): Promise<T[]>;
+    abstract getByCartIdentifier(payload: CartPaymentQueryByCart, reqCtx: RequestContext): Promise<T[]>;
     /**
      * Calls payment provider to set up a new payment intent. Returns whatever is needed to continue the payment process, e.g. a client secret for Stripe, or a redirect URL for PayPal.
      *
@@ -25,7 +25,7 @@ export declare abstract class CartPaymentProvider<T extends CartPaymentInstructi
      * @param payload
      * @param session
      */
-    abstract initiatePaymentForCart(payload: CartPaymentMutationAddPayment, session: Session): Promise<T>;
+    abstract initiatePaymentForCart(payload: CartPaymentMutationAddPayment, reqCtx: RequestContext): Promise<T>;
     /**
      * Cancel a payment instruction. This will typically void the payment intent in the payment provider, and set the status of the payment instruction to 'canceled'.
      *
@@ -37,6 +37,6 @@ export declare abstract class CartPaymentProvider<T extends CartPaymentInstructi
      * @param session
      * @returns
      */
-    abstract cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, session: Session): Promise<T>;
+    abstract cancelPaymentInstruction(payload: CartPaymentMutationCancelPayment, reqCtx: RequestContext): Promise<T>;
     protected getResourceName(): string;
 }

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/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

@@ -7,4 +7,6 @@ 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';

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/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,10 @@
-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, 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>;
     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;
 }