@reactionary/source 0.6.1 → 0.6.3

package/packages/medusa/src/core/initialize.ts

@@ -0,0 +1,330 @@
+import type {
+  Cache,
+  RequestContext,
+} from '@reactionary/core';
+import {
+  CartIdentifierSchema,
+  CartSchema,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  CheckoutSchema,
+  InventorySchema,
+  OrderSchema,
+  OrderSearchResultSchema,
+  PaymentMethodSchema,
+  PriceSchema,
+  ProductAssociationSchema,
+  ProductSchema,
+  ProductSearchResultSchema,
+  ProfileSchema,
+  ShippingMethodSchema,
+} from '@reactionary/core';
+import { MedusaCartCapability } from '../capabilities/cart.capability.js';
+import { MedusaCategoryCapability } from '../capabilities/category.capability.js';
+import { MedusaCheckoutCapability } from '../capabilities/checkout.capability.js';
+import { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
+import { MedusaInventoryCapability } from '../capabilities/inventory.capability.js';
+import { MedusaOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import { MedusaOrderCapability } from '../capabilities/order.capability.js';
+import { MedusaPriceCapability } from '../capabilities/price.capability.js';
+import { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
+import { MedusaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import { MedusaProductCapability } from '../capabilities/product.capability.js';
+import { MedusaProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import { MedusaProfileCapability } from '../capabilities/profile.capability.js';
+import {
+  MedusaCapabilitiesSchema,
+  type MedusaCapabilities,
+} from '../schema/capabilities.schema.js';
+import {
+  MedusaConfigurationSchema,
+  type MedusaConfiguration,
+} from '../schema/configuration.schema.js';
+import { MedusaAPI } from './client.js';
+import {
+  MedusaCartFactory,
+  MedusaCategoryFactory,
+  MedusaCheckoutFactory,
+  MedusaInventoryFactory,
+  MedusaOrderFactory,
+  MedusaOrderSearchFactory,
+  MedusaPriceFactory,
+  MedusaProductAssociationsFactory,
+  MedusaProductFactory,
+  MedusaProductSearchFactory,
+  MedusaProfileFactory,
+} from '../factories/index.js';
+import {
+  type MedusaClientFromCapabilities,
+  resolveCapabilityWithFactory,
+  resolveDirectCapability,
+} from './initialize.types.js';
+
+export function withMedusaCapabilities<T extends MedusaCapabilities>(
+  configuration: MedusaConfiguration,
+  capabilities: T,
+) {
+  return (
+    cache: Cache,
+    context: RequestContext,
+  ): MedusaClientFromCapabilities<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client: any = {};
+    const config = MedusaConfigurationSchema.parse(configuration);
+    const caps = MedusaCapabilitiesSchema.parse(capabilities);
+    const medusaApi = new MedusaAPI(config, context);
+
+    const buildCapabilityArgs = <TFactory,>(factory: TFactory) => ({
+      cache,
+      context,
+      config,
+      medusaApi,
+      factory,
+    });
+
+    if (caps.product?.enabled) {
+      client.product = resolveCapabilityWithFactory(
+        capabilities.product,
+        {
+          factory: new MedusaProductFactory(ProductSchema),
+          capability: (args) =>
+            new MedusaProductCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityWithFactory(
+        capabilities.productSearch,
+        {
+          factory: new MedusaProductSearchFactory(ProductSearchResultSchema),
+          capability: (args) =>
+            new MedusaProductSearchCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.category?.enabled) {
+      client.category = resolveCapabilityWithFactory(
+        capabilities.category,
+        {
+          factory: new MedusaCategoryFactory(
+            CategorySchema,
+            CategoryPaginatedResultSchema,
+          ),
+          capability: (args) =>
+            new MedusaCategoryCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityWithFactory(
+        capabilities.checkout,
+        {
+          factory: new MedusaCheckoutFactory(
+            CheckoutSchema,
+            ShippingMethodSchema,
+            PaymentMethodSchema,
+          ),
+          capability: (args) =>
+            new MedusaCheckoutCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.productRecommendations?.enabled) {
+      client.productRecommendations = resolveDirectCapability(
+        capabilities.productRecommendations,
+        (args) =>
+          new MedusaProductRecommendationsCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+          ),
+        {
+          cache,
+          context,
+          config,
+          medusaApi,
+        },
+      );
+    }
+
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityWithFactory(
+        capabilities.cart,
+        {
+          factory: new MedusaCartFactory(CartSchema, CartIdentifierSchema),
+          capability: (args) =>
+            new MedusaCartCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityWithFactory(
+        capabilities.price,
+        {
+          factory: new MedusaPriceFactory(PriceSchema),
+          capability: (args) =>
+            new MedusaPriceCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityWithFactory(
+        capabilities.inventory,
+        {
+          factory: new MedusaInventoryFactory(InventorySchema),
+          capability: (args) =>
+            new MedusaInventoryCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.identity?.enabled) {
+      client.identity = resolveDirectCapability(
+        capabilities.identity,
+        (args) =>
+          new MedusaIdentityCapability(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+          ),
+        {
+          cache,
+          context,
+          config,
+          medusaApi,
+        },
+      );
+    }
+
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityWithFactory(
+        capabilities.profile,
+        {
+          factory: new MedusaProfileFactory(ProfileSchema),
+          capability: (args) =>
+            new MedusaProfileCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityWithFactory(
+        capabilities.order,
+        {
+          factory: new MedusaOrderFactory(OrderSchema),
+          capability: (args) =>
+            new MedusaOrderCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityWithFactory(
+        capabilities.orderSearch,
+        {
+          factory: new MedusaOrderSearchFactory(OrderSearchResultSchema),
+          capability: (args) =>
+            new MedusaOrderSearchCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityWithFactory(
+        capabilities.productAssociations,
+        {
+          factory: new MedusaProductAssociationsFactory(ProductAssociationSchema),
+          capability: (args) =>
+            new MedusaProductAssociationsCapability(
+              args.config,
+              args.cache,
+              args.context,
+              args.medusaApi,
+              args.factory,
+            ),
+        },
+        buildCapabilityArgs,
+      );
+    }
+
+    return client;
+  };
+}

package/packages/medusa/src/core/initialize.types.ts

@@ -0,0 +1,184 @@
+import type {
+  CartFactory,
+  CategoryFactory,
+  CheckoutFactory,
+  ClientFromCapabilities,
+  InventoryFactory,
+  OrderFactory,
+  OrderSearchFactory,
+  PriceFactory,
+  ProductAssociationsFactory,
+  ProductFactory,
+  ProductRecommendationsCapability,
+  ProductSearchFactory,
+  ProfileFactory,
+} from '@reactionary/core';
+import type { MedusaCapabilities } from '../schema/capabilities.schema.js';
+import type { MedusaCartFactory } from '../factories/cart/cart.factory.js';
+import type { MedusaCategoryFactory } from '../factories/category/category.factory.js';
+import type { MedusaCheckoutFactory } from '../factories/checkout/checkout.factory.js';
+import type { MedusaInventoryFactory } from '../factories/inventory/inventory.factory.js';
+import type { MedusaOrderFactory } from '../factories/order/order.factory.js';
+import type { MedusaOrderSearchFactory } from '../factories/order-search/order-search.factory.js';
+import type { MedusaPriceFactory } from '../factories/price/price.factory.js';
+import type { MedusaProductAssociationsFactory } from '../factories/product-associations/product-associations.factory.js';
+import type { MedusaProductFactory } from '../factories/product/product.factory.js';
+import type { MedusaProductSearchFactory } from '../factories/product-search/product-search.factory.js';
+import type { MedusaProfileFactory } from '../factories/profile/profile.factory.js';
+import type { MedusaCartCapability } from '../capabilities/cart.capability.js';
+import type { MedusaCategoryCapability } from '../capabilities/category.capability.js';
+import type { MedusaCheckoutCapability } from '../capabilities/checkout.capability.js';
+import type { MedusaInventoryCapability } from '../capabilities/inventory.capability.js';
+import type { MedusaOrderCapability } from '../capabilities/order.capability.js';
+import type { MedusaOrderSearchCapability } from '../capabilities/order-search.capability.js';
+import type { MedusaPriceCapability } from '../capabilities/price.capability.js';
+import type { MedusaProductAssociationsCapability } from '../capabilities/product-associations.capability.js';
+import type { MedusaProductCapability } from '../capabilities/product.capability.js';
+import type { MedusaProductSearchCapability } from '../capabilities/product-search.capability.js';
+import type { MedusaProfileCapability } from '../capabilities/profile.capability.js';
+import type { MedusaProductRecommendationsCapability } from '../capabilities/product-recommendations.capability.js';
+import type { MedusaIdentityCapability } from '../capabilities/identity.capability.js';
+
+type OverridableCapabilityKey =
+  | 'product'
+  | 'productSearch'
+  | 'cart'
+  | 'checkout'
+  | 'category'
+  | 'price'
+  | 'order'
+  | 'orderSearch'
+  | 'inventory'
+  | 'profile'
+  | 'productAssociations';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends MedusaCapabilities> =
+  Omit<T, OverridableCapabilityKey | 'productRecommendations'> & {
+    [K in OverridableCapabilityKey]?: EnabledCapability<T[K]>;
+  } & {
+    productRecommendations?: EnabledCapability<T['productRecommendations']>;
+    identity?: EnabledCapability<T['identity']>;
+  };
+
+type ExtractCapabilityFactory<TCapability, TContract, TDefaultFactory> =
+  TCapability extends { enabled: true; factory?: infer TFactory }
+    ? TFactory extends TContract
+      ? TFactory
+      : TDefaultFactory
+    : TDefaultFactory;
+
+type ExtractCapabilityImplementation<TCapability, TDefaultCapability> =
+  TCapability extends { enabled: true; capability?: infer TCapabilityFactory }
+    ? TCapabilityFactory extends (...args: unknown[]) => infer TResolvedCapability
+      ? TResolvedCapability
+      : TDefaultCapability
+    : TDefaultCapability;
+
+type FactoryContractMap = {
+  product: ProductFactory;
+  productSearch: ProductSearchFactory;
+  cart: CartFactory;
+  checkout: CheckoutFactory;
+  category: CategoryFactory;
+  price: PriceFactory;
+  order: OrderFactory;
+  orderSearch: OrderSearchFactory;
+  inventory: InventoryFactory;
+  profile: ProfileFactory;
+  productAssociations: ProductAssociationsFactory;
+};
+
+type DefaultFactoryMap = {
+  product: MedusaProductFactory;
+  productSearch: MedusaProductSearchFactory;
+  cart: MedusaCartFactory;
+  checkout: MedusaCheckoutFactory;
+  category: MedusaCategoryFactory;
+  price: MedusaPriceFactory;
+  order: MedusaOrderFactory;
+  orderSearch: MedusaOrderSearchFactory;
+  inventory: MedusaInventoryFactory;
+  profile: MedusaProfileFactory;
+  productAssociations: MedusaProductAssociationsFactory;
+};
+
+type ResolvedFactoryMap<T extends MedusaCapabilities> = {
+  [K in OverridableCapabilityKey]: ExtractCapabilityFactory<
+    T[K],
+    FactoryContractMap[K],
+    DefaultFactoryMap[K]
+  >;
+};
+
+type DefaultCapabilityMap<T extends MedusaCapabilities> = {
+  product: MedusaProductCapability<ResolvedFactoryMap<T>['product']>;
+  productSearch: MedusaProductSearchCapability<ResolvedFactoryMap<T>['productSearch']>;
+  cart: MedusaCartCapability<ResolvedFactoryMap<T>['cart']>;
+  checkout: MedusaCheckoutCapability<ResolvedFactoryMap<T>['checkout']>;
+  category: MedusaCategoryCapability<ResolvedFactoryMap<T>['category']>;
+  price: MedusaPriceCapability<ResolvedFactoryMap<T>['price']>;
+  order: MedusaOrderCapability<ResolvedFactoryMap<T>['order']>;
+  orderSearch: MedusaOrderSearchCapability<ResolvedFactoryMap<T>['orderSearch']>;
+  inventory: MedusaInventoryCapability<ResolvedFactoryMap<T>['inventory']>;
+  profile: MedusaProfileCapability<ResolvedFactoryMap<T>['profile']>;
+  productAssociations: MedusaProductAssociationsCapability<
+    ResolvedFactoryMap<T>['productAssociations']
+  >;
+  identity: MedusaIdentityCapability;
+  productRecommendations: MedusaProductRecommendationsCapability;
+};
+
+type CapabilityImplementationMap<T extends MedusaCapabilities> = {
+  [K in OverridableCapabilityKey | 'productRecommendations' | 'identity']: ExtractCapabilityImplementation<
+    T[K],
+    DefaultCapabilityMap<T>[K]
+  >;
+};
+
+type EnabledCapabilityOverrideMap<T extends MedusaCapabilities> = {
+  [K in OverridableCapabilityKey | 'productRecommendations' | 'identity' as T[K] extends {
+    enabled: true;
+  }
+    ? K
+    : never]: CapabilityImplementationMap<T>[K];
+};
+
+export type MedusaClientFromCapabilities<T extends MedusaCapabilities> = Omit<
+  ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>,
+  OverridableCapabilityKey | 'productRecommendations' | 'identity'
+> &
+  EnabledCapabilityOverrideMap<T>;
+
+export function resolveCapabilityWithFactory<TFactory, TResolvedCapability, TCapabilityArgs>(
+  capability:
+    | {
+        factory?: TFactory;
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
+      }
+    | undefined,
+  defaults: {
+    factory: TFactory;
+    capability: (args: TCapabilityArgs) => TResolvedCapability;
+  },
+  buildCapabilityArgs: (factory: TFactory) => TCapabilityArgs,
+): TResolvedCapability {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+
+export function resolveDirectCapability<TResolvedCapability, TCapabilityArgs>(
+  capability:
+    | {
+        capability?: (args: TCapabilityArgs) => TResolvedCapability;
+      }
+    | undefined,
+  defaultCapability: (args: TCapabilityArgs) => TResolvedCapability,
+  args: TCapabilityArgs,
+): TResolvedCapability {
+  const capabilityFactory = capability?.capability ?? defaultCapability;
+  return capabilityFactory(args);
+}

package/packages/medusa/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 MedusaCartFactory<
+  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/packages/medusa/src/factories/category/category.factory.ts

@@ -0,0 +1,37 @@
+import type {
+  AnyCategoryPaginatedResultSchema,
+  AnyCategorySchema,
+  CategoryFactory,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaCategoryFactory<
+  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);
+  }
+}

package/packages/medusa/src/factories/checkout/checkout.factory.ts

@@ -0,0 +1,50 @@
+import type {
+  AnyCheckoutSchema,
+  AnyPaymentMethodSchema,
+  AnyShippingMethodSchema,
+  CheckoutFactory,
+  CheckoutSchema,
+  PaymentMethodSchema,
+  RequestContext,
+  ShippingMethodSchema,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaCheckoutFactory<
+  TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema,
+  TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema,
+  TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema,
+> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema>
+{
+  public readonly checkoutSchema: TCheckoutSchema;
+  public readonly shippingMethodSchema: TShippingMethodSchema;
+  public readonly paymentMethodSchema: TPaymentMethodSchema;
+
+  constructor(
+    checkoutSchema: TCheckoutSchema,
+    shippingMethodSchema: TShippingMethodSchema,
+    paymentMethodSchema: TPaymentMethodSchema,
+  ) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+
+  public parseCheckout(_context: RequestContext, data: unknown): z.output<TCheckoutSchema> {
+    return this.checkoutSchema.parse(data);
+  }
+
+  public parseShippingMethod(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TShippingMethodSchema> {
+    return this.shippingMethodSchema.parse(data);
+  }
+
+  public parsePaymentMethod(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TPaymentMethodSchema> {
+    return this.paymentMethodSchema.parse(data);
+  }
+}

package/packages/medusa/src/factories/identity/identity.factory.ts

@@ -0,0 +1,22 @@
+import type {
+  AnyIdentitySchema,
+  IdentityFactory,
+  IdentitySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaIdentityFactory<
+  TIdentitySchema extends AnyIdentitySchema = typeof IdentitySchema,
+> implements IdentityFactory<TIdentitySchema>
+{
+  public readonly identitySchema: TIdentitySchema;
+
+  constructor(identitySchema: TIdentitySchema) {
+    this.identitySchema = identitySchema;
+  }
+
+  public parseIdentity(_context: RequestContext, data: unknown): z.output<TIdentitySchema> {
+    return this.identitySchema.parse(data);
+  }
+}

package/packages/medusa/src/factories/index.ts

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

package/packages/medusa/src/factories/inventory/inventory.factory.ts

@@ -0,0 +1,25 @@
+import type {
+  AnyInventorySchema,
+  InventoryFactory,
+  InventorySchema,
+  RequestContext,
+} from '@reactionary/core';
+import type * as z from 'zod';
+
+export class MedusaInventoryFactory<
+  TInventorySchema extends AnyInventorySchema = typeof InventorySchema,
+> implements InventoryFactory<TInventorySchema>
+{
+  public readonly inventorySchema: TInventorySchema;
+
+  constructor(inventorySchema: TInventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+
+  public parseInventory(
+    _context: RequestContext,
+    data: unknown,
+  ): z.output<TInventorySchema> {
+    return this.inventorySchema.parse(data);
+  }
+}