@reactionary/source 0.6.1 → 0.6.2

package/README.md

@@ -144,18 +144,8 @@ Vendors:  Commercetools
   - Add to Shopping List
 
 
-### Roadmap to V0.7
-Usecase: As a B2B user i want to shop using my own prices
-Vendors:  Commercetools, Medusa
-
-- PDP / PLP
-  - [ ] External Pricing
-  - [ ] Customer specific pricing
-  - [ ] Organizational/Entitlement Context. Choose to shop private or for company?
-  - [ ] Multi currency/Multi lingual
-
 
-### Roadmap to V0.8
+### Roadmap to V0.7
 Usecase: As a B2B user i want to see my organization data
 Vendors:  Commercetools, Medusa
 
@@ -167,6 +157,19 @@ Vendors:  Commercetools, Medusa
   - [ ] Self management of users and roles
 
 
+### Roadmap to V0.8
+Usecase: As a B2B user i want to shop using my own prices
+Vendors:  Commercetools, Medusa
+
+- PDP / PLP
+  - [ ] External Pricing / Pushed prices
+  - [ ] Customer specific pricing
+  - [ ] Organizational/Entitlement Context. Choose to shop private or for company?
+  - [ ] Multi currency/Multi lingual
+
+
+
+
 ### Roadmap to V0.9
 Usecase: As a B2B user i want have multiple carts and requisition lists
 Vendors:  Commercetools

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

@@ -8,14 +8,23 @@ import {
 } from '../schemas/session.schema.js';
 import { MulticastProductRecommendationsProvider, type ProductRecommendationsProvider } from '../providers/product-recommendations.provider.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 class ClientBuilder<TClient = Client> {
   private factories: Array<CapabilityFactory<Partial<Client>>> = [];
   private cache: Cache | undefined;
   private context: RequestContext;
+  private collisionStrategy: CapabilityCollisionStrategy = 'last-wins';
 
   constructor(context: RequestContext) {
     this.context = context;
@@ -28,6 +37,7 @@ export class ClientBuilder<TClient = Client> {
     newBuilder.factories = [...this.factories, factory];
     newBuilder.cache = this.cache;
     newBuilder.context = this.context;
+    newBuilder.collisionStrategy = this.collisionStrategy;
     return newBuilder;
   }
 
@@ -36,6 +46,16 @@ export class ClientBuilder<TClient = Client> {
     newBuilder.factories = [...this.factories];
     newBuilder.cache = cache;
     newBuilder.context = this.context;
+    newBuilder.collisionStrategy = this.collisionStrategy;
+    return newBuilder;
+  }
+
+  withCollisionStrategy(strategy: CapabilityCollisionStrategy): ClientBuilder<TClient> {
+    const newBuilder = new ClientBuilder<TClient>(this.context);
+    newBuilder.factories = [...this.factories];
+    newBuilder.cache = this.cache;
+    newBuilder.context = this.context;
+    newBuilder.collisionStrategy = strategy;
     return newBuilder;
   }
 
@@ -56,11 +76,8 @@ export class ClientBuilder<TClient = Client> {
     const mergedProductRecommendationsProviders: ProductRecommendationsProvider[] = [];
 
     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 as Partial<TClient>);
 
       if (provider.analytics) {
         mergedAnalytics.push(provider.analytics);
@@ -81,4 +98,35 @@ export class ClientBuilder<TClient = Client> {
 
     return completeClient;
   }
+
+  private resolveFactory<TNew extends Partial<Client>>(
+    factory: CapabilityFactory<TNew>,
+    cache: Cache,
+    context: RequestContext,
+  ): TNew {
+    if (factory.length <= 1) {
+      return (factory as (args: ClientBuilderFactoryArgs) => TNew)({ cache, context });
+    }
+    return (factory as (cache: Cache, context: RequestContext) => TNew)(cache, context);
+  }
+
+  private mergeProviders(
+    target: TClient,
+    source: Partial<TClient>,
+  ): TClient {
+    const result = { ...target } as Record<string, unknown>;
+    for (const key of Object.keys(source as object)) {
+      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 as Record<string, unknown>)[key];
+    }
+    return result as TClient;
+  }
 }

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

@@ -0,0 +1,40 @@
+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/core/src/factories/category.factory.ts

@@ -0,0 +1,40 @@
+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/core/src/factories/checkout.factory.ts

@@ -0,0 +1,59 @@
+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/core/src/factories/identity.factory.ts

@@ -0,0 +1,26 @@
+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/core/src/factories/index.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/core/src/factories/inventory.factory.ts

@@ -0,0 +1,26 @@
+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/core/src/factories/order-search.factory.ts

@@ -0,0 +1,33 @@
+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/core/src/factories/order.factory.ts

@@ -0,0 +1,21 @@
+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/core/src/factories/price.factory.ts

@@ -0,0 +1,29 @@
+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/core/src/factories/product-associations.factory.ts

@@ -0,0 +1,30 @@
+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/core/src/factories/product-list.factory.ts

@@ -0,0 +1,82 @@
+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/core/src/factories/product-reviews.factory.ts

@@ -0,0 +1,58 @@
+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/core/src/factories/product-search.factory.ts

@@ -0,0 +1,31 @@
+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/core/src/factories/product.factory.ts

@@ -0,0 +1,21 @@
+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>;
+};