@reactionary/source 0.3.18 → 0.6.2

package/providers/commercetools/src/test/client-builder-merge-extensions.example.ts

@@ -0,0 +1,125 @@
+import {
+  ClientBuilder,
+  createInitialRequestContext,
+  NoOpCache,
+  ProductSchema,
+  StoreSchema,
+  type RequestContext,
+} from '@reactionary/core';
+import type { ProductProjection, Channel } from '@commercetools/platform-sdk';
+import * as z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import { withCommercetoolsCapabilities } from '../core/initialize.js';
+import { CommercetoolsProductFactory } from '../factories/product/product.factory.js';
+import { CommercetoolsStoreFactory } from '../factories/store/store.factory.js';
+import { assertNotAny, assertType } from '../factories/product/utils.example.js';
+
+const ExtendedProductSchema = ProductSchema.safeExtend({
+  extendedProductValue: z.string(),
+});
+
+class ExtendedCommercetoolsProductFactory extends CommercetoolsProductFactory<
+  typeof ExtendedProductSchema
+> {
+  constructor() {
+    super(ExtendedProductSchema);
+  }
+
+  public override parseProduct(context: RequestContext, data: ProductProjection) {
+    const base = super.parseProduct(context, data);
+    return this.productSchema.parse({
+      ...base,
+      extendedProductValue: 'from-product-factory',
+    });
+  }
+}
+
+const ExtendedStoreSchema = StoreSchema.safeExtend({
+  extendedStoreValue: z.string(),
+});
+
+class ExtendedCommercetoolsStoreFactory extends CommercetoolsStoreFactory<
+  typeof ExtendedStoreSchema
+> {
+  constructor() {
+    super(ExtendedStoreSchema);
+  }
+
+  public override parseStore(context: RequestContext, data: Channel) {
+    const base = super.parseStore(context, data);
+    return this.storeSchema.parse({
+      ...base,
+      extendedStoreValue: 'from-store-factory',
+    });
+  }
+}
+
+const config = {
+  apiUrl: 'https://api.example.invalid',
+  authUrl: 'https://auth.example.invalid',
+  clientId: 'test-client',
+  clientSecret: 'test-secret',
+  projectKey: 'test-project',
+  scopes: [],
+  paymentMethods: [],
+  facetFieldsForSearch: [],
+} satisfies CommercetoolsConfiguration;
+
+function createMergedClientExample() {
+  const cache = new NoOpCache();
+  const context = createInitialRequestContext();
+
+  const withProduct = withCommercetoolsCapabilities(config, {
+    product: {
+      enabled: true,
+      factory: new ExtendedCommercetoolsProductFactory(),
+    },
+  });
+
+  const withStore = withCommercetoolsCapabilities(config, {
+    store: {
+      enabled: true,
+      factory: new ExtendedCommercetoolsStoreFactory(),
+    },
+  });
+
+  const client = new ClientBuilder(context)
+    .withCache(cache)
+    .withCapability(withProduct)
+    .withCapability(withStore)
+    .build();
+
+  client.product
+    .getById({
+      identifier: { key: 'p-1' },
+    })
+    .then((result) => {
+      assertNotAny(result);
+      if (result.success) {
+        assertNotAny(result.value);
+        assertNotAny(result.value.extendedProductValue);
+        assertType<string>(result.value.extendedProductValue);
+      }
+    });
+
+  client.store
+    .queryByProximity({
+      longitude: 10.0,
+      latitude: 56.0,
+      distance: 50,
+      limit: 5,
+    })
+    .then((result) => {
+      assertNotAny(result);
+      if (result.success) {
+        const first = result.value[0];
+        assertNotAny(first);
+        assertNotAny(first.extendedStoreValue);
+        assertType<string>(first.extendedStoreValue);
+      }
+    });
+
+  return client;
+}
+
+void createMergedClientExample;

package/providers/fake/src/core/initialize.ts

