@reactionary/medusa 0.6.3

package/src/core/client.d.ts

@@ -0,0 +1,81 @@
+import { Admin, Auth, Client, type Config, Store } from '@medusajs/js-sdk';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import { type RequestContext } from '@reactionary/core';
+import { type MedusaSession } from '../index.js';
+import type { StoreProduct } from '@medusajs/types';
+export declare const SESSION_KEY = "MEDUSA_PROVIDER";
+export interface MedusaAuthToken {
+    token: string;
+    expires_at?: Date;
+}
+export interface MedusaCustomStorage {
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+export declare class RequestContextTokenStore implements MedusaCustomStorage {
+    protected context: RequestContext;
+    keyPrefix: string;
+    constructor(context: RequestContext, keyPrefix?: string);
+    getItem(key: string): Promise<string | null>;
+    setItem(key: string, value: string): Promise<void>;
+    removeItem(key: string): Promise<void>;
+}
+declare class Medusa {
+    client: Client;
+    admin: Admin;
+    store: Store;
+    auth: Auth;
+    constructor(config: Config);
+}
+export declare class MedusaAdminAPI {
+    protected config: MedusaConfiguration;
+    protected client: Medusa;
+    protected context: RequestContext;
+    constructor(config: MedusaConfiguration, context: RequestContext);
+    getClient(): Promise<Medusa>;
+}
+export declare class MedusaAPI {
+    protected config: MedusaConfiguration;
+    protected client: Promise<Medusa> | undefined;
+    protected context: RequestContext;
+    constructor(config: MedusaConfiguration, context: RequestContext);
+    getActiveRegion(): Promise<{
+        [x: string]: unknown;
+        id: string;
+        name: string;
+        currency_code: string;
+    }>;
+    resolveProductForSKU(sku: string): Promise<StoreProduct>;
+    /**
+     * This function should not need to exist.
+     * It returns a product-id, given a SKU.
+     * @param sku
+     * @returns
+     */
+    resolveVariantId(sku: string): Promise<string>;
+    getClient(): Promise<Medusa>;
+    getSessionData(): MedusaSession;
+    setSessionData(sessionData: Partial<MedusaSession>): void;
+    register(email: string, password: string, firstName: string, lastName: string, reqCtx: RequestContext): Promise<{
+        id: {
+            userId: string;
+        };
+        type: "Registered";
+    } | {
+        type: "Anonymous";
+    }>;
+    login(email: string, password: string, reqCtx: RequestContext): Promise<{
+        id: {
+            userId: string;
+        };
+        type: "Registered";
+    } | {
+        type: "Anonymous";
+    }>;
+    logout(reqCtx: RequestContext): Promise<{
+        type: "Anonymous";
+    }>;
+    protected createAuthenticatedClient(reqCtx: RequestContext): Promise<Medusa>;
+}
+export {};

package/src/core/initialize.d.ts

@@ -0,0 +1,5 @@
+import type { Cache, RequestContext } from '@reactionary/core';
+import { type MedusaCapabilities } from '../schema/capabilities.schema.js';
+import { type MedusaConfiguration } from '../schema/configuration.schema.js';
+import { type MedusaClientFromCapabilities } from './initialize.types.js';
+export declare function withMedusaCapabilities<T extends MedusaCapabilities>(configuration: MedusaConfiguration, capabilities: T): (cache: Cache, context: RequestContext) => MedusaClientFromCapabilities<T>;

package/src/core/initialize.types.d.ts

@@ -0,0 +1,108 @@
+import type { CartFactory, CategoryFactory, CheckoutFactory, ClientFromCapabilities, InventoryFactory, OrderFactory, OrderSearchFactory, PriceFactory, ProductAssociationsFactory, ProductFactory, 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 declare 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;
+export declare function resolveDirectCapability<TResolvedCapability, TCapabilityArgs>(capability: {
+    capability?: (args: TCapabilityArgs) => TResolvedCapability;
+} | undefined, defaultCapability: (args: TCapabilityArgs) => TResolvedCapability, args: TCapabilityArgs): TResolvedCapability;
+export {};

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

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

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

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

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

@@ -0,0 +1,11 @@
+import type { AnyCheckoutSchema, AnyPaymentMethodSchema, AnyShippingMethodSchema, CheckoutFactory, CheckoutSchema, PaymentMethodSchema, RequestContext, ShippingMethodSchema } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaCheckoutFactory<TCheckoutSchema extends AnyCheckoutSchema = typeof CheckoutSchema, TShippingMethodSchema extends AnyShippingMethodSchema = typeof ShippingMethodSchema, TPaymentMethodSchema extends AnyPaymentMethodSchema = typeof PaymentMethodSchema> implements CheckoutFactory<TCheckoutSchema, TShippingMethodSchema, TPaymentMethodSchema> {
+    readonly checkoutSchema: TCheckoutSchema;
+    readonly shippingMethodSchema: TShippingMethodSchema;
+    readonly paymentMethodSchema: TPaymentMethodSchema;
+    constructor(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>;
+}

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

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

package/src/factories/index.d.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/src/factories/inventory/inventory.factory.d.ts

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

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

@@ -0,0 +1,7 @@
+import type { AnyOrderSchema, OrderFactory, OrderSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaOrderFactory<TOrderSchema extends AnyOrderSchema = typeof OrderSchema> implements OrderFactory<TOrderSchema> {
+    readonly orderSchema: TOrderSchema;
+    constructor(orderSchema: TOrderSchema);
+    parseOrder(_context: RequestContext, data: unknown): z.output<TOrderSchema>;
+}

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

@@ -0,0 +1,7 @@
+import type { AnyOrderSearchResultSchema, OrderSearchFactory, OrderSearchQueryByTerm, OrderSearchResultSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaOrderSearchFactory<TOrderSearchResultSchema extends AnyOrderSearchResultSchema = typeof OrderSearchResultSchema> implements OrderSearchFactory<TOrderSearchResultSchema> {
+    readonly orderSearchResultSchema: TOrderSearchResultSchema;
+    constructor(orderSearchResultSchema: TOrderSearchResultSchema);
+    parseOrderSearchResult(_context: RequestContext, data: unknown, _query: OrderSearchQueryByTerm): z.output<TOrderSearchResultSchema>;
+}

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

@@ -0,0 +1,9 @@
+import type { AnyPriceSchema, PriceFactory, PriceSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaPriceFactory<TPriceSchema extends AnyPriceSchema = typeof PriceSchema> implements PriceFactory<TPriceSchema> {
+    readonly priceSchema: TPriceSchema;
+    constructor(priceSchema: TPriceSchema);
+    parsePrice(_context: RequestContext, data: unknown, _options?: {
+        includeDiscounts: boolean;
+    }): z.output<TPriceSchema>;
+}

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

@@ -0,0 +1,7 @@
+import type { AnyProductSchema, ProductFactory, ProductSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaProductFactory<TProductSchema extends AnyProductSchema = typeof ProductSchema> implements ProductFactory<TProductSchema> {
+    readonly productSchema: TProductSchema;
+    constructor(productSchema: TProductSchema);
+    parseProduct(_context: RequestContext, data: unknown): z.output<TProductSchema>;
+}

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

@@ -0,0 +1,7 @@
+import type { AnyProductAssociationSchema, ProductAssociationSchema, ProductAssociationsFactory, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaProductAssociationsFactory<TProductAssociationSchema extends AnyProductAssociationSchema = typeof ProductAssociationSchema> implements ProductAssociationsFactory<TProductAssociationSchema> {
+    readonly productAssociationSchema: TProductAssociationSchema;
+    constructor(productAssociationSchema: TProductAssociationSchema);
+    parseAssociation(_context: RequestContext, data: unknown): z.output<TProductAssociationSchema>;
+}

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

@@ -0,0 +1,7 @@
+import type { AnyProductSearchResultSchema, ProductSearchFactory, ProductSearchQueryByTerm, ProductSearchResultSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaProductSearchFactory<TProductSearchResultSchema extends AnyProductSearchResultSchema = typeof ProductSearchResultSchema> implements ProductSearchFactory<TProductSearchResultSchema> {
+    readonly productSearchResultSchema: TProductSearchResultSchema;
+    constructor(productSearchResultSchema: TProductSearchResultSchema);
+    parseSearchResult(_context: RequestContext, data: unknown, _query: ProductSearchQueryByTerm): z.output<TProductSearchResultSchema>;
+}

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

@@ -0,0 +1,7 @@
+import type { AnyProfileSchema, ProfileFactory, ProfileSchema, RequestContext } from '@reactionary/core';
+import type * as z from 'zod';
+export declare class MedusaProfileFactory<TProfileSchema extends AnyProfileSchema = typeof ProfileSchema> implements ProfileFactory<TProfileSchema> {
+    readonly profileSchema: TProfileSchema;
+    constructor(profileSchema: TProfileSchema);
+    parseProfile(_context: RequestContext, data: unknown): z.output<TProfileSchema>;
+}

package/src/index.d.ts

@@ -0,0 +1,17 @@
+export * from './schema/configuration.schema.js';
+export * from './schema/medusa.schema.js';
+export * from './schema/capabilities.schema.js';
+export * from './core/initialize.js';
+export * from './core/initialize.types.js';
+export * from './core/client.js';
+export * from './factories/index.js';
+export * from './capabilities/cart.capability.js';
+export * from './capabilities/identity.capability.js';
+export * from './capabilities/inventory.capability.js';
+export * from './capabilities/order.capability.js';
+export * from './capabilities/order-search.capability.js';
+export * from './capabilities/price.capability.js';
+export * from './capabilities/product-search.capability.js';
+export * from './capabilities/product-recommendations.capability.js';
+export * from './capabilities/product-associations.capability.js';
+export * from './capabilities/profile.capability.js';

package/src/schema/capabilities.schema.d.ts

@@ -0,0 +1,116 @@
+import type { CartFactory, CartFactoryWithOutput, CartCapability, CategoryFactory, CategoryFactoryWithOutput, CategoryCapability, CheckoutFactory, CheckoutFactoryWithOutput, CheckoutCapability, IdentityCapability, InventoryFactory, InventoryFactoryWithOutput, InventoryCapability, OrderFactory, OrderFactoryWithOutput, OrderCapability, OrderSearchFactory, OrderSearchFactoryWithOutput, OrderSearchCapability, PriceFactory, PriceFactoryWithOutput, PriceCapability, ProductAssociationsFactory, ProductAssociationsFactoryWithOutput, ProductAssociationsCapability, ProductFactory, ProductFactoryWithOutput, ProductCapability, ProductRecommendationsCapability, ProductSearchFactory, ProductSearchFactoryWithOutput, ProductSearchCapability, ProfileFactory, ProfileFactoryWithOutput, ProfileCapability, RequestContext, Cache } from '@reactionary/core';
+import type { MedusaConfiguration } from './configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import * as z from 'zod';
+export declare const MedusaCapabilitiesSchema: z.ZodObject<{
+    product: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    cart: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    checkout: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    category: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    price: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    order: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    orderSearch: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    inventory: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    identity: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    profile: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productAssociations: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        factory: z.ZodOptional<z.ZodUnknown>;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+    productRecommendations: z.ZodOptional<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodBoolean;
+        capability: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;
+export interface MedusaCapabilityFactoryArgs {
+    cache: Cache;
+    context: RequestContext;
+    config: MedusaConfiguration;
+    medusaApi: MedusaAPI;
+}
+export interface MedusaFactoryCapabilityArgs<TFactory> extends MedusaCapabilityFactoryArgs {
+    factory: TFactory;
+}
+export interface MedusaCapabilityConfig<TFactory, TCapability> {
+    enabled: boolean;
+    factory?: TFactory;
+    capability?: (args: MedusaFactoryCapabilityArgs<TFactory>) => TCapability;
+}
+export interface MedusaDirectCapabilityConfig<TCapability> {
+    enabled: boolean;
+    capability?: (args: MedusaCapabilityFactoryArgs) => TCapability;
+}
+export type MedusaProductCapabilityConfig = MedusaCapabilityConfig<ProductFactoryWithOutput<ProductFactory>, ProductCapability>;
+export type MedusaProductSearchCapabilityConfig = MedusaCapabilityConfig<ProductSearchFactoryWithOutput<ProductSearchFactory>, ProductSearchCapability>;
+export type MedusaCartCapabilityConfig = MedusaCapabilityConfig<CartFactoryWithOutput<CartFactory>, CartCapability>;
+export type MedusaCheckoutCapabilityConfig = MedusaCapabilityConfig<CheckoutFactoryWithOutput<CheckoutFactory>, CheckoutCapability>;
+export type MedusaCategoryCapabilityConfig = MedusaCapabilityConfig<CategoryFactoryWithOutput<CategoryFactory>, CategoryCapability>;
+export type MedusaPriceCapabilityConfig = MedusaCapabilityConfig<PriceFactoryWithOutput<PriceFactory>, PriceCapability>;
+export type MedusaOrderCapabilityConfig = MedusaCapabilityConfig<OrderFactoryWithOutput<OrderFactory>, OrderCapability>;
+export type MedusaOrderSearchCapabilityConfig = MedusaCapabilityConfig<OrderSearchFactoryWithOutput<OrderSearchFactory>, OrderSearchCapability>;
+export type MedusaInventoryCapabilityConfig = MedusaCapabilityConfig<InventoryFactoryWithOutput<InventoryFactory>, InventoryCapability>;
+export type MedusaIdentityCapabilityConfig = MedusaDirectCapabilityConfig<IdentityCapability>;
+export type MedusaProfileCapabilityConfig = MedusaCapabilityConfig<ProfileFactoryWithOutput<ProfileFactory>, ProfileCapability>;
+export type MedusaProductAssociationsCapabilityConfig = MedusaCapabilityConfig<ProductAssociationsFactoryWithOutput<ProductAssociationsFactory>, ProductAssociationsCapability>;
+export type MedusaProductRecommendationsCapabilityConfig = MedusaDirectCapabilityConfig<ProductRecommendationsCapability>;
+export type MedusaCapabilities<TProductFactory extends ProductFactory = ProductFactory, TProductCapability extends ProductCapability = ProductCapability, TProductSearchFactory extends ProductSearchFactory = ProductSearchFactory, TProductSearchCapability extends ProductSearchCapability = ProductSearchCapability, TCartFactory extends CartFactory = CartFactory, TCartCapability extends CartCapability = CartCapability, TCheckoutFactory extends CheckoutFactory = CheckoutFactory, TCheckoutCapability extends CheckoutCapability = CheckoutCapability, TCategoryFactory extends CategoryFactory = CategoryFactory, TCategoryCapability extends CategoryCapability = CategoryCapability, TPriceFactory extends PriceFactory = PriceFactory, TPriceCapability extends PriceCapability = PriceCapability, TOrderFactory extends OrderFactory = OrderFactory, TOrderCapability extends OrderCapability = OrderCapability, TOrderSearchFactory extends OrderSearchFactory = OrderSearchFactory, TOrderSearchCapability extends OrderSearchCapability = OrderSearchCapability, TInventoryFactory extends InventoryFactory = InventoryFactory, TInventoryCapability extends InventoryCapability = InventoryCapability, TIdentityCapability extends IdentityCapability = IdentityCapability, TProfileFactory extends ProfileFactory = ProfileFactory, TProfileCapability extends ProfileCapability = ProfileCapability, TProductAssociationsFactory extends ProductAssociationsFactory = ProductAssociationsFactory, TProductAssociationsCapability extends ProductAssociationsCapability = ProductAssociationsCapability, TProductRecommendationsCapability extends ProductRecommendationsCapability = ProductRecommendationsCapability> = {
+    product?: MedusaCapabilityConfig<ProductFactoryWithOutput<TProductFactory>, TProductCapability>;
+    productSearch?: MedusaCapabilityConfig<ProductSearchFactoryWithOutput<TProductSearchFactory>, TProductSearchCapability>;
+    cart?: MedusaCapabilityConfig<CartFactoryWithOutput<TCartFactory>, TCartCapability>;
+    checkout?: MedusaCapabilityConfig<CheckoutFactoryWithOutput<TCheckoutFactory>, TCheckoutCapability>;
+    category?: MedusaCapabilityConfig<CategoryFactoryWithOutput<TCategoryFactory>, TCategoryCapability>;
+    price?: MedusaCapabilityConfig<PriceFactoryWithOutput<TPriceFactory>, TPriceCapability>;
+    order?: MedusaCapabilityConfig<OrderFactoryWithOutput<TOrderFactory>, TOrderCapability>;
+    orderSearch?: MedusaCapabilityConfig<OrderSearchFactoryWithOutput<TOrderSearchFactory>, TOrderSearchCapability>;
+    inventory?: MedusaCapabilityConfig<InventoryFactoryWithOutput<TInventoryFactory>, TInventoryCapability>;
+    identity?: MedusaDirectCapabilityConfig<TIdentityCapability>;
+    profile?: MedusaCapabilityConfig<ProfileFactoryWithOutput<TProfileFactory>, TProfileCapability>;
+    productAssociations?: MedusaCapabilityConfig<ProductAssociationsFactoryWithOutput<TProductAssociationsFactory>, TProductAssociationsCapability>;
+    productRecommendations?: MedusaDirectCapabilityConfig<TProductRecommendationsCapability>;
+};
+export type ParsedMedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

package/src/schema/configuration.schema.d.ts

@@ -0,0 +1,9 @@
+import * as z from 'zod';
+export declare const MedusaConfigurationSchema: z.ZodObject<{
+    publishable_key: z.ZodString;
+    adminApiKey: z.ZodString;
+    apiUrl: z.ZodString;
+    defaultCurrency: z.ZodDefault<z.ZodString>;
+    allCurrencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+}, z.core.$loose>;
+export type MedusaConfiguration = z.infer<typeof MedusaConfigurationSchema>;

package/src/schema/medusa.schema.d.ts

@@ -0,0 +1,33 @@
+import * as z from 'zod';
+export declare const MedusaCartIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+    region_id: z.ZodOptional<z.ZodString>;
+}, z.core.$loose>;
+export declare const MedusaOrderIdentifierSchema: z.ZodObject<{
+    key: z.ZodString;
+    display_id: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+export declare const MedusaRegionSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    currency_code: z.ZodString;
+}, z.core.$loose>;
+export declare const MedusaSessionSchema: z.ZodObject<{
+    activeCartId: z.ZodOptional<z.ZodString>;
+    token: z.ZodOptional<z.ZodString>;
+    expires: z.ZodOptional<z.ZodString>;
+    allRegions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        currency_code: z.ZodString;
+    }, z.core.$loose>>>;
+    selectedRegion: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        currency_code: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export type MedusaCartIdentifier = z.infer<typeof MedusaCartIdentifierSchema>;
+export type MedusaOrderIdentifier = z.infer<typeof MedusaOrderIdentifierSchema>;
+export type MedusaSession = z.infer<typeof MedusaSessionSchema>;
+export type MedusaRegion = z.infer<typeof MedusaRegionSchema>;

package/src/test/test-utils.d.ts

@@ -0,0 +1,2 @@
+import { type MedusaConfiguration } from '../schema/configuration.schema.js';
+export declare function getMedusaTestConfiguration(): MedusaConfiguration;

package/src/utils/medusa-helpers.d.ts

@@ -0,0 +1,35 @@
+import type { StoreCart, StoreOrder } from '@medusajs/types';
+import type { CostBreakDown, Currency } from '@reactionary/core';
+/**
+ * Parses cost breakdown from Medusa StoreCart
+ */
+export declare function parseMedusaCostBreakdown(remote: StoreCart | StoreOrder): CostBreakDown;
+/**
+ * Parses item price structure from Medusa line item
+ */
+export declare function parseMedusaItemPrice(remoteItem: {
+    unit_price?: number;
+    quantity: number;
+    discount_total?: number;
+}, currency: Currency): {
+    unitPrice: {
+        value: number;
+        currency: Currency;
+    };
+    unitDiscount: {
+        value: number;
+        currency: Currency;
+    };
+    totalPrice: {
+        value: number;
+        currency: Currency;
+    };
+    totalDiscount: {
+        value: number;
+        currency: Currency;
+    };
+};
+/**
+ * Handles capability implementation errors with consistent formatting
+ */
+export declare function handleProviderError(action: string, error: unknown): never;

package/test/test-utils.js

@@ -0,0 +1,12 @@
+import { MedusaConfigurationSchema } from "../schema/configuration.schema.js";
+function getMedusaTestConfiguration() {
+  return MedusaConfigurationSchema.parse({
+    publishable_key: process.env["MEDUSA_PUBLISHABLE_KEY"] || "",
+    adminApiKey: process.env["MEDUSA_ADMIN_KEY"] || "",
+    apiUrl: process.env["MEDUSA_API_URL"] || "",
+    defaultCurrency: process.env["MEDUSA_DEFAULT_CURRENCY"] || ""
+  });
+}
+export {
+  getMedusaTestConfiguration
+};

package/utils/medusa-helpers.js

@@ -0,0 +1,72 @@
+import createDebug from "debug";
+const debug = createDebug("reactionary:medusa:helpers");
+function parseMedusaCostBreakdown(remote) {
+  const grandTotal = remote.total || 0;
+  const shippingTotal = remote.shipping_total || 0;
+  const taxTotal = remote.tax_total || 0;
+  const discountTotal = remote.discount_total || 0;
+  const subtotal = remote.subtotal || 0;
+  const currency = (remote.currency_code || "EUR").toUpperCase();
+  return {
+    totalTax: {
+      value: taxTotal,
+      currency
+    },
+    totalDiscount: {
+      value: discountTotal,
+      currency
+    },
+    totalSurcharge: {
+      value: 0,
+      currency
+    },
+    totalShipping: {
+      value: shippingTotal,
+      currency
+    },
+    totalProductPrice: {
+      value: subtotal,
+      currency
+    },
+    grandTotal: {
+      value: grandTotal,
+      currency
+    }
+  };
+}
+function parseMedusaItemPrice(remoteItem, currency) {
+  const unitPrice = remoteItem.unit_price || 0;
+  const totalPrice = unitPrice * remoteItem.quantity || 0;
+  const discountTotal = remoteItem.discount_total || 0;
+  return {
+    unitPrice: {
+      value: unitPrice,
+      currency
+    },
+    unitDiscount: {
+      value: discountTotal / remoteItem.quantity,
+      currency
+    },
+    totalPrice: {
+      value: totalPrice,
+      currency
+    },
+    totalDiscount: {
+      value: discountTotal,
+      currency
+    }
+  };
+}
+function handleProviderError(action, error) {
+  if (debug.enabled) {
+    debug(`Failed to ${action}:`, error);
+  }
+  throw new Error(
+    `Failed to ${action}: ${error instanceof Error ? error.message : "Unknown error"}`
+  );
+}
+export {
+  handleProviderError,
+  parseMedusaCostBreakdown,
+  parseMedusaItemPrice
+};