@reactionary/core 0.6.1 → 0.6.2

package/client/client-builder.js

@@ -7,6 +7,7 @@ import { MulticastProductRecommendationsProvider } from "../providers/product-re
 class ClientBuilder {
   constructor(context) {
     this.factories = [];
+    this.collisionStrategy = "last-wins";
     this.context = context;
   }
   withCapability(factory) {
@@ -14,6 +15,7 @@ class ClientBuilder {
     newBuilder.factories = [...this.factories, factory];
     newBuilder.cache = this.cache;
     newBuilder.context = this.context;
+    newBuilder.collisionStrategy = this.collisionStrategy;
     return newBuilder;
   }
   withCache(cache) {
@@ -21,6 +23,15 @@ class ClientBuilder {
     newBuilder.factories = [...this.factories];
     newBuilder.cache = cache;
     newBuilder.context = this.context;
+    newBuilder.collisionStrategy = this.collisionStrategy;
+    return newBuilder;
+  }
+  withCollisionStrategy(strategy) {
+    const newBuilder = new ClientBuilder(this.context);
+    newBuilder.factories = [...this.factories];
+    newBuilder.cache = this.cache;
+    newBuilder.context = this.context;
+    newBuilder.collisionStrategy = strategy;
     return newBuilder;
   }
   build() {
@@ -33,11 +44,8 @@ class ClientBuilder {
     const mergedAnalytics = [];
     const mergedProductRecommendationsProviders = [];
     for (const factory of this.factories) {
-      const provider = factory(sharedCache, this.context);
-      client = {
-        ...client,
-        ...provider
-      };
+      const provider = this.resolveFactory(factory, sharedCache, this.context);
+      client = this.mergeProviders(client, provider);
       if (provider.analytics) {
         mergedAnalytics.push(provider.analytics);
       }
@@ -53,6 +61,28 @@ class ClientBuilder {
     };
     return completeClient;
   }
+  resolveFactory(factory, cache, context) {
+    if (factory.length <= 1) {
+      return factory({ cache, context });
+    }
+    return factory(cache, context);
+  }
+  mergeProviders(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+      const hasExisting = Object.prototype.hasOwnProperty.call(result, key);
+      if (hasExisting) {
+        if (this.collisionStrategy === "first-wins") {
+          continue;
+        }
+        if (this.collisionStrategy === "throw") {
+          throw new Error(`Capability collision detected for "${key}"`);
+        }
+      }
+      result[key] = source[key];
+    }
+    return result;
+  }
 }
 export {
   ClientBuilder

package/factories/index.js

@@ -0,0 +1,15 @@
+export * from "./cart.factory.js";
+export * from "./category.factory.js";
+export * from "./checkout.factory.js";
+export * from "./identity.factory.js";
+export * from "./inventory.factory.js";
+export * from "./order.factory.js";
+export * from "./order-search.factory.js";
+export * from "./price.factory.js";
+export * from "./product.factory.js";
+export * from "./product-associations.factory.js";
+export * from "./product-list.factory.js";
+export * from "./product-reviews.factory.js";
+export * from "./product-search.factory.js";
+export * from "./profile.factory.js";
+export * from "./store.factory.js";

package/index.js

@@ -1,6 +1,7 @@
 export * from "./cache/index.js";
 export * from "./client/index.js";
 export * from "./decorators/index.js";
+export * from "./factories/index.js";
 export * from "./providers/index.js";
 export * from "./schemas/index.js";
 export * from "./initialization.js";

package/package.json

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

package/providers/product-search.provider.js

@@ -3,6 +3,12 @@ class ProductSearchProvider extends BaseProvider {
   getResourceName() {
     return "product-search";
   }
+  /**
+   * 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.
+   */
 }
 export {
   ProductSearchProvider

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

@@ -1,17 +1,26 @@
 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;
+export interface ClientBuilderFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+}
+export type CapabilityFactory<T> = ((cache: Cache, context: RequestContext) => T) | ((args: ClientBuilderFactoryArgs) => T);
 type MergeCapabilities<Acc, New> = Omit<Acc, keyof New> & New;
+export type CapabilityCollisionStrategy = 'last-wins' | 'first-wins' | 'throw';
 export declare class ClientBuilder<TClient = Client> {
     private factories;
     private cache;
     private context;
+    private collisionStrategy;
     constructor(context: RequestContext);
     withCapability<TNew extends Partial<Client>>(factory: CapabilityFactory<TNew>): ClientBuilder<MergeCapabilities<TClient, TNew>>;
     withCache(cache: Cache): ClientBuilder<TClient>;
+    withCollisionStrategy(strategy: CapabilityCollisionStrategy): ClientBuilder<TClient>;
     build(): TClient & {
         cache: Cache;
     };
+    private resolveFactory;
+    private mergeProviders;
 }
 export {};

package/src/factories/cart.factory.d.ts

@@ -0,0 +1,18 @@
+import type * as z from 'zod';
+import type { CartSchema } from '../schemas/models/cart.model.js';
+import type { CartIdentifierSchema } from '../schemas/models/identifiers.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCartSchema = z.ZodType<z.output<typeof CartSchema>>;
+export type AnyCartIdentifierSchema = z.ZodType<z.output<typeof CartIdentifierSchema>>;
+export interface CartFactory<TCartSchema extends AnyCartSchema = AnyCartSchema, TCartIdentifierSchema extends AnyCartIdentifierSchema = AnyCartIdentifierSchema> {
+    cartSchema: TCartSchema;
+    cartIdentifierSchema: TCartIdentifierSchema;
+    parseCart(context: RequestContext, data: unknown): z.output<TCartSchema>;
+    parseCartIdentifier(context: RequestContext, data: unknown): z.output<TCartIdentifierSchema>;
+}
+export type CartFactoryCartOutput<TFactory extends CartFactory> = ReturnType<TFactory['parseCart']>;
+export type CartFactoryIdentifierOutput<TFactory extends CartFactory> = ReturnType<TFactory['parseCartIdentifier']>;
+export type CartFactoryWithOutput<TFactory extends CartFactory> = Omit<TFactory, 'parseCart' | 'parseCartIdentifier'> & {
+    parseCart(context: RequestContext, data: unknown): CartFactoryCartOutput<TFactory>;
+    parseCartIdentifier(context: RequestContext, data: unknown): CartFactoryIdentifierOutput<TFactory>;
+};

package/src/factories/category.factory.d.ts

@@ -0,0 +1,17 @@
+import type * as z from 'zod';
+import type { CategoryPaginatedResultSchema, CategorySchema } from '../schemas/models/category.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCategorySchema = z.ZodType<z.output<typeof CategorySchema>>;
+export type AnyCategoryPaginatedResultSchema = z.ZodType<z.output<typeof CategoryPaginatedResultSchema>>;
+export interface CategoryFactory<TCategorySchema extends AnyCategorySchema = AnyCategorySchema, TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = AnyCategoryPaginatedResultSchema> {
+    categorySchema: TCategorySchema;
+    categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+    parseCategory(context: RequestContext, data: unknown): z.output<TCategorySchema>;
+    parseCategoryPaginatedResult(context: RequestContext, data: unknown): z.output<TCategoryPaginatedSchema>;
+}
+export type CategoryFactoryCategoryOutput<TFactory extends CategoryFactory> = ReturnType<TFactory['parseCategory']>;
+export type CategoryFactoryPaginatedOutput<TFactory extends CategoryFactory> = ReturnType<TFactory['parseCategoryPaginatedResult']>;
+export type CategoryFactoryWithOutput<TFactory extends CategoryFactory> = Omit<TFactory, 'parseCategory' | 'parseCategoryPaginatedResult'> & {
+    parseCategory(context: RequestContext, data: unknown): CategoryFactoryCategoryOutput<TFactory>;
+    parseCategoryPaginatedResult(context: RequestContext, data: unknown): CategoryFactoryPaginatedOutput<TFactory>;
+};

package/src/factories/checkout.factory.d.ts

@@ -0,0 +1,24 @@
+import type * as z from 'zod';
+import type { CheckoutSchema } from '../schemas/models/checkout.model.js';
+import type { PaymentMethodSchema } from '../schemas/models/payment.model.js';
+import type { ShippingMethodSchema } from '../schemas/models/shipping-method.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyCheckoutSchema = z.ZodType<z.output<typeof CheckoutSchema>>;
+export type AnyShippingMethodSchema = z.ZodType<z.output<typeof ShippingMethodSchema>>;
+export type AnyPaymentMethodSchema = z.ZodType<z.output<typeof PaymentMethodSchema>>;
+export interface CheckoutFactory<TCheckoutSchema extends AnyCheckoutSchema = AnyCheckoutSchema, TShippingMethodSchema extends AnyShippingMethodSchema = AnyShippingMethodSchema, TPaymentMethodSchema extends AnyPaymentMethodSchema = AnyPaymentMethodSchema> {
+    checkoutSchema: TCheckoutSchema;
+    shippingMethodSchema: TShippingMethodSchema;
+    paymentMethodSchema: TPaymentMethodSchema;
+    parseCheckout(context: RequestContext, data: unknown): z.output<TCheckoutSchema>;
+    parseShippingMethod(context: RequestContext, data: unknown): z.output<TShippingMethodSchema>;
+    parsePaymentMethod(context: RequestContext, data: unknown): z.output<TPaymentMethodSchema>;
+}
+export type CheckoutFactoryCheckoutOutput<TFactory extends CheckoutFactory> = ReturnType<TFactory['parseCheckout']>;
+export type CheckoutFactoryShippingMethodOutput<TFactory extends CheckoutFactory> = ReturnType<TFactory['parseShippingMethod']>;
+export type CheckoutFactoryPaymentMethodOutput<TFactory extends CheckoutFactory> = ReturnType<TFactory['parsePaymentMethod']>;
+export type CheckoutFactoryWithOutput<TFactory extends CheckoutFactory> = Omit<TFactory, 'parseCheckout' | 'parseShippingMethod' | 'parsePaymentMethod'> & {
+    parseCheckout(context: RequestContext, data: unknown): CheckoutFactoryCheckoutOutput<TFactory>;
+    parseShippingMethod(context: RequestContext, data: unknown): CheckoutFactoryShippingMethodOutput<TFactory>;
+    parsePaymentMethod(context: RequestContext, data: unknown): CheckoutFactoryPaymentMethodOutput<TFactory>;
+};

package/src/factories/identity.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { IdentitySchema } from '../schemas/models/identity.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyIdentitySchema = z.ZodType<z.output<typeof IdentitySchema>>;
+export interface IdentityFactory<TIdentitySchema extends AnyIdentitySchema = AnyIdentitySchema> {
+    identitySchema: TIdentitySchema;
+    parseIdentity(context: RequestContext, data: unknown): z.output<TIdentitySchema>;
+}
+export type IdentityFactoryOutput<TFactory extends IdentityFactory> = ReturnType<TFactory['parseIdentity']>;
+export type IdentityFactoryWithOutput<TFactory extends IdentityFactory> = Omit<TFactory, 'parseIdentity'> & {
+    parseIdentity(context: RequestContext, data: unknown): IdentityFactoryOutput<TFactory>;
+};

package/src/factories/index.d.ts

@@ -0,0 +1,15 @@
+export * from './cart.factory.js';
+export * from './category.factory.js';
+export * from './checkout.factory.js';
+export * from './identity.factory.js';
+export * from './inventory.factory.js';
+export * from './order.factory.js';
+export * from './order-search.factory.js';
+export * from './price.factory.js';
+export * from './product.factory.js';
+export * from './product-associations.factory.js';
+export * from './product-list.factory.js';
+export * from './product-reviews.factory.js';
+export * from './product-search.factory.js';
+export * from './profile.factory.js';
+export * from './store.factory.js';

package/src/factories/inventory.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { InventorySchema } from '../schemas/models/inventory.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyInventorySchema = z.ZodType<z.output<typeof InventorySchema>>;
+export interface InventoryFactory<TInventorySchema extends AnyInventorySchema = AnyInventorySchema> {
+    inventorySchema: TInventorySchema;
+    parseInventory(context: RequestContext, data: unknown): z.output<TInventorySchema>;
+}
+export type InventoryFactoryOutput<TFactory extends InventoryFactory> = ReturnType<TFactory['parseInventory']>;
+export type InventoryFactoryWithOutput<TFactory extends InventoryFactory> = Omit<TFactory, 'parseInventory'> & {
+    parseInventory(context: RequestContext, data: unknown): InventoryFactoryOutput<TFactory>;
+};

package/src/factories/order-search.factory.d.ts

@@ -0,0 +1,13 @@
+import type * as z from 'zod';
+import type { OrderSearchResultSchema } from '../schemas/models/order-search.model.js';
+import type { OrderSearchQueryByTerm } from '../schemas/queries/order-search.query.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyOrderSearchResultSchema = z.ZodType<z.output<typeof OrderSearchResultSchema>>;
+export interface OrderSearchFactory<TOrderSearchResultSchema extends AnyOrderSearchResultSchema = AnyOrderSearchResultSchema> {
+    orderSearchResultSchema: TOrderSearchResultSchema;
+    parseOrderSearchResult(context: RequestContext, data: unknown, query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
+}
+export type OrderSearchFactoryOutput<TFactory extends OrderSearchFactory> = ReturnType<TFactory['parseOrderSearchResult']>;
+export type OrderSearchFactoryWithOutput<TFactory extends OrderSearchFactory> = Omit<TFactory, 'parseOrderSearchResult'> & {
+    parseOrderSearchResult(context: RequestContext, data: unknown, query: OrderSearchQueryByTerm): OrderSearchFactoryOutput<TFactory>;
+};

package/src/factories/order.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { OrderSchema } from '../schemas/models/order.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyOrderSchema = z.ZodType<z.output<typeof OrderSchema>>;
+export interface OrderFactory<TOrderSchema extends AnyOrderSchema = AnyOrderSchema> {
+    orderSchema: TOrderSchema;
+    parseOrder(context: RequestContext, data: unknown): z.output<TOrderSchema>;
+}
+export type OrderFactoryOutput<TFactory extends OrderFactory> = ReturnType<TFactory['parseOrder']>;
+export type OrderFactoryWithOutput<TFactory extends OrderFactory> = Omit<TFactory, 'parseOrder'> & {
+    parseOrder(context: RequestContext, data: unknown): OrderFactoryOutput<TFactory>;
+};

package/src/factories/price.factory.d.ts

@@ -0,0 +1,16 @@
+import type * as z from 'zod';
+import type { PriceSchema } from '../schemas/models/price.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyPriceSchema = z.ZodType<z.output<typeof PriceSchema>>;
+export interface PriceFactory<TPriceSchema extends AnyPriceSchema = AnyPriceSchema> {
+    priceSchema: TPriceSchema;
+    parsePrice(context: RequestContext, data: unknown, options?: {
+        includeDiscounts: boolean;
+    }): z.output<TPriceSchema>;
+}
+export type PriceFactoryOutput<TFactory extends PriceFactory> = ReturnType<TFactory['parsePrice']>;
+export type PriceFactoryWithOutput<TFactory extends PriceFactory> = Omit<TFactory, 'parsePrice'> & {
+    parsePrice(context: RequestContext, data: unknown, options?: {
+        includeDiscounts: boolean;
+    }): PriceFactoryOutput<TFactory>;
+};

package/src/factories/product-associations.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { ProductAssociationSchema } from '../schemas/models/product-associations.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductAssociationSchema = z.ZodType<z.output<typeof ProductAssociationSchema>>;
+export interface ProductAssociationsFactory<TProductAssociationSchema extends AnyProductAssociationSchema = AnyProductAssociationSchema> {
+    productAssociationSchema: TProductAssociationSchema;
+    parseAssociation(context: RequestContext, data: unknown): z.output<TProductAssociationSchema>;
+}
+export type ProductAssociationsFactoryOutput<TFactory extends ProductAssociationsFactory> = ReturnType<TFactory['parseAssociation']>;
+export type ProductAssociationsFactoryWithOutput<TFactory extends ProductAssociationsFactory> = Omit<TFactory, 'parseAssociation'> & {
+    parseAssociation(context: RequestContext, data: unknown): ProductAssociationsFactoryOutput<TFactory>;
+};

package/src/factories/product-list.factory.d.ts

@@ -0,0 +1,27 @@
+import type * as z from 'zod';
+import type { ProductListItemPaginatedResultsSchema, ProductListItemSchema, ProductListPaginatedResultsSchema, ProductListSchema } from '../schemas/models/product-list.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductListSchema = z.ZodType<z.output<typeof ProductListSchema>>;
+export type AnyProductListItemSchema = z.ZodType<z.output<typeof ProductListItemSchema>>;
+export type AnyProductListPaginatedSchema = z.ZodType<z.output<typeof ProductListPaginatedResultsSchema>>;
+export type AnyProductListItemPaginatedSchema = z.ZodType<z.output<typeof ProductListItemPaginatedResultsSchema>>;
+export interface ProductListFactory<TProductListSchema extends AnyProductListSchema = AnyProductListSchema, TProductListItemSchema extends AnyProductListItemSchema = AnyProductListItemSchema, TProductListPaginatedSchema extends AnyProductListPaginatedSchema = AnyProductListPaginatedSchema, TProductListItemPaginatedSchema extends AnyProductListItemPaginatedSchema = AnyProductListItemPaginatedSchema> {
+    productListSchema: TProductListSchema;
+    productListItemSchema: TProductListItemSchema;
+    productListPaginatedSchema: TProductListPaginatedSchema;
+    productListItemPaginatedSchema: TProductListItemPaginatedSchema;
+    parseProductList(context: RequestContext, data: unknown): z.output<TProductListSchema>;
+    parseProductListItem(context: RequestContext, data: unknown): z.output<TProductListItemSchema>;
+    parseProductListPaginatedResult(context: RequestContext, data: unknown): z.output<TProductListPaginatedSchema>;
+    parseProductListItemPaginatedResult(context: RequestContext, data: unknown): z.output<TProductListItemPaginatedSchema>;
+}
+export type ProductListFactoryListOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductList']>;
+export type ProductListFactoryItemOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductListItem']>;
+export type ProductListFactoryListPaginatedOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductListPaginatedResult']>;
+export type ProductListFactoryItemPaginatedOutput<TFactory extends ProductListFactory> = ReturnType<TFactory['parseProductListItemPaginatedResult']>;
+export type ProductListFactoryWithOutput<TFactory extends ProductListFactory> = Omit<TFactory, 'parseProductList' | 'parseProductListItem' | 'parseProductListPaginatedResult' | 'parseProductListItemPaginatedResult'> & {
+    parseProductList(context: RequestContext, data: unknown): ProductListFactoryListOutput<TFactory>;
+    parseProductListItem(context: RequestContext, data: unknown): ProductListFactoryItemOutput<TFactory>;
+    parseProductListPaginatedResult(context: RequestContext, data: unknown): ProductListFactoryListPaginatedOutput<TFactory>;
+    parseProductListItemPaginatedResult(context: RequestContext, data: unknown): ProductListFactoryItemPaginatedOutput<TFactory>;
+};

package/src/factories/product-reviews.factory.d.ts

@@ -0,0 +1,22 @@
+import type * as z from 'zod';
+import type { ProductRatingSummarySchema, ProductReviewPaginatedResultSchema, ProductReviewSchema } from '../schemas/models/product-reviews.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductRatingSummarySchema = z.ZodType<z.output<typeof ProductRatingSummarySchema>>;
+export type AnyProductReviewSchema = z.ZodType<z.output<typeof ProductReviewSchema>>;
+export type AnyProductReviewPaginatedSchema = z.ZodType<z.output<typeof ProductReviewPaginatedResultSchema>>;
+export interface ProductReviewsFactory<TRatingSummarySchema extends AnyProductRatingSummarySchema = AnyProductRatingSummarySchema, TReviewSchema extends AnyProductReviewSchema = AnyProductReviewSchema, TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = AnyProductReviewPaginatedSchema> {
+    ratingSummarySchema: TRatingSummarySchema;
+    reviewSchema: TReviewSchema;
+    reviewPaginatedSchema: TReviewPaginatedSchema;
+    parseRatingSummary(context: RequestContext, data: unknown): z.output<TRatingSummarySchema>;
+    parseReview(context: RequestContext, data: unknown): z.output<TReviewSchema>;
+    parseReviewPaginatedResult(context: RequestContext, data: unknown): z.output<TReviewPaginatedSchema>;
+}
+export type ProductReviewsFactoryRatingOutput<TFactory extends ProductReviewsFactory> = ReturnType<TFactory['parseRatingSummary']>;
+export type ProductReviewsFactoryReviewOutput<TFactory extends ProductReviewsFactory> = ReturnType<TFactory['parseReview']>;
+export type ProductReviewsFactoryReviewPaginatedOutput<TFactory extends ProductReviewsFactory> = ReturnType<TFactory['parseReviewPaginatedResult']>;
+export type ProductReviewsFactoryWithOutput<TFactory extends ProductReviewsFactory> = Omit<TFactory, 'parseRatingSummary' | 'parseReview' | 'parseReviewPaginatedResult'> & {
+    parseRatingSummary(context: RequestContext, data: unknown): ProductReviewsFactoryRatingOutput<TFactory>;
+    parseReview(context: RequestContext, data: unknown): ProductReviewsFactoryReviewOutput<TFactory>;
+    parseReviewPaginatedResult(context: RequestContext, data: unknown): ProductReviewsFactoryReviewPaginatedOutput<TFactory>;
+};

package/src/factories/product-search.factory.d.ts

@@ -0,0 +1,13 @@
+import type * as z from 'zod';
+import type { ProductSearchResultSchema } 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';
+export type AnyProductSearchResultSchema = z.ZodType<z.output<typeof ProductSearchResultSchema>>;
+export interface ProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = AnyProductSearchResultSchema> {
+    productSearchResultSchema: TProductSearchResultSchema;
+    parseSearchResult(context: RequestContext, data: unknown, query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+}
+export type ProductSearchFactoryOutput<TFactory extends ProductSearchFactory> = ReturnType<TFactory['parseSearchResult']>;
+export type ProductSearchFactoryWithOutput<TFactory extends ProductSearchFactory> = Omit<TFactory, 'parseSearchResult'> & {
+    parseSearchResult(context: RequestContext, data: unknown, query: ProductSearchQueryByTerm): ProductSearchFactoryOutput<TFactory>;
+};

package/src/factories/product.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { ProductSchema } from '../schemas/models/product.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProductSchema = z.ZodType<z.output<typeof ProductSchema>>;
+export interface ProductFactory<TProductSchema extends AnyProductSchema = AnyProductSchema> {
+    productSchema: TProductSchema;
+    parseProduct(context: RequestContext, data: unknown): z.output<TProductSchema>;
+}
+export type ProductFactoryOutput<TFactory extends ProductFactory> = ReturnType<TFactory['parseProduct']>;
+export type ProductFactoryWithOutput<TFactory extends ProductFactory> = Omit<TFactory, 'parseProduct'> & {
+    parseProduct(context: RequestContext, data: unknown): ProductFactoryOutput<TFactory>;
+};

package/src/factories/profile.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { ProfileSchema } from '../schemas/models/profile.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyProfileSchema = z.ZodType<z.output<typeof ProfileSchema>>;
+export interface ProfileFactory<TProfileSchema extends AnyProfileSchema = AnyProfileSchema> {
+    profileSchema: TProfileSchema;
+    parseProfile(context: RequestContext, data: unknown): z.output<TProfileSchema>;
+}
+export type ProfileFactoryOutput<TFactory extends ProfileFactory> = ReturnType<TFactory['parseProfile']>;
+export type ProfileFactoryWithOutput<TFactory extends ProfileFactory> = Omit<TFactory, 'parseProfile'> & {
+    parseProfile(context: RequestContext, data: unknown): ProfileFactoryOutput<TFactory>;
+};

package/src/factories/store.factory.d.ts

@@ -0,0 +1,12 @@
+import type * as z from 'zod';
+import type { StoreSchema } from '../schemas/models/store.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+export type AnyStoreSchema = z.ZodType<z.output<typeof StoreSchema>>;
+export interface StoreFactory<TStoreSchema extends AnyStoreSchema = AnyStoreSchema> {
+    storeSchema: TStoreSchema;
+    parseStore(context: RequestContext, data: unknown): z.output<TStoreSchema>;
+}
+export type StoreFactoryOutput<TFactory extends StoreFactory> = ReturnType<TFactory['parseStore']>;
+export type StoreFactoryWithOutput<TFactory extends StoreFactory> = Omit<TFactory, 'parseStore'> & {
+    parseStore(context: RequestContext, data: unknown): StoreFactoryOutput<TFactory>;
+};

package/src/index.d.ts

@@ -1,6 +1,8 @@
 export * from './cache/index.js';
 export * from './client/index.js';
 export * from './decorators/index.js';
+export * from './factories/index.js';
 export * from './providers/index.js';
 export * from './schemas/index.js';
 export * from './initialization.js';
+export type { InferType } from './zod-utils.js';

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

@@ -8,7 +8,7 @@ import { BaseProvider } from "./base.provider.js";
 /**
  * @group Providers
  */
-export declare abstract class CartProvider extends BaseProvider {
+export declare abstract class CartProvider<TCart extends Cart = Cart, TCartIdentifier extends CartIdentifier = CartIdentifier> extends BaseProvider {
     /**
      * Get cart by ID.
      *
@@ -16,14 +16,14 @@ export declare abstract class CartProvider extends BaseProvider {
      * @param payload
      * @param session
      */
-    abstract getById(payload: CartQueryById): Promise<Result<Cart, NotFoundError>>;
+    abstract getById(payload: CartQueryById): Promise<Result<TCart, NotFoundError>>;
     /**
      * 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(): Promise<Result<CartIdentifier, NotFoundError>>;
+    abstract getActiveCartId(): Promise<Result<TCartIdentifier, NotFoundError>>;
     /**
      * 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,
@@ -33,7 +33,7 @@ export declare abstract class CartProvider extends BaseProvider {
      * @param payload
      * @param session
      */
-    abstract add(payload: CartMutationItemAdd): Promise<Result<Cart>>;
+    abstract add(payload: CartMutationItemAdd): Promise<Result<TCart>>;
     /**
      * Remove item from cart. If the cart is empty after removal, delete the cart. Returns the updated and recalculated cart.
      *
@@ -41,7 +41,7 @@ export declare abstract class CartProvider extends BaseProvider {
      * @param payload
      * @param session
      */
-    abstract remove(payload: CartMutationItemRemove): Promise<Result<Cart>>;
+    abstract remove(payload: CartMutationItemRemove): Promise<Result<TCart>>;
     /**
      * 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.
@@ -51,7 +51,7 @@ export declare abstract class CartProvider extends BaseProvider {
      * @param payload
      * @param session
      */
-    abstract changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<Cart>>;
+    abstract changeQuantity(payload: CartMutationItemQuantityChange): Promise<Result<TCart>>;
     /**
      * Deletes the entire cart.
      *
@@ -67,7 +67,7 @@ export declare abstract class CartProvider extends BaseProvider {
      * @param payload
      * @param session
      */
-    abstract applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<Cart>>;
+    abstract applyCouponCode(payload: CartMutationApplyCoupon): Promise<Result<TCart>>;
     /**
      * Removes a coupon code from the cart. Returns the updated and recalculated cart.
      *
@@ -75,7 +75,7 @@ export declare abstract class CartProvider extends BaseProvider {
      * @param payload
      * @param session
      */
-    abstract removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<Cart>>;
+    abstract removeCouponCode(payload: CartMutationRemoveCoupon): Promise<Result<TCart>>;
     /**
      * Changes the currency of the cart.
      *
@@ -83,6 +83,6 @@ export declare abstract class CartProvider extends BaseProvider {
      * @param newCurrency
      * @param session
      */
-    abstract changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<Cart>>;
+    abstract changeCurrency(payload: CartMutationChangeCurrency): Promise<Result<TCart>>;
     protected getResourceName(): string;
 }

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

@@ -10,7 +10,7 @@ import { BaseProvider } from "./base.provider.js";
  *
  * @group Foo
  */
-export declare abstract class CategoryProvider extends BaseProvider {
+export declare abstract class CategoryProvider<TCategory extends Category = Category, TCategoryPaginatedResult extends CategoryPaginatedResult = CategoryPaginatedResult> extends BaseProvider {
     /**
      * Get a single category by its ID. Cannot return null, because HOW did you come across a categories ID that does not exist?
      *
@@ -26,7 +26,7 @@ export declare abstract class CategoryProvider extends BaseProvider {
      * @param id
      * @param session
      */
-    abstract getById(payload: CategoryQueryById): Promise<Result<Category, NotFoundError>>;
+    abstract getById(payload: CategoryQueryById): Promise<Result<TCategory, NotFoundError>>;
     /**
      * Gets a single category by its seo slug
      *
@@ -34,7 +34,7 @@ export declare abstract class CategoryProvider extends BaseProvider {
      * @param slug the slug
      * @param session
      */
-    abstract getBySlug(payload: CategoryQueryBySlug): Promise<Result<Category, NotFoundError>>;
+    abstract getBySlug(payload: CategoryQueryBySlug): Promise<Result<TCategory, NotFoundError>>;
     /**
      * 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 extends BaseProvider {
      * @param id
      * @param session
      */
-    abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<Category[]>>;
+    abstract getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb): Promise<Result<TCategory[]>>;
     /**
      * Finds all child categories of a given category.
      *
@@ -54,7 +54,7 @@ export declare abstract class CategoryProvider extends BaseProvider {
      * @param id The ID of the parent category.
      * @param session The session information.
      */
-    abstract findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<CategoryPaginatedResult>>;
+    abstract findChildCategories(payload: CategoryQueryForChildCategories): Promise<Result<TCategoryPaginatedResult>>;
     /**
      * Returns all top categories, i.e. categories without a parent.
      *
@@ -62,6 +62,6 @@ export declare abstract class CategoryProvider extends BaseProvider {
      * @param paginationOptions
      * @param session
      */
-    abstract findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<CategoryPaginatedResult>>;
+    abstract findTopCategories(payload: CategoryQueryForTopCategories): Promise<Result<TCategoryPaginatedResult>>;
     protected getResourceName(): string;
 }

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

@@ -4,7 +4,7 @@ import type { CheckoutMutationFinalizeCheckout, CheckoutMutationInitiateCheckout
 import type { CheckoutQueryById, CheckoutQueryForAvailablePaymentMethods, CheckoutQueryForAvailableShippingMethods } from "../schemas/queries/index.js";
 import type { Result } from "../schemas/result.js";
 import type { NotFoundError } from "../schemas/index.js";
-export declare abstract class CheckoutProvider extends BaseProvider {
+export declare abstract class CheckoutProvider<TCheckout extends Checkout = Checkout, TShippingMethod extends ShippingMethod = ShippingMethod, TPaymentMethod extends PaymentMethod = PaymentMethod> extends BaseProvider {
     /**
      * 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.
@@ -15,7 +15,7 @@ export declare abstract class CheckoutProvider extends BaseProvider {
      * @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): Promise<Result<Checkout>>;
+    abstract initiateCheckoutForCart(payload: CheckoutMutationInitiateCheckout): Promise<Result<TCheckout>>;
     /**
      * Fetches an existing checkout by its identifier.
      *
@@ -23,7 +23,7 @@ export declare abstract class CheckoutProvider extends BaseProvider {
      * @param payload
      * @param reqCtx
      */
-    abstract getById(payload: CheckoutQueryById): Promise<Result<Checkout, NotFoundError>>;
+    abstract getById(payload: CheckoutQueryById): Promise<Result<TCheckout, NotFoundError>>;
     /**
      * Updates the shipping address for the checkout and recalculates the shipping methods and totals.
      *
@@ -32,7 +32,7 @@ export declare abstract class CheckoutProvider extends BaseProvider {
      * 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): Promise<Result<Checkout>>;
+    abstract setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<TCheckout>>;
     /**
      * 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.
      *
@@ -41,7 +41,7 @@ export declare abstract class CheckoutProvider extends BaseProvider {
      * @param checkoutId The checkout you want to get shipping methods for.
      * @param reqCtx
      */
-    abstract getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<ShippingMethod[]>>;
+    abstract getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<TShippingMethod[]>>;
     /**
      * Returns all available payment methods for the given checkout. This will typically depend mostly on the billing address and jurisdiction.
      *
@@ -50,20 +50,20 @@ export declare abstract class CheckoutProvider extends BaseProvider {
      * @param checkoutId The checkout you want to get payment methods for.
      * @param reqCtx
      */
-    abstract getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<PaymentMethod[]>>;
+    abstract getAvailablePaymentMethods(payload: CheckoutQueryForAvailablePaymentMethods): Promise<Result<TPaymentMethod[]>>;
     /**
      * 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): Promise<Result<Checkout>>;
+    abstract addPaymentInstruction(payload: CheckoutMutationAddPaymentInstruction): Promise<Result<TCheckout>>;
     /**
      * 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): Promise<Result<Checkout>>;
+    abstract removePaymentInstruction(payload: CheckoutMutationRemovePaymentInstruction): Promise<Result<TCheckout>>;
     /**
      * 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.
@@ -74,7 +74,7 @@ export declare abstract class CheckoutProvider extends BaseProvider {
      * @param shippingMethodId
      * @param pickupPoint
      */
-    abstract setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<Checkout>>;
+    abstract setShippingInstruction(payload: CheckoutMutationSetShippingInstruction): Promise<Result<TCheckout>>;
     /**
      * Finalizes the checkout process. This typically involves creating an order from the checkout and processing payment.
      *
@@ -83,7 +83,7 @@ export declare abstract class CheckoutProvider extends BaseProvider {
      * @param payload
      * @param reqCtx
      */
-    abstract finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<Checkout>>;
+    abstract finalizeCheckout(payload: CheckoutMutationFinalizeCheckout): Promise<Result<TCheckout>>;
     getResourceName(): string;
 }
 /**

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

@@ -3,11 +3,11 @@ import type { IdentityMutationLogin, IdentityMutationLogout, IdentityMutationReg
 import type { IdentityQuerySelf } from "../schemas/queries/identity.query.js";
 import type { Result } from "../schemas/result.js";
 import { BaseProvider } from "./base.provider.js";
-export declare abstract class IdentityProvider extends BaseProvider {
-    abstract getSelf(payload: IdentityQuerySelf): Promise<Result<Identity>>;
-    abstract login(payload: IdentityMutationLogin): Promise<Result<Identity>>;
-    abstract logout(payload: IdentityMutationLogout): Promise<Result<Identity>>;
-    abstract register(payload: IdentityMutationRegister): Promise<Result<Identity>>;
+export declare abstract class IdentityProvider<TIdentity extends Identity = Identity> extends BaseProvider {
+    abstract getSelf(payload: IdentityQuerySelf): Promise<Result<TIdentity>>;
+    abstract login(payload: IdentityMutationLogin): Promise<Result<TIdentity>>;
+    abstract logout(payload: IdentityMutationLogout): Promise<Result<TIdentity>>;
+    abstract register(payload: IdentityMutationRegister): Promise<Result<TIdentity>>;
     protected getResourceName(): string;
-    protected updateIdentityContext(identity: Identity): void;
+    protected updateIdentityContext(identity: TIdentity): void;
 }

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

@@ -4,8 +4,8 @@ import type { Inventory } from '../schemas/models/inventory.model.js';
 import type { InventoryQueryBySKU } from '../schemas/queries/inventory.query.js';
 import type { Result } from '../schemas/result.js';
 import { BaseProvider } from './base.provider.js';
-export declare abstract class InventoryProvider extends BaseProvider {
-    abstract getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>>;
+export declare abstract class InventoryProvider<TInventory extends Inventory = Inventory> extends BaseProvider {
+    abstract getBySKU(payload: InventoryQueryBySKU): Promise<Result<TInventory, NotFoundError>>;
     protected getResourceName(): string;
-    protected createEmptyInventory(key: InventoryIdentifier): Inventory;
+    protected createEmptyInventory(key: InventoryIdentifier): TInventory;
 }

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

@@ -8,7 +8,7 @@ import { BaseProvider } from "./base.provider.js";
  *
  * Usecase: An e-commerce platform wants to provide customers with a way to search through their past orders using filters like date range, order status, or total amount spent.
  */
-export declare abstract class OrderSearchProvider extends BaseProvider {
+export declare abstract class OrderSearchProvider<TOrderSearchResult extends OrderSearchResult = OrderSearchResult> extends BaseProvider {
     protected getResourceName(): string;
     /**
      * Queries orders based on the provided search criteria.
@@ -17,5 +17,5 @@ export declare abstract class OrderSearchProvider extends BaseProvider {
      * Usecase: A widget on the frontpage after login, shows the last 5 orders placed by the customer.
      * @param payload The search criteria for querying orders.
      */
-    abstract queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>>;
+    abstract queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<TOrderSearchResult>>;
 }

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

@@ -3,7 +3,7 @@ import type { Order } from '../schemas/models/index.js';
 import type { OrderQueryById } from '../schemas/queries/index.js';
 import type { Result } from '../schemas/result.js';
 import type { NotFoundError } from '../schemas/index.js';
-export declare abstract class OrderProvider extends BaseProvider {
+export declare abstract class OrderProvider<TOrder extends Order = Order> extends BaseProvider {
     /**
      * Get order by ID.
      *
@@ -11,7 +11,7 @@ export declare abstract class OrderProvider extends BaseProvider {
      * @param payload
      * @param session
      */
-    abstract getById(payload: OrderQueryById): Promise<Result<Order, NotFoundError>>;
-    protected createEmptyOrder(): Order;
+    abstract getById(payload: OrderQueryById): Promise<Result<TOrder, NotFoundError>>;
+    protected createEmptyOrder(): TOrder;
     protected getResourceName(): string;
 }

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

@@ -1,7 +1,7 @@
 import type { Price, Result } from '../schemas/index.js';
 import type { CustomerPriceQuery, ListPriceQuery } from '../schemas/queries/price.query.js';
 import { BaseProvider } from './base.provider.js';
-export declare abstract class PriceProvider extends BaseProvider {
+export declare abstract class PriceProvider<TPrice extends Price = Price> extends BaseProvider {
     /**
      * Get a list price price by SKU. This is the most general, undiscounted price and is typically
      * used as the "before" price in most ecommerce setups.
@@ -10,7 +10,7 @@ export declare abstract class PriceProvider extends BaseProvider {
      * @param payload The SKU to query
      * @param session The session information
      */
-    abstract getListPrice(payload: ListPriceQuery): Promise<Result<Price>>;
+    abstract getListPrice(payload: ListPriceQuery): Promise<Result<TPrice>>;
     /**
      * Get a customer-specific price by SKU.
      *
@@ -20,7 +20,7 @@ export declare abstract class PriceProvider extends BaseProvider {
      * @param payload The SKU to query
      * @param session The session information
      */
-    abstract getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<Price>>;
+    abstract getCustomerPrice(payload: CustomerPriceQuery): Promise<Result<TPrice>>;
     /**
      * 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.
@@ -29,6 +29,6 @@ export declare abstract class PriceProvider extends BaseProvider {
      * @param currency
      * @returns
      */
-    protected createEmptyPriceResult(sku: string): Price;
+    protected createEmptyPriceResult(sku: string): TPrice;
     protected getResourceName(): string;
 }

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

@@ -7,7 +7,7 @@ import type { ProductAssociation } from '../schemas/models/product-associations.
  * accessories, spareparts, and replacements. These associations are typically used to provide recommendations to customers on the product detail page, but can also be used in other contexts such as the cart or post-purchase, but
  * do not carry any personalization concept to them.
  */
-export declare abstract class ProductAssociationsProvider extends BaseProvider {
+export declare abstract class ProductAssociationsProvider<TProductAssociation extends ProductAssociation = ProductAssociation> extends BaseProvider {
     /**
      * Returns a list of product identifiers which are accessories to the given product.
      * Accessories in are products in their own right, but are commonly purchased alongside or recommended as complementary to the main product. Examples of accessories include:
@@ -20,7 +20,7 @@ export declare abstract class ProductAssociationsProvider extends BaseProvider {
      *
      * TODO:  This should be a PaginatedResult
      */
-    abstract getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociation[]>>;
+    abstract getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<TProductAssociation[]>>;
     /**
      * Returns a list of product identifiers which are spareparts to the given product.
      * Spareparts are products which are necessary for the use of the main product, but are not typically purchased alongside it. Examples of spareparts include:
@@ -30,13 +30,13 @@ export declare abstract class ProductAssociationsProvider extends BaseProvider {
      *
      * TODO:  This should be a PaginatedResult
      */
-    abstract getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociation[]>>;
+    abstract getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<TProductAssociation[]>>;
     /**
      * This product is replaced by these equivalent or newer products
      *
      * TODO:  This should be a PaginatedResult
      * @param query
      */
-    abstract getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociation[]>>;
+    abstract getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<TProductAssociation[]>>;
     getResourceName(): string;
 }

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

@@ -12,21 +12,21 @@ import { BaseProvider } from "./base.provider.js";
  *
  * Some systems might only support single entries of each type, but the general case is to support multiples.
  */
-export declare abstract class ProductListProvider extends BaseProvider {
+export declare abstract class ProductListProvider<TProductList extends ProductList = ProductList, TProductListItem extends ProductListItem = ProductListItem, TProductListPaginatedResult extends ProductListPaginatedResult = ProductListPaginatedResult, TProductListItemPaginatedResult extends ProductListItemPaginatedResult = ProductListItemPaginatedResult> extends BaseProvider {
     protected getResourceName(): string;
     /**
      * Usecase: in the frontend you want to fetch a specific list, for example a specific wishlist, to show the details of the list, such as the name, description, image, etc.
      * you might have stored the identifier from an earlier session or looked it up previously.
      * @param payload
      */
-    abstract getById(payload: ProductListQueryById): Promise<Result<ProductList>>;
+    abstract getById(payload: ProductListQueryById): Promise<Result<TProductList>>;
     /**
      * Usecase: in the frontend you want to see if the customer already has a favorite list or wishlist, to which the product can be added.
      * In complex scenarios you might want to fetch a list of wishlists, and allow customer to pick which one to add the product-variant to.
      *
      * @param query
      */
-    abstract queryLists(query: ProductListQuery): Promise<Result<ProductListPaginatedResult>>;
+    abstract queryLists(query: ProductListQuery): Promise<Result<TProductListPaginatedResult>>;
     /**
      * Usecase: in the frontend, if customer has clicked the "add to favorites list", and you have used the queryLists to find out there is no
      * preexistiing list, you can use this method to create a new favorite list.
@@ -35,13 +35,13 @@ export declare abstract class ProductListProvider extends BaseProvider {
      * which the customer can then add the product to.
      * @param mutation
      */
-    abstract addList(mutation: ProductListMutationCreate): Promise<Result<ProductList>>;
+    abstract addList(mutation: ProductListMutationCreate): Promise<Result<TProductList>>;
     /**
      *
      * Usecase: update name of list, or other metadata related to the list, such as "this is my summer wishlist", or "this is my favorite list for cameras".
      * @param mutation
      */
-    abstract updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductList>>;
+    abstract updateList(mutation: ProductListMutationUpdate): Promise<Result<TProductList>>;
     /**
      * Usecase: customer wants to delete a list, such as "delete my summer wishlist", including all the product list items
      * @param mutation
@@ -51,12 +51,12 @@ export declare abstract class ProductListProvider extends BaseProvider {
      * Usecase: in the frontend you want to show a list of the products in the customers wishlist.
      * @param query
      */
-    abstract queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListItemPaginatedResult>>;
+    abstract queryListItems(query: ProductListItemsQuery): Promise<Result<TProductListItemPaginatedResult>>;
     /**
      * Usecase: Add a new product-variant to a list
      * @param mutation
      */
-    abstract addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListItem>>;
+    abstract addItem(mutation: ProductListItemMutationCreate): Promise<Result<TProductListItem>>;
     /**
      * Usecase: Remove a product-variant from a list.
      * @param mutation
@@ -66,5 +66,5 @@ export declare abstract class ProductListProvider extends BaseProvider {
      * Usecase: Update the quantity of a product-variant in a list.
      * @param mutation
      */
-    abstract updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListItem>>;
+    abstract updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<TProductListItem>>;
 }

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

@@ -8,28 +8,28 @@ import { type ProductRatingIdentifier } from '../schemas/models/identifiers.mode
  * Reviews contain ratings along with textual feedback, author information, and verification status.
  * This provider also handles aggregated rating summaries for products.
  */
-export declare abstract class ProductReviewsProvider extends BaseProvider {
+export declare abstract class ProductReviewsProvider<TProductRatingSummary extends ProductRatingSummary = ProductRatingSummary, TProductReviewPaginatedResult extends ProductReviewPaginatedResult = ProductReviewPaginatedResult, TProductReview extends ProductReview = ProductReview> extends BaseProvider {
     /**
      * Get the rating summary for a product, including average rating and distribution.
      *
      * Usecase: Display rating summary on product detail pages or product listing pages.
      * @param query The product to get ratings for
      */
-    abstract getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<ProductRatingSummary>>;
+    abstract getRatingSummary(query: ProductReviewsGetRatingSummaryQuery): Promise<Result<TProductRatingSummary>>;
     /**
      * Get a paginated list of reviews for a product.
      *
      * Usecase: Display customer reviews on product detail pages with filtering and sorting options.
      * @param query The query parameters including product, pagination, sorting, and filtering options
      */
-    abstract findReviews(query: ProductReviewsListQuery): Promise<Result<ProductReviewPaginatedResult>>;
+    abstract findReviews(query: ProductReviewsListQuery): Promise<Result<TProductReviewPaginatedResult>>;
     /**
      * Submit a review for a product.
      *
      * Usecase: Allow customers to submit detailed reviews with ratings for products they have purchased.
      * @param mutation The review submission data including rating, title, and content
      */
-    abstract submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<ProductReview>>;
+    abstract submitReview(mutation: ProductReviewMutationSubmit): Promise<Result<TProductReview>>;
     protected createEmptyProductRatingSummary(key: ProductRatingIdentifier): ProductRatingSummary;
     getResourceName(): string;
 }

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

@@ -1,10 +1,10 @@
-import type { FacetIdentifier, FacetValueIdentifier, Result } from '../index.js';
-import type { ProductSearchResult, ProductSearchResultFacet, ProductSearchResultFacetValue, ProductSearchResultItemVariant } from '../schemas/models/product-search.model.js';
+import type { FacetValueIdentifier, Result } from '../index.js';
+import type { ProductSearchResult } from '../schemas/models/product-search.model.js';
 import type { ProductSearchQueryByTerm, ProductSearchQueryCreateNavigationFilter } from '../schemas/queries/product-search.query.js';
 import { BaseProvider } from './base.provider.js';
-export declare abstract class ProductSearchProvider extends BaseProvider {
+export declare abstract class ProductSearchProvider<TProductSearchResult extends ProductSearchResult = ProductSearchResult> extends BaseProvider {
     protected getResourceName(): string;
-    abstract queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<ProductSearchResult>>;
+    abstract queryByTerm(payload: ProductSearchQueryByTerm): Promise<Result<TProductSearchResult>>;
     /**
      * Since each platform has it own way of representing categories and their hierarchy, we leave it to the platform to tell us how to get from a
      * category breadcrumb path to a global category navigation filter that can be applied to product searches.
@@ -24,27 +24,4 @@ export declare abstract class ProductSearchProvider extends BaseProvider {
      * @param categoryPath
      */
     abstract createCategoryNavigationFilter(payload: ProductSearchQueryCreateNavigationFilter): Promise<Result<FacetValueIdentifier>>;
-    /**
-     * 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.
-     */
-    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.
-     *
-     * Usecase: Override this to customize the parsing of facets.
-     */
-    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.
-     *
-     * Usecase: Override this to customize the parsing of product variants.
-     */
-    protected abstract parseVariant(variant: unknown, product: unknown): ProductSearchResultItemVariant;
 }

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

@@ -3,7 +3,7 @@ import { BaseProvider } from './base.provider.js';
 import type { ProductQueryById, ProductQueryBySKU, ProductQueryBySlug } from '../schemas/queries/product.query.js';
 import type { Result } from '../schemas/result.js';
 import type { NotFoundError } from '../schemas/index.js';
-export declare abstract class ProductProvider extends BaseProvider {
+export declare abstract class ProductProvider<TProduct extends Product = Product> extends BaseProvider {
     /**
      * Get a product by its ID.
      * @param payload The query payload containing the product ID.
@@ -14,7 +14,7 @@ export declare abstract class ProductProvider extends BaseProvider {
      * 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): Promise<Result<Product>>;
+    abstract getById(payload: ProductQueryById): Promise<Result<TProduct>>;
     /**
      * Get a product by its slug.
      * @param payload The query payload containing the product slug.
@@ -22,7 +22,7 @@ export declare abstract class ProductProvider extends BaseProvider {
      *
      * Usecase: You are rendering a product detail page, and you need to fetch the product by its slug.
      */
-    abstract getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>>;
+    abstract getBySlug(payload: ProductQueryBySlug): Promise<Result<TProduct, NotFoundError>>;
     /**
      * Get a product by its SKU
      * @param payload
@@ -32,8 +32,8 @@ export declare abstract class ProductProvider extends BaseProvider {
      * 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): Promise<Result<Product>>;
-    protected createEmptyProduct(id: string): Product;
+    abstract getBySKU(payload: ProductQueryBySKU): Promise<Result<TProduct>>;
+    protected createEmptyProduct(id: string): TProduct;
     /**
      * The resource name, used for caching and logging.
      * @returns

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

@@ -4,14 +4,14 @@ import type { ProfileMutationAddShippingAddress, ProfileMutationMakeShippingAddr
 import type { ProfileQuerySelf as ProfileQueryById } from '../schemas/queries/index.js';
 import type { Result } from '../schemas/result.js';
 import { BaseProvider } from './base.provider.js';
-export declare abstract class ProfileProvider extends BaseProvider {
+export declare abstract class ProfileProvider<TProfile extends Profile = Profile> extends BaseProvider {
     /**
      * Returns the profile of the currently authenticated (registered) user.
      *
      * Usecase: Fetch the profile of the logged-in user for display in header, or account settings.
      * @param payload
      */
-    abstract getById(payload: ProfileQueryById): Promise<Result<Profile, NotFoundError>>;
+    abstract getById(payload: ProfileQueryById): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Updates the base profile information of the currently authenticated (registered) user.
      *
@@ -23,7 +23,7 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * Usecase: Update the user's name, email, or phone number.
      * @param payload
      */
-    abstract update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>>;
+    abstract update(payload: ProfileMutationUpdate): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Creates a new shipping address for the currently authenticated (registered) user.
      * Does not set it as default automatically.
@@ -32,7 +32,7 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * done at checkout should be considered local to that session, unless the addressbook is empty.
      * @param payload
      */
-    abstract addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Updates an existing shipping address for the currently authenticated (registered) user.
      *
@@ -40,7 +40,7 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * done at checkout should be considered local to that session/order, unless the addressbook is empty.
      * @param payload
      */
-    abstract updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Removes an existing shipping address for the currently authenticated (registered) user.
      *
@@ -49,14 +49,14 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * Usecase: User deletes a shipping address from their profile.
      * @param payload
      */
-    abstract removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Configures an existing shipping address as the default shipping address for the currently authenticated (registered) user.
      *
      * Usecase: User selects a default shipping address in their profile.
      * @param payload
      */
-    abstract makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>>;
+    abstract makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<TProfile, NotFoundError>>;
     /**
      * Sets the current/active billing address for the currently authenticated (registered) user.
      *
@@ -66,6 +66,6 @@ export declare abstract class ProfileProvider extends BaseProvider {
      * entity being billed, and as such it makes sense to have a single authoritative billing address.
      * @param payload
      */
-    abstract setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>>;
+    abstract setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<TProfile, NotFoundError>>;
     protected getResourceName(): string;
 }

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

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