@@ -1,12 +1,31 @@
-import type {
-  Cache as ReactinaryCache,
-  RequestContext,
-  ClientFromCapabilities,
+import type { Cache as ReactinaryCache, RequestContext } from '@reactionary/core';
+import {
+  CartIdentifierSchema as CoreCartIdentifierSchema,
+  CartSchema as CoreCartSchema,
+  CategoryPaginatedResultSchema as CoreCategoryPaginatedResultSchema,
+  CategorySchema as CoreCategorySchema,
+  CheckoutSchema as CoreCheckoutSchema,
+  IdentitySchema as CoreIdentitySchema,
+  InventorySchema as CoreInventorySchema,
+  OrderSchema as CoreOrderSchema,
+  OrderSearchResultSchema as CoreOrderSearchResultSchema,
+  PaymentMethodSchema as CorePaymentMethodSchema,
+  PriceSchema as CorePriceSchema,
+  ProductAssociationSchema as CoreProductAssociationSchema,
+  ProductRatingSummarySchema as CoreProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema as CoreProductReviewPaginatedResultSchema,
+  ProductReviewSchema as CoreProductReviewSchema,
+  ProductSchema as CoreProductSchema,
+  ProductSearchResultSchema as CoreProductSearchResultSchema,
+  ProfileSchema as CoreProfileSchema,
+  ShippingMethodSchema as CoreShippingMethodSchema,
+  StoreSchema as CoreStoreSchema,
 } from '@reactionary/core';
 import { FakeProductProvider } from '../providers/product.provider.js';
 import { FakeSearchProvider } from '../providers/product-search.provider.js';
 import type { FakeConfiguration } from '../schema/configuration.schema.js';
 import type { FakeCapabilities } from '../schema/capabilities.schema.js';
+import { FakeCapabilitiesSchema } from '../schema/capabilities.schema.js';
 import { FakeCategoryProvider } from '../providers/category.provider.js';
 import {
   FakeCartProvider,
@@ -21,83 +40,233 @@ import { FakeOrderProvider } from '../providers/order.provider.js';
 import { FakeProfileProvider } from '../providers/profile.provider.js';
 import { FakeProductReviewsProvider } from '../providers/product-reviews.provider.js';
 import { FakeProductAssociationsProvider } from '../providers/product-associations.provider.js';
+import {
+  FakeCartFactory,
+  FakeCategoryFactory,
+  FakeCheckoutFactory,
+  FakeIdentityFactory,
+  FakeInventoryFactory,
+  FakeOrderFactory,
+  FakeOrderSearchFactory,
+  FakePriceFactory,
+  FakeProductAssociationsFactory,
+  FakeProductFactory,
+  FakeProductReviewsFactory,
+  FakeProductSearchFactory,
+  FakeProfileFactory,
+  FakeStoreFactory,
+} from '../factories/index.js';
+import {
+  type FakeClientFromCapabilities,
+  resolveCapabilityProvider,
+} from './initialize.types.js';
 
 export function withFakeCapabilities<T extends FakeCapabilities>(
   configuration: FakeConfiguration,
-  capabilities: T
+  capabilities: T,
 ) {
   return (
     cache: ReactinaryCache,
-    context: RequestContext
-  ): ClientFromCapabilities<T> => {
+    context: RequestContext,
+  ): FakeClientFromCapabilities<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const client: any = {};
+    const caps = FakeCapabilitiesSchema.parse(capabilities);
+
+    const buildProviderArgs = <TFactory,>(factory: TFactory) => ({
+      cache,
+      context,
+      config: configuration,
+      factory,
+    });
 
-    if (capabilities.product) {
-      client.product = new FakeProductProvider(configuration, cache, context);
+    if (caps.product?.enabled) {
+      client.product = resolveCapabilityProvider(
+        capabilities.product,
+        {
+          factory: new FakeProductFactory(CoreProductSchema),
+          provider: (args) =>
+            new FakeProductProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.productSearch) {
-      client.productSearch = new FakeSearchProvider(
-        configuration,
-        cache,
-        context
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityProvider(
+        capabilities.productSearch,
+        {
+          factory: new FakeProductSearchFactory(CoreProductSearchResultSchema),
+          provider: (args) =>
+            new FakeSearchProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
       );
     }
 
-    if (capabilities.category) {
-      client.category = new FakeCategoryProvider(configuration, cache, context);
+    if (caps.category?.enabled) {
+      client.category = resolveCapabilityProvider(
+        capabilities.category,
+        {
+          factory: new FakeCategoryFactory(
+            CoreCategorySchema,
+            CoreCategoryPaginatedResultSchema,
+          ),
+          provider: (args) =>
+            new FakeCategoryProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.cart) {
-      client.cart = new FakeCartProvider(configuration, cache, context);
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityProvider(
+        capabilities.cart,
+        {
+          factory: new FakeCartFactory(CoreCartSchema, CoreCartIdentifierSchema),
+          provider: (args) =>
+            new FakeCartProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.inventory) {
-      client.inventory = new FakeInventoryProvider(
-        configuration,
-        cache,
-        context
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityProvider(
+        capabilities.inventory,
+        {
+          factory: new FakeInventoryFactory(CoreInventorySchema),
+          provider: (args) =>
+            new FakeInventoryProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
       );
     }
 
-    if (capabilities.store) {
-      client.store = new FakeStoreProvider(configuration, cache, context);
+    if (caps.store?.enabled) {
+      client.store = resolveCapabilityProvider(
+        capabilities.store,
+        {
+          factory: new FakeStoreFactory(CoreStoreSchema),
+          provider: (args) =>
+            new FakeStoreProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.price) {
-      client.price = new FakePriceProvider(configuration, cache, context);
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityProvider(
+        capabilities.price,
+        {
+          factory: new FakePriceFactory(CorePriceSchema),
+          provider: (args) =>
+            new FakePriceProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.identity) {
-      client.identity = new FakeIdentityProvider(configuration, cache, context);
+    if (caps.identity?.enabled) {
+      client.identity = resolveCapabilityProvider(
+        capabilities.identity,
+        {
+          factory: new FakeIdentityFactory(CoreIdentitySchema),
+          provider: (args) =>
+            new FakeIdentityProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.checkout) {
-      client.checkout = new FakeCheckoutProvider(configuration, cache, context);
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityProvider(
+        capabilities.checkout,
+        {
+          factory: new FakeCheckoutFactory(
+            CoreCheckoutSchema,
+            CoreShippingMethodSchema,
+            CorePaymentMethodSchema,
+          ),
+          provider: (args) =>
+            new FakeCheckoutProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.orderSearch) {
-      client.orderSearch = new FakeOrderSearchProvider(
-        configuration,
-        cache,
-        context
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityProvider(
+        capabilities.orderSearch,
+        {
+          factory: new FakeOrderSearchFactory(CoreOrderSearchResultSchema),
+          provider: (args) =>
+            new FakeOrderSearchProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
       );
     }
 
-    if (capabilities.order) {
-      client.order = new FakeOrderProvider(configuration, cache, context);
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityProvider(
+        capabilities.order,
+        {
+          factory: new FakeOrderFactory(CoreOrderSchema),
+          provider: (args) =>
+            new FakeOrderProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.profile) {
-      client.profile = new FakeProfileProvider(configuration, cache, context);
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityProvider(
+        capabilities.profile,
+        {
+          factory: new FakeProfileFactory(CoreProfileSchema),
+          provider: (args) =>
+            new FakeProfileProvider(args.config, args.cache, args.context, args.factory),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.productReviews) {
-      client.productReviews = new FakeProductReviewsProvider(configuration, cache, context);
+    if (caps.productReviews?.enabled) {
+      client.productReviews = resolveCapabilityProvider(
+        capabilities.productReviews,
+        {
+          factory: new FakeProductReviewsFactory(
+            CoreProductRatingSummarySchema,
+            CoreProductReviewSchema,
+            CoreProductReviewPaginatedResultSchema,
+          ),
+          provider: (args) =>
+            new FakeProductReviewsProvider(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        buildProviderArgs,
+      );
     }
 
-    if (capabilities.productAssociations) {
-      client.productAssociations = new FakeProductAssociationsProvider(configuration, cache, context);
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityProvider(
+        capabilities.productAssociations,
+        {
+          factory: new FakeProductAssociationsFactory(CoreProductAssociationSchema),
+          provider: (args) =>
+            new FakeProductAssociationsProvider(
+              args.config,
+              args.cache,
+              args.context,
+              args.factory,
+            ),
+        },
+        buildProviderArgs,
+      );
     }
 
     return client;

package/providers/fake/src/core/initialize.types.ts

@@ -0,0 +1,164 @@
+import type {
+  CartFactory,
+  CategoryFactory,
+  CheckoutFactory,
+  ClientFromCapabilities,
+  IdentityFactory,
+  InventoryFactory,
+  OrderFactory,
+  OrderSearchFactory,
+  PriceFactory,
+  ProductAssociationsFactory,
+  ProductFactory,
+  ProductReviewsFactory,
+  ProductSearchFactory,
+  ProfileFactory,
+  StoreFactory,
+} from '@reactionary/core';
+import type { FakeCapabilities } from '../schema/capabilities.schema.js';
+import type { FakeCartFactory } from '../factories/cart/cart.factory.js';
+import type { FakeCategoryFactory } from '../factories/category/category.factory.js';
+import type { FakeCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { FakeIdentityFactory } from '../factories/identity/identity.factory.js';
+import type { FakeInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { FakeOrderFactory } from '../factories/order/order.factory.js';
+import type { FakeOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { FakePriceFactory } from '../factories/price/price.factory.js';
+import type { FakeProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import type { FakeProductFactory } from '../factories/product/product.factory.js';
+import type { FakeProductReviewsFactory } from '../factories/product-reviews/product-reviews.factory.js';
+import type { FakeProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { FakeProfileFactory } from '../factories/profile/profile.factory.js';
+import type { FakeStoreFactory } from '../factories/store/store.factory.js';
+import type { FakeCartProvider } from '../providers/cart.provider.js';
+import type { FakeCategoryProvider } from '../providers/category.provider.js';
+import type { FakeCheckoutProvider } from '../providers/checkout.provider.js';
+import type { FakeIdentityProvider } from '../providers/identity.provider.js';
+import type { FakeInventoryProvider } from '../providers/inventory.provider.js';
+import type { FakeOrderProvider } from '../providers/order.provider.js';
+import type { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
+import type { FakePriceProvider } from '../providers/price.provider.js';
+import type { FakeProductAssociationsProvider } from '../providers/product-associations.provider.js';
+import type { FakeProductProvider } from '../providers/product.provider.js';
+import type { FakeProductReviewsProvider } from '../providers/product-reviews.provider.js';
+import type { FakeSearchProvider } from '../providers/product-search.provider.js';
+import type { FakeProfileProvider } from '../providers/profile.provider.js';
+import type { FakeStoreProvider } from '../providers/store.provider.js';
+
+type FakeCapabilityKey = keyof FakeCapabilities;
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey]?: EnabledCapability<T[K]>;
+};
+
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
+  TCapability extends { enabled: true; factory?: infer TFactory }
+    ? TFactory extends TContract
+      ? TFactory
+      : TDefaultFactory
+    : TDefaultFactory;
+
+type ExtractCapabilityProvider<TCapability, TDefaultProvider> =
+  TCapability extends { enabled: true; provider?: infer TProviderFactory }
+    ? TProviderFactory extends (...args: unknown[]) => infer TProvider
+      ? TProvider
+      : TDefaultProvider
+    : TDefaultProvider;
+
+type FactoryContractMap = {
+  product: ProductFactory;
+  productSearch: ProductSearchFactory;
+  identity: IdentityFactory;
+  category: CategoryFactory;
+  cart: CartFactory;
+  inventory: InventoryFactory;
+  store: StoreFactory;
+  price: PriceFactory;
+  checkout: CheckoutFactory;
+  order: OrderFactory;
+  orderSearch: OrderSearchFactory;
+  profile: ProfileFactory;
+  productReviews: ProductReviewsFactory;
+  productAssociations: ProductAssociationsFactory;
+};
+
+type DefaultFactoryMap = {
+  product: FakeProductFactory;
+  productSearch: FakeProductSearchFactory;
+  identity: FakeIdentityFactory;
+  category: FakeCategoryFactory;
+  cart: FakeCartFactory;
+  inventory: FakeInventoryFactory;
+  store: FakeStoreFactory;
+  price: FakePriceFactory;
+  checkout: FakeCheckoutFactory;
+  order: FakeOrderFactory;
+  orderSearch: FakeOrderSearchFactory;
+  profile: FakeProfileFactory;
+  productReviews: FakeProductReviewsFactory;
+  productAssociations: FakeProductAssociationsFactory;
+};
+
+type ResolvedFactoryMap<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey]: ExtractCapabilityFactory<
+    T[K],
+    FactoryContractMap[K],
+    DefaultFactoryMap[K]
+  >;
+};
+
+type DefaultProviderMap<T extends FakeCapabilities> = {
+  product: FakeProductProvider<ResolvedFactoryMap<T>['product']>;
+  productSearch: FakeSearchProvider<ResolvedFactoryMap<T>['productSearch']>;
+  identity: FakeIdentityProvider<ResolvedFactoryMap<T>['identity']>;
+  category: FakeCategoryProvider<ResolvedFactoryMap<T>['category']>;
+  cart: FakeCartProvider<ResolvedFactoryMap<T>['cart']>;
+  inventory: FakeInventoryProvider<ResolvedFactoryMap<T>['inventory']>;
+  store: FakeStoreProvider<ResolvedFactoryMap<T>['store']>;
+  price: FakePriceProvider<ResolvedFactoryMap<T>['price']>;
+  checkout: FakeCheckoutProvider<ResolvedFactoryMap<T>['checkout']>;
+  order: FakeOrderProvider<ResolvedFactoryMap<T>['order']>;
+  orderSearch: FakeOrderSearchProvider<ResolvedFactoryMap<T>['orderSearch']>;
+  profile: FakeProfileProvider<ResolvedFactoryMap<T>['profile']>;
+  productReviews: FakeProductReviewsProvider<ResolvedFactoryMap<T>['productReviews']>;
+  productAssociations: FakeProductAssociationsProvider<
+    ResolvedFactoryMap<T>['productAssociations']
+  >;
+};
+
+type CapabilityProviderTypeMap<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey]: ExtractCapabilityProvider<T[K], DefaultProviderMap<T>[K]>;
+};
+
+type EnabledCapabilityOverrideMap<T extends FakeCapabilities> = {
+  [K in FakeCapabilityKey as T[K] extends { enabled: true } ? K : never]:
+    CapabilityProviderTypeMap<T>[K];
+};
+
+export type FakeClientFromCapabilities<T extends FakeCapabilities> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  FakeCapabilityKey
+> &
+  EnabledCapabilityOverrideMap<T>;
+
+export function resolveCapabilityProvider<TFactory, TProvider, TProviderArgs>(
+  capability:
+    | {
+        factory?: TFactory;
+        provider?: (args: TProviderArgs) => TProvider;
+      }
+    | undefined,
+  defaults: {
+    factory: TFactory;
+    provider: (args: TProviderArgs) => TProvider;
+  },
+  buildProviderArgs: (factory: TFactory) => TProviderArgs,
+): TProvider {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+
+  return provider(buildProviderArgs(factory));
+}

package/providers/fake/src/factories/cart/cart.factory.ts

@@ -0,0 +1,34 @@
+import type {
+  AnyCartIdentifierSchema,
+  AnyCartSchema,
+  CartFactory,
+  CartIdentifierSchema,
+  CartSchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeCartFactory<
+  TCartSchema extends AnyCartSchema = typeof CartSchema,
+  TCartIdentifierSchema extends AnyCartIdentifierSchema = typeof CartIdentifierSchema,
+> implements CartFactory<TCartSchema, TCartIdentifierSchema>
+{
+  public readonly cartSchema: TCartSchema;
+  public readonly cartIdentifierSchema: TCartIdentifierSchema;
+
+  constructor(cartSchema: TCartSchema, cartIdentifierSchema: TCartIdentifierSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+  }
+
+  public parseCart(_context: RequestContext, data: unknown): z.output<TCartSchema> {
+    return this.cartSchema.parse(data);
+  }
+
+  public parseCartIdentifier(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TCartIdentifierSchema> {
+    return this.cartIdentifierSchema.parse(data);
+  }
+}

package/providers/fake/src/factories/category/category.factory.ts

@@ -0,0 +1,40 @@
+import type {
+  AnyCategoryPaginatedResultSchema,
+  AnyCategorySchema,
+  CategoryFactory,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class FakeCategoryFactory<
+  TCategorySchema extends AnyCategorySchema = typeof CategorySchema,
+  TCategoryPaginatedSchema extends AnyCategoryPaginatedResultSchema = typeof CategoryPaginatedResultSchema,
+> implements CategoryFactory<TCategorySchema, TCategoryPaginatedSchema>
+{
+  public readonly categorySchema: TCategorySchema;
+  public readonly categoryPaginatedResultSchema: TCategoryPaginatedSchema;
+
+  constructor(
+    categorySchema: TCategorySchema,
+    categoryPaginatedResultSchema: TCategoryPaginatedSchema,
+  ) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+
+  public parseCategory(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TCategorySchema> {
+    return this.categorySchema.parse(data);
+  }
+
+  public parseCategoryPaginatedResult(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TCategoryPaginatedSchema> {
+    return this.categoryPaginatedResultSchema.parse(data);
+  }
+}