@reactionary/source 0.6.1 → 0.6.3

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

@@ -0,0 +1,131 @@
+import type { Cache } from '../cache/cache.interface.js';
+import { NoOpCache } from '../cache/noop-cache.js';
+import type { Client } from './client.js';
+import { MulticastAnalyticsCapability, type AnalyticsCapability } from '../capabilities/analytics.capability.js';
+import {
+  RequestContextSchema,
+  type RequestContext,
+} from '../schemas/session.schema.js';
+import { MulticastProductRecommendationsCapability, type ProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+
+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;
+  }
+
+  withCapability<TNew extends Partial<Client>>(
+    factory: CapabilityFactory<TNew>
+  ): ClientBuilder<MergeCapabilities<TClient, TNew>> {
+    const newBuilder = new ClientBuilder<MergeCapabilities<TClient, TNew>>(this.context);
+    newBuilder.factories = [...this.factories, factory];
+    newBuilder.cache = this.cache;
+    newBuilder.context = this.context;
+    newBuilder.collisionStrategy = this.collisionStrategy;
+    return newBuilder;
+  }
+
+  withCache(cache: Cache): ClientBuilder<TClient> {
+    const newBuilder = new ClientBuilder<TClient>(this.context);
+    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;
+  }
+
+  build(): TClient & { cache: Cache } {
+    let client = {} as TClient;
+
+    // Default to no-op cache if none is provided
+    const sharedCache = this.cache || new NoOpCache();
+    const validatedContext = RequestContextSchema.safeParse(this.context);
+
+    // Avoid returning the parsed result for context, to preserve object equality at the top level
+    if (!validatedContext.success) {
+      throw new Error('Invalid context: ' + validatedContext.error);
+    }
+
+    const mergedAnalytics: AnalyticsCapability[] = [];
+    const mergedProductRecommendations: ProductRecommendationsCapability[] = [];
+
+    for (const factory of this.factories) {
+      const capability = this.resolveFactory(factory, sharedCache, this.context);
+      client = this.mergeCapabilities(client, capability as Partial<TClient>);
+
+      if (capability.analytics) {
+        mergedAnalytics.push(capability.analytics);
+      }
+
+      if (capability.productRecommendations) {
+        mergedProductRecommendations.push(capability.productRecommendations);
+      }
+    }
+
+    // Add cache to complete the client
+    const completeClient = {
+      ...client,
+      analytics: new MulticastAnalyticsCapability(sharedCache, this.context, mergedAnalytics),
+      productRecommendations: new MulticastProductRecommendationsCapability(sharedCache, this.context, mergedProductRecommendations),
+      cache: sharedCache,
+    } as TClient & { cache: Cache };
+
+    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 mergeCapabilities(
+    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/packages/core/src/client/client.ts

@@ -0,0 +1,35 @@
+import type { ProductCapability } from "../capabilities/product.capability.js";
+import type { ProductSearchCapability } from "../capabilities/product-search.capability.js";
+import type { IdentityCapability } from '../capabilities/identity.capability.js';
+import type { CartCapability } from "../capabilities/cart.capability.js";
+import type { PriceCapability } from "../capabilities/price.capability.js";
+import type { InventoryCapability } from "../capabilities/inventory.capability.js";
+import type { Cache } from "../cache/cache.interface.js";
+import type { CategoryCapability } from "../capabilities/category.capability.js";
+import type { AnalyticsCapability, CheckoutCapability, OrderCapability, ProductListCapability, ProfileCapability, StoreCapability } from "../capabilities/index.js";
+import type { OrderSearchCapability } from "../capabilities/order-search.capability.js";
+import type { ProductRecommendationsCapability } from "../capabilities/product-recommendations.capability.js";
+import type { ProductAssociationsCapability } from "../capabilities/product-associations.capability.js";
+import type { ProductReviewsCapability } from "../capabilities/product-reviews.capability.js";
+
+export interface Client {
+    product: ProductCapability,
+    productSearch: ProductSearchCapability,
+    productRecommendations: ProductRecommendationsCapability,
+    productAssociations: ProductAssociationsCapability,
+    productReviews: ProductReviewsCapability,
+    productList: ProductListCapability,
+    identity: IdentityCapability,
+    cache: Cache,
+    cart: CartCapability,
+    checkout: CheckoutCapability,
+    analytics: AnalyticsCapability,
+    price: PriceCapability,
+    inventory: InventoryCapability,
+    category: CategoryCapability,
+    profile: ProfileCapability,
+    store: StoreCapability,
+    order: OrderCapability,
+    orderSearch: OrderSearchCapability,
+}
+

package/{core → packages/core}/src/decorators/reactionary.decorator.ts

@@ -1,7 +1,7 @@
 import type { Tracer } from '@opentelemetry/api';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
 import * as z from 'zod';
-import type { BaseProvider } from '../providers/index.js';
+import type { BaseCapability } from '../capabilities/index.js';
 import { getReactionaryMeter } from '../metrics/metrics.js';
 import { error, success, type Result } from '../schemas/result.js';
 import type {
@@ -18,7 +18,7 @@ export function getTracer(): Tracer {
 }
 
 /**
- * The options associated with annotating a provider function and marking
+ * The options associated with annotating a capability function and marking
  * it as a reactionary entrypoint to be called
  */
 export class ReactionaryDecoratorOptions {
@@ -59,13 +59,13 @@ export class ReactionaryDecoratorOptions {
 }
 
 /**
- * Decorator for provider functions to provide functionality such as caching, tracing and type-checked
+ * Decorator for capability 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.
+ * capabilities.
  */
 export function Reactionary(options: Partial<ReactionaryDecoratorOptions>) {
   return function (
-    target: BaseProvider,
+    target: BaseCapability,
     propertyKey: string | symbol,
     descriptor: PropertyDescriptor
   ): PropertyDescriptor {
@@ -82,11 +82,11 @@ export function Reactionary(options: Partial<ReactionaryDecoratorOptions>) {
 
     if (!original) {
       throw new Error(
-        '@Reactionary decorator may only be applied to methods on classes extending BaseProvider.'
+        '@Reactionary decorator may only be applied to methods on classes extending BaseCapability.'
       );
     }
 
-    descriptor.value = async function (this: BaseProvider, ...args: any[]) {
+    descriptor.value = async function (this: BaseCapability, ...args: any[]) {
       return traceSpan(scope, async () => {
         meter.requestInProgress.add(1, attributes);
         try {

package/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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/packages/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>;
+  };