@reactionary/provider-medusa 0.6.1 → 0.6.2

package/core/initialize.js

@@ -1,3 +1,20 @@
+import {
+  CartIdentifierSchema,
+  CartSchema,
+  CategoryPaginatedResultSchema,
+  CategorySchema,
+  CheckoutSchema,
+  InventorySchema,
+  OrderSchema,
+  OrderSearchResultSchema,
+  PaymentMethodSchema,
+  PriceSchema,
+  ProductAssociationSchema,
+  ProductSchema,
+  ProductSearchResultSchema,
+  ProfileSchema,
+  ShippingMethodSchema
+} from "@reactionary/core";
 import { MedusaCartProvider } from "../providers/cart.provider.js";
 import { MedusaCategoryProvider } from "../providers/category.provider.js";
 import { MedusaCheckoutProvider } from "../providers/checkout.provider.js";
@@ -11,53 +28,259 @@ import { MedusaProductRecommendationsProvider } from "../providers/product-recom
 import { MedusaProductProvider } from "../providers/product.provider.js";
 import { MedusaProductAssociationsProvider } from "../providers/product-associations.provider.js";
 import { MedusaProfileProvider } from "../providers/profile.provider.js";
-import { MedusaCapabilitiesSchema } from "../schema/capabilities.schema.js";
-import { MedusaConfigurationSchema } from "../schema/configuration.schema.js";
+import {
+  MedusaCapabilitiesSchema
+} from "../schema/capabilities.schema.js";
+import {
+  MedusaConfigurationSchema
+} 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 {
+  resolveCapabilityProvider,
+  resolveProviderOnlyCapability
+} from "./initialize.types.js";
 function withMedusaCapabilities(configuration, capabilities) {
   return (cache, context) => {
     const client = {};
     const config = MedusaConfigurationSchema.parse(configuration);
     const caps = MedusaCapabilitiesSchema.parse(capabilities);
     const medusaApi = new MedusaAPI(config, context);
-    if (caps.productSearch) {
-      client.productSearch = new MedusaSearchProvider(configuration, cache, context, medusaApi);
+    const buildProviderArgs = (factory) => ({
+      cache,
+      context,
+      config,
+      medusaApi,
+      factory
+    });
+    if (caps.product?.enabled) {
+      client.product = resolveCapabilityProvider(
+        capabilities.product,
+        {
+          factory: new MedusaProductFactory(ProductSchema),
+          provider: (args) => new MedusaProductProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.productRecommendations) {
-      client.productRecommendations = new MedusaProductRecommendationsProvider(configuration, cache, context, medusaApi);
+    if (caps.productSearch?.enabled) {
+      client.productSearch = resolveCapabilityProvider(
+        capabilities.productSearch,
+        {
+          factory: new MedusaProductSearchFactory(ProductSearchResultSchema),
+          provider: (args) => new MedusaSearchProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.category) {
-      client.category = new MedusaCategoryProvider(configuration, cache, context, medusaApi);
+    if (caps.category?.enabled) {
+      client.category = resolveCapabilityProvider(
+        capabilities.category,
+        {
+          factory: new MedusaCategoryFactory(
+            CategorySchema,
+            CategoryPaginatedResultSchema
+          ),
+          provider: (args) => new MedusaCategoryProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.checkout) {
-      client.checkout = new MedusaCheckoutProvider(configuration, cache, context, medusaApi);
+    if (caps.checkout?.enabled) {
+      client.checkout = resolveCapabilityProvider(
+        capabilities.checkout,
+        {
+          factory: new MedusaCheckoutFactory(
+            CheckoutSchema,
+            ShippingMethodSchema,
+            PaymentMethodSchema
+          ),
+          provider: (args) => new MedusaCheckoutProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.product) {
-      client.product = new MedusaProductProvider(configuration, cache, context, medusaApi);
+    if (caps.productRecommendations?.enabled) {
+      client.productRecommendations = resolveProviderOnlyCapability(
+        capabilities.productRecommendations,
+        (args) => new MedusaProductRecommendationsProvider(
+          args.config,
+          args.cache,
+          args.context,
+          args.medusaApi
+        ),
+        {
+          cache,
+          context,
+          config,
+          medusaApi
+        }
+      );
     }
-    if (caps.cart) {
-      client.cart = new MedusaCartProvider(configuration, cache, context, medusaApi);
+    if (caps.cart?.enabled) {
+      client.cart = resolveCapabilityProvider(
+        capabilities.cart,
+        {
+          factory: new MedusaCartFactory(CartSchema, CartIdentifierSchema),
+          provider: (args) => new MedusaCartProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.price) {
-      client.price = new MedusaPriceProvider(configuration, cache, context, medusaApi);
+    if (caps.price?.enabled) {
+      client.price = resolveCapabilityProvider(
+        capabilities.price,
+        {
+          factory: new MedusaPriceFactory(PriceSchema),
+          provider: (args) => new MedusaPriceProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.inventory) {
-      client.inventory = new MedusaInventoryProvider(configuration, cache, context, medusaApi);
+    if (caps.inventory?.enabled) {
+      client.inventory = resolveCapabilityProvider(
+        capabilities.inventory,
+        {
+          factory: new MedusaInventoryFactory(InventorySchema),
+          provider: (args) => new MedusaInventoryProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.identity) {
-      client.identity = new MedusaIdentityProvider(configuration, cache, context, medusaApi);
+    if (caps.identity?.enabled) {
+      client.identity = resolveProviderOnlyCapability(
+        capabilities.identity,
+        (args) => new MedusaIdentityProvider(
+          args.config,
+          args.cache,
+          args.context,
+          args.medusaApi
+        ),
+        {
+          cache,
+          context,
+          config,
+          medusaApi
+        }
+      );
     }
-    if (caps.profile) {
-      client.profile = new MedusaProfileProvider(configuration, cache, context, medusaApi);
+    if (caps.profile?.enabled) {
+      client.profile = resolveCapabilityProvider(
+        capabilities.profile,
+        {
+          factory: new MedusaProfileFactory(ProfileSchema),
+          provider: (args) => new MedusaProfileProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.order) {
-      client.order = new MedusaOrderProvider(configuration, cache, context, medusaApi);
+    if (caps.order?.enabled) {
+      client.order = resolveCapabilityProvider(
+        capabilities.order,
+        {
+          factory: new MedusaOrderFactory(OrderSchema),
+          provider: (args) => new MedusaOrderProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.orderSearch) {
-      client.orderSearch = new MedusaOrderSearchProvider(configuration, cache, context, medusaApi);
+    if (caps.orderSearch?.enabled) {
+      client.orderSearch = resolveCapabilityProvider(
+        capabilities.orderSearch,
+        {
+          factory: new MedusaOrderSearchFactory(OrderSearchResultSchema),
+          provider: (args) => new MedusaOrderSearchProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
-    if (caps.productAssociations) {
-      client.productAssociations = new MedusaProductAssociationsProvider(configuration, cache, context, medusaApi);
+    if (caps.productAssociations?.enabled) {
+      client.productAssociations = resolveCapabilityProvider(
+        capabilities.productAssociations,
+        {
+          factory: new MedusaProductAssociationsFactory(ProductAssociationSchema),
+          provider: (args) => new MedusaProductAssociationsProvider(
+            args.config,
+            args.cache,
+            args.context,
+            args.medusaApi,
+            args.factory
+          )
+        },
+        buildProviderArgs
+      );
     }
     return client;
   };

package/core/initialize.types.js

@@ -0,0 +1,13 @@
+function resolveCapabilityProvider(capability, defaults, buildProviderArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const provider = capability?.provider ?? defaults.provider;
+  return provider(buildProviderArgs(factory));
+}
+function resolveProviderOnlyCapability(capability, defaultProvider, args) {
+  const provider = capability?.provider ?? defaultProvider;
+  return provider(args);
+}
+export {
+  resolveCapabilityProvider,
+  resolveProviderOnlyCapability
+};

package/factories/cart/cart.factory.js

@@ -0,0 +1,15 @@
+class MedusaCartFactory {
+  constructor(cartSchema, cartIdentifierSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+  }
+  parseCart(_context, data) {
+    return this.cartSchema.parse(data);
+  }
+  parseCartIdentifier(_context, data) {
+    return this.cartIdentifierSchema.parse(data);
+  }
+}
+export {
+  MedusaCartFactory
+};

package/factories/category/category.factory.js

@@ -0,0 +1,15 @@
+class MedusaCategoryFactory {
+  constructor(categorySchema, categoryPaginatedResultSchema) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+  parseCategory(_context, data) {
+    return this.categorySchema.parse(data);
+  }
+  parseCategoryPaginatedResult(_context, data) {
+    return this.categoryPaginatedResultSchema.parse(data);
+  }
+}
+export {
+  MedusaCategoryFactory
+};

package/factories/checkout/checkout.factory.js

@@ -0,0 +1,19 @@
+class MedusaCheckoutFactory {
+  constructor(checkoutSchema, shippingMethodSchema, paymentMethodSchema) {
+    this.checkoutSchema = checkoutSchema;
+    this.shippingMethodSchema = shippingMethodSchema;
+    this.paymentMethodSchema = paymentMethodSchema;
+  }
+  parseCheckout(_context, data) {
+    return this.checkoutSchema.parse(data);
+  }
+  parseShippingMethod(_context, data) {
+    return this.shippingMethodSchema.parse(data);
+  }
+  parsePaymentMethod(_context, data) {
+    return this.paymentMethodSchema.parse(data);
+  }
+}
+export {
+  MedusaCheckoutFactory
+};

package/factories/identity/identity.factory.js

@@ -0,0 +1,11 @@
+class MedusaIdentityFactory {
+  constructor(identitySchema) {
+    this.identitySchema = identitySchema;
+  }
+  parseIdentity(_context, data) {
+    return this.identitySchema.parse(data);
+  }
+}
+export {
+  MedusaIdentityFactory
+};

package/factories/index.js

@@ -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/factories/inventory/inventory.factory.js

@@ -0,0 +1,11 @@
+class MedusaInventoryFactory {
+  constructor(inventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+  parseInventory(_context, data) {
+    return this.inventorySchema.parse(data);
+  }
+}
+export {
+  MedusaInventoryFactory
+};

package/factories/order/order.factory.js

@@ -0,0 +1,11 @@
+class MedusaOrderFactory {
+  constructor(orderSchema) {
+    this.orderSchema = orderSchema;
+  }
+  parseOrder(_context, data) {
+    return this.orderSchema.parse(data);
+  }
+}
+export {
+  MedusaOrderFactory
+};

package/factories/order-search/order-search.factory.js

@@ -0,0 +1,11 @@
+class MedusaOrderSearchFactory {
+  constructor(orderSearchResultSchema) {
+    this.orderSearchResultSchema = orderSearchResultSchema;
+  }
+  parseOrderSearchResult(_context, data, _query) {
+    return this.orderSearchResultSchema.parse(data);
+  }
+}
+export {
+  MedusaOrderSearchFactory
+};

package/factories/price/price.factory.js

@@ -0,0 +1,11 @@
+class MedusaPriceFactory {
+  constructor(priceSchema) {
+    this.priceSchema = priceSchema;
+  }
+  parsePrice(_context, data, _options) {
+    return this.priceSchema.parse(data);
+  }
+}
+export {
+  MedusaPriceFactory
+};

package/factories/product/product.factory.js

@@ -0,0 +1,11 @@
+class MedusaProductFactory {
+  constructor(productSchema) {
+    this.productSchema = productSchema;
+  }
+  parseProduct(_context, data) {
+    return this.productSchema.parse(data);
+  }
+}
+export {
+  MedusaProductFactory
+};

package/factories/product-associations/product-associations.factory.js

@@ -0,0 +1,11 @@
+class MedusaProductAssociationsFactory {
+  constructor(productAssociationSchema) {
+    this.productAssociationSchema = productAssociationSchema;
+  }
+  parseAssociation(_context, data) {
+    return this.productAssociationSchema.parse(data);
+  }
+}
+export {
+  MedusaProductAssociationsFactory
+};

package/factories/product-search/product-search.factory.js

@@ -0,0 +1,11 @@
+class MedusaProductSearchFactory {
+  constructor(productSearchResultSchema) {
+    this.productSearchResultSchema = productSearchResultSchema;
+  }
+  parseSearchResult(_context, data, _query) {
+    return this.productSearchResultSchema.parse(data);
+  }
+}
+export {
+  MedusaProductSearchFactory
+};

package/factories/profile/profile.factory.js

@@ -0,0 +1,11 @@
+class MedusaProfileFactory {
+  constructor(profileSchema) {
+    this.profileSchema = profileSchema;
+  }
+  parseProfile(_context, data) {
+    return this.profileSchema.parse(data);
+  }
+}
+export {
+  MedusaProfileFactory
+};

package/index.js

@@ -2,7 +2,9 @@ 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 "./providers/cart.provider.js";
 export * from "./providers/identity.provider.js";
 export * from "./providers/inventory.provider.js";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@reactionary/provider-medusa",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "type": "module",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
     "@medusajs/js-sdk": "^2.13.0",
-    "@reactionary/core": "0.6.1",
+    "@reactionary/core": "0.6.2",
     "debug": "^4.4.3",
     "@medusajs/types": "^2.11.0",
     "zod": "4.1.9"

package/providers/cart.provider.js

@@ -35,7 +35,7 @@ import {
 } from "../utils/medusa-helpers.js";
 const debug = createDebug("reactionary:medusa:cart");
 class MedusaCartProvider extends CartProvider {
-  constructor(config, cache, context, medusaApi) {
+  constructor(config, cache, context, medusaApi, factory) {
     super(cache, context);
     this.medusaApi = medusaApi;
     /**
@@ -46,6 +46,7 @@ class MedusaCartProvider extends CartProvider {
      */
     this.includedFields = ["+items.*"].join(",");
     this.config = config;
+    this.factory = factory;
   }
   async getById(payload) {
     try {
@@ -185,12 +186,10 @@ class MedusaCartProvider extends CartProvider {
       if (activeCartId) {
         try {
           await client.store.cart.retrieve(activeCartId);
-          return success(
-            MedusaCartIdentifierSchema.parse({
-              key: activeCartId,
-              region_id: (await this.medusaApi.getActiveRegion()).id
-            })
-          );
+          return success(this.factory.parseCartIdentifier(this.context, {
+            key: activeCartId,
+            region_id: (await this.medusaApi.getActiveRegion()).id
+          }));
         } catch {
         }
       }
@@ -348,7 +347,7 @@ class MedusaCartProvider extends CartProvider {
         }
       );
       if (response.cart) {
-        const cartIdentifier = MedusaCartIdentifierSchema.parse({
+        const cartIdentifier = this.factory.parseCartIdentifier(this.context, {
           key: response.cart.id,
           region_id: response.cart.region_id
         });
@@ -455,7 +454,7 @@ class MedusaCartProvider extends CartProvider {
         userId: "???"
       }
     };
-    return result;
+    return this.factory.parseCart(this.context, result);
   }
 }
 __decorateClass([

package/providers/category.provider.js

@@ -26,10 +26,11 @@ import {
 } from "@reactionary/core";
 import * as z from "zod";
 class MedusaCategoryProvider extends CategoryProvider {
-  constructor(config, cache, context, medusaApi) {
+  constructor(config, cache, context, medusaApi, factory) {
     super(cache, context);
     this.medusaApi = medusaApi;
     this.config = config;
+    this.factory = factory;
   }
   async resolveCategoryIdByExternalId(externalId) {
     const sdk = await this.medusaApi.getClient();
@@ -160,7 +161,7 @@ class MedusaCategoryProvider extends CategoryProvider {
       parentCategory,
       images: []
     };
-    return result;
+    return this.factory.parseCategory(this.context, result);
   }
   parsePaginatedResult(body) {
     const items = body.product_categories.map((x) => this.parseSingle(x));
@@ -175,7 +176,7 @@ class MedusaCategoryProvider extends CategoryProvider {
       totalPages,
       items
     };
-    return result;
+    return this.factory.parseCategoryPaginatedResult(this.context, result);
   }
 }
 __decorateClass([

package/providers/checkout.provider.js

@@ -46,7 +46,7 @@ class CheckoutNotReadyForFinalizationError extends Error {
   }
 }
 class MedusaCheckoutProvider extends CheckoutProvider {
-  constructor(config, cache, context, medusaApi) {
+  constructor(config, cache, context, medusaApi, factory) {
     super(cache, context);
     this.medusaApi = medusaApi;
     /**
@@ -57,6 +57,7 @@ class MedusaCheckoutProvider extends CheckoutProvider {
      */
     this.includedFields = ["+items.*"].join(",");
     this.config = config;
+    this.factory = factory;
   }
   initiateCheckoutForCartPayload(payload) {
     return {
@@ -143,7 +144,9 @@ class MedusaCheckoutProvider extends CheckoutProvider {
         shippingMethods
       );
     }
-    return success(shippingMethods);
+    return success(
+      shippingMethods.map((x) => this.factory.parseShippingMethod(this.context, x))
+    );
   }
   getAvailablePaymentMethodsPayload(payload, regionId) {
     return {
@@ -185,7 +188,9 @@ class MedusaCheckoutProvider extends CheckoutProvider {
         paymentMethods
       );
     }
-    return success(paymentMethods);
+    return success(
+      paymentMethods.map((x) => this.factory.parsePaymentMethod(this.context, x))
+    );
   }
   addPaymentInstructionPayload(payload) {
     return {
@@ -274,9 +279,13 @@ class MedusaCheckoutProvider extends CheckoutProvider {
           order_display_id: response.order?.display_id ? 0 : ""
         }
       });
-      return this.getById({
+      const refreshedCheckout = await this.getById({
         identifier: payload.checkout
       });
+      if (!refreshedCheckout.success) {
+        throw new Error(`Unable to reload checkout ${payload.checkout.key} after completion`);
+      }
+      return success(refreshedCheckout.value);
     }
     throw new Error("Something failed during order creation");
   }
@@ -459,7 +468,7 @@ class MedusaCheckoutProvider extends CheckoutProvider {
       shippingAddress,
       shippingInstruction
     };
-    return result;
+    return this.factory.parseCheckout(this.context, result);
   }
 }
 __decorateClass([