@reactionary/medusa 0.6.3

package/core/initialize.js

@@ -0,0 +1,290 @@
+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
+} 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 {
+  resolveCapabilityWithFactory,
+  resolveDirectCapability
+} 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);
+    const buildCapabilityArgs = (factory) => ({
+      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;
+  };
+}
+export {
+  withMedusaCapabilities
+};

package/core/initialize.types.js

@@ -0,0 +1,13 @@
+function resolveCapabilityWithFactory(capability, defaults, buildCapabilityArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+function resolveDirectCapability(capability, defaultCapability, args) {
+  const capabilityFactory = capability?.capability ?? defaultCapability;
+  return capabilityFactory(args);
+}
+export {
+  resolveCapabilityWithFactory,
+  resolveDirectCapability
+};

package/factories/cart/cart.factory.js

@@ -0,0 +1,17 @@
+class MedusaCartFactory {
+  cartSchema;
+  cartIdentifierSchema;
+  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,17 @@
+class MedusaCategoryFactory {
+  categorySchema;
+  categoryPaginatedResultSchema;
+  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,22 @@
+class MedusaCheckoutFactory {
+  checkoutSchema;
+  shippingMethodSchema;
+  paymentMethodSchema;
+  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,12 @@
+class MedusaIdentityFactory {
+  identitySchema;
+  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,12 @@
+class MedusaInventoryFactory {
+  inventorySchema;
+  constructor(inventorySchema) {
+    this.inventorySchema = inventorySchema;
+  }
+  parseInventory(_context, data) {
+    return this.inventorySchema.parse(data);
+  }
+}
+export {
+  MedusaInventoryFactory
+};

package/factories/order/order.factory.js

@@ -0,0 +1,12 @@
+class MedusaOrderFactory {
+  orderSchema;
+  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,12 @@
+class MedusaOrderSearchFactory {
+  orderSearchResultSchema;
+  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,12 @@
+class MedusaPriceFactory {
+  priceSchema;
+  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,12 @@
+class MedusaProductFactory {
+  productSchema;
+  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,12 @@
+class MedusaProductAssociationsFactory {
+  productAssociationSchema;
+  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,12 @@
+class MedusaProductSearchFactory {
+  productSearchResultSchema;
+  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,12 @@
+class MedusaProfileFactory {
+  profileSchema;
+  constructor(profileSchema) {
+    this.profileSchema = profileSchema;
+  }
+  parseProfile(_context, data) {
+    return this.profileSchema.parse(data);
+  }
+}
+export {
+  MedusaProfileFactory
+};

package/index.js

@@ -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/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@reactionary/medusa",
+  "version": "0.6.3",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
+  "dependencies": {
+    "@medusajs/js-sdk": "^2.13.3",
+    "@reactionary/core": "0.6.3",
+    "debug": "^4.4.3",
+    "@medusajs/types": "^2.13.3",
+    "zod": "4.1.9",
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5"
+  },
+  "sideEffects": false
+}

package/schema/capabilities.schema.js

@@ -0,0 +1,43 @@
+import { CapabilitiesSchema } from "@reactionary/core";
+import * as z from "zod";
+const OverridableCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  factory: z.unknown().optional(),
+  capability: z.unknown().optional()
+});
+const DirectCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  capability: z.unknown().optional()
+});
+const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
+  productSearch: true,
+  productRecommendations: true,
+  cart: true,
+  checkout: true,
+  category: true,
+  product: true,
+  price: true,
+  order: true,
+  orderSearch: true,
+  inventory: true,
+  identity: true,
+  profile: true,
+  productAssociations: true
+}).extend({
+  product: OverridableCapabilitySchema.optional(),
+  productSearch: OverridableCapabilitySchema.optional(),
+  cart: OverridableCapabilitySchema.optional(),
+  checkout: OverridableCapabilitySchema.optional(),
+  category: OverridableCapabilitySchema.optional(),
+  price: OverridableCapabilitySchema.optional(),
+  order: OverridableCapabilitySchema.optional(),
+  orderSearch: OverridableCapabilitySchema.optional(),
+  inventory: OverridableCapabilitySchema.optional(),
+  identity: DirectCapabilitySchema.optional(),
+  profile: OverridableCapabilitySchema.optional(),
+  productAssociations: OverridableCapabilitySchema.optional(),
+  productRecommendations: DirectCapabilitySchema.optional()
+}).partial();
+export {
+  MedusaCapabilitiesSchema
+};

package/schema/configuration.schema.js

@@ -0,0 +1,11 @@
+import * as z from "zod";
+const MedusaConfigurationSchema = z.looseObject({
+  publishable_key: z.string().meta({ description: "The publishable API key for the Medusa store. Used for all storefront operations." }),
+  adminApiKey: z.string().meta({ description: "The API key for Medusa admin operations. Needed for the few tasks that require admin access." }),
+  apiUrl: z.string().meta({ description: "The base URL for the Medusa API." }),
+  defaultCurrency: z.string().default(""),
+  allCurrencies: z.array(z.string()).default(() => [])
+});
+export {
+  MedusaConfigurationSchema
+};

package/schema/medusa.schema.js

@@ -0,0 +1,26 @@
+import { CartIdentifierSchema, OrderIdentifierSchema } from "@reactionary/core";
+import * as z from "zod";
+const MedusaCartIdentifierSchema = CartIdentifierSchema.extend({
+  region_id: z.string().optional()
+});
+const MedusaOrderIdentifierSchema = OrderIdentifierSchema.extend({
+  display_id: z.number().optional()
+});
+const MedusaRegionSchema = z.looseObject({
+  id: z.string(),
+  name: z.string(),
+  currency_code: z.string()
+});
+const MedusaSessionSchema = z.looseObject({
+  activeCartId: z.string().optional(),
+  token: z.string().optional(),
+  expires: z.string().optional(),
+  allRegions: z.array(MedusaRegionSchema).optional(),
+  selectedRegion: MedusaRegionSchema.optional()
+});
+export {
+  MedusaCartIdentifierSchema,
+  MedusaOrderIdentifierSchema,
+  MedusaRegionSchema,
+  MedusaSessionSchema
+};