@reactionary/provider-medusa 0.3.14 → 0.3.16

package/core/client.js

@@ -122,7 +122,7 @@ class MedusaAPI {
     const productsResponse = await adminClient.admin.product.list({
       limit: 1,
       offset: 0,
-      fields: "+metadata.*,+categories.metadata.*",
+      fields: "+metadata.*,+categories.metadata.*,+external_id",
       variants: {
         $or: [{ ean: sku }, { upc: sku }, { barcode: sku }]
       }

package/core/initialize.js

@@ -9,6 +9,7 @@ import { MedusaPriceProvider } from "../providers/price.provider.js";
 import { MedusaSearchProvider } from "../providers/product-search.provider.js";
 import { MedusaProductRecommendationsProvider } from "../providers/product-recommendations.provider.js";
 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";
@@ -55,6 +56,9 @@ function withMedusaCapabilities(configuration, capabilities) {
     if (caps.orderSearch) {
       client.orderSearch = new MedusaOrderSearchProvider(configuration, cache, context, medusaApi);
     }
+    if (caps.productAssociations) {
+      client.productAssociations = new MedusaProductAssociationsProvider(configuration, cache, context, medusaApi);
+    }
     return client;
   };
 }

package/index.js

@@ -11,4 +11,5 @@ export * from "./providers/order-search.provider.js";
 export * from "./providers/price.provider.js";
 export * from "./providers/product-search.provider.js";
 export * from "./providers/product-recommendations.provider.js";
+export * from "./providers/product-associations.provider.js";
 export * from "./providers/profile.provider.js";

package/package.json

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

package/providers/product-associations.provider.js

@@ -0,0 +1,144 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import {
+  ProductAssociationsProvider,
+  Reactionary,
+  ImageSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  success
+} from "@reactionary/core";
+class MedusaProductAssociationsProvider extends ProductAssociationsProvider {
+  constructor(config, cache, context, medusa) {
+    super(cache, context);
+    this.config = config;
+    this.medusa = medusa;
+  }
+  async fetchAssociatedProductsFor(productKey, maxNumberOfAssociations, attributeName) {
+    const client = await this.medusa.getClient();
+    const productResponse = await client.store.product.list({
+      external_id: productKey.key,
+      limit: 1,
+      offset: 0,
+      fields: "metadata.*,external_id"
+    });
+    let product;
+    if (!productResponse.products || productResponse.products.length === 0)
+      return [];
+    else
+      product = productResponse.products[0];
+    if (!product) {
+      return [];
+    }
+    const associationsMetadata = (product.metadata?.[attributeName] || "").split(";");
+    if (!associationsMetadata || associationsMetadata.length === 0 || associationsMetadata[0] === "") {
+      return [];
+    }
+    const associatedProductIds = associationsMetadata.slice(0, maxNumberOfAssociations);
+    const associatedProductsResponse = await client.store.product.list({
+      external_id: associatedProductIds,
+      fields: "+metadata.*,+external_id",
+      offset: 0,
+      limit: maxNumberOfAssociations
+    });
+    return associatedProductsResponse.products.map((product2) => this.parseSingle(product2));
+  }
+  async getAccessories(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfAccessories || 4, "reactionaryaccessories");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-accessory-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result);
+  }
+  async getSpareparts(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfSpareparts || 4, "reactionaryspareparts");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-sparepart-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result);
+  }
+  async getReplacements(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfReplacements || 4, "reactionaryreplacements");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-replacement-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result);
+  }
+  parseSingle(_body) {
+    const heroVariant = _body.variants?.[0];
+    const identifier = { key: _body.external_id || _body.id };
+    const slug = _body.handle;
+    const name = heroVariant?.title || _body.title;
+    const variants = [];
+    if (heroVariant) {
+      variants.push(this.parseVariant(heroVariant, _body));
+    }
+    const result = {
+      identifier,
+      name,
+      slug,
+      variants
+    };
+    return result;
+  }
+  parseVariant(variant, product) {
+    const img = ImageSchema.parse({
+      sourceUrl: product.images?.[0].url ?? "",
+      altText: product.title || void 0
+    });
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || ""
+      }),
+      image: img
+    });
+  }
+}
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], MedusaProductAssociationsProvider.prototype, "getAccessories", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], MedusaProductAssociationsProvider.prototype, "getSpareparts", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], MedusaProductAssociationsProvider.prototype, "getReplacements", 1);
+export {
+  MedusaProductAssociationsProvider
+};

package/providers/product-recommendations.provider.js

@@ -47,7 +47,7 @@ class MedusaProductRecommendationsProvider extends ProductRecommendationsProvide
       const productsResponse = await client.store.product.list({
         collection_id: [collection.id],
         limit: query.numberOfRecommendations,
-        fields: "+variants.id,+variants.sku"
+        fields: "+variants.id,+variants.sku,+external_id"
       });
       if (debug.enabled) {
         debug(`Found ${productsResponse.products.length} products in collection`);
@@ -78,7 +78,7 @@ class MedusaProductRecommendationsProvider extends ProductRecommendationsProvide
   }
   parseSearchResultItem(_body) {
     const heroVariant = _body.variants?.[0];
-    const identifier = { key: _body.id };
+    const identifier = { key: _body.external_id || _body.id };
     const slug = _body.handle;
     const name = heroVariant?.title || _body.title;
     const variants = [];

package/providers/product-search.provider.js

@@ -87,6 +87,7 @@ class MedusaSearchProvider extends ProductSearchProvider {
       q: finalSearch,
       ...categoryIdToFind ? { category_id: categoryIdToFind } : {},
       limit: payload.search.paginationOptions.pageSize,
+      fields: "+metadata.*,+external_id",
       offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
     });
     const result = this.parsePaginatedResult(response);
@@ -126,7 +127,7 @@ class MedusaSearchProvider extends ProductSearchProvider {
   }
   parseSingle(_body) {
     const heroVariant = _body.variants?.[0];
-    const identifier = { key: _body.id };
+    const identifier = { key: _body.external_id || _body.id };
     const slug = _body.handle;
     const name = heroVariant?.title || _body.title;
     const variants = [];

package/providers/product.provider.js

@@ -27,6 +27,7 @@ class MedusaProductProvider extends ProductProvider {
   constructor(config, cache, context, medusaApi) {
     super(cache, context);
     this.medusaApi = medusaApi;
+    this.alwaysIncludedFields = ["+metadata.*", "+categories.metadata.*", "+external_id"];
     this.config = config;
   }
   async getById(payload) {
@@ -34,18 +35,21 @@ class MedusaProductProvider extends ProductProvider {
     if (debug.enabled) {
       debug(`Fetching product by ID: ${payload.identifier.key}`);
     }
-    let response;
-    try {
-      response = await client.store.product.retrieve(payload.identifier.key, {
-        fields: "+metadata,+categories.metadata.*"
-      });
-    } catch (error2) {
-      if (debug.enabled) {
-        debug(`Product with ID: ${payload.identifier.key} not found, returning empty product. Error %O `, error2);
+    const response = await client.store.product.list(
+      {
+        external_id: payload.identifier.key,
+        limit: 1,
+        offset: 0,
+        fields: this.alwaysIncludedFields.join(",")
       }
-      return success(this.createEmptyProduct(payload.identifier.key));
+    );
+    if (response.count === 0) {
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
     }
-    return success(this.parseSingle(response.product));
+    return success(this.parseSingle(response.products[0]));
   }
   async getBySlug(payload) {
     const client = await this.medusaApi.getClient();
@@ -56,7 +60,7 @@ class MedusaProductProvider extends ProductProvider {
       handle: payload.slug,
       limit: 1,
       offset: 0,
-      fields: "+metadata.*"
+      fields: this.alwaysIncludedFields.join(",")
     });
     if (debug.enabled) {
       debug(`Found ${response.count} products for slug: ${payload.slug}`);
@@ -79,12 +83,11 @@ class MedusaProductProvider extends ProductProvider {
     if (!variant) {
       throw new Error(`Variant with SKU ${sku} not found`);
     }
-    product.variants = [];
-    product.variants.push(variant);
+    product.variants = product.variants?.filter((v) => v.sku === sku).concat(product.variants?.filter((v) => v.sku !== sku)) || [];
     return success(this.parseSingle(product));
   }
   parseSingle(_body) {
-    const identifier = ProductIdentifierSchema.parse({ key: _body.id });
+    const identifier = ProductIdentifierSchema.parse({ key: _body.external_id || _body.id });
     const name = _body.title;
     const slug = _body.handle;
     const description = _body.description || "" || _body.subtitle || "";
@@ -95,7 +98,7 @@ class MedusaProductProvider extends ProductProvider {
     const sharedAttributes = this.parseAttributes(_body);
     if (!_body.variants) {
       debug("Product has no variants", _body);
-      throw new Error("Product has no variants " + _body.id);
+      throw new Error("Product has no variants " + _body.external_id);
     }
     const mainVariant = this.parseVariant(_body.variants[0], _body);
     const otherVariants = [];
@@ -194,7 +197,11 @@ class MedusaProductProvider extends ProductProvider {
       sharedAttributes.push(this.createSynthAttribute("material", "Material", _body.material));
     }
     if (_body.metadata) {
+      const keysToExclude = ["reactionaryaccessories", "reactionaryreplacements", "reactionaryspareparts"];
       for (const [key, value] of Object.entries(_body.metadata)) {
+        if (keysToExclude.includes(key)) {
+          continue;
+        }
         sharedAttributes.push(this.createSynthAttribute(key, key, String(value)));
       }
     }

package/schema/capabilities.schema.js

@@ -11,7 +11,8 @@ const MedusaCapabilitiesSchema = CapabilitiesSchema.pick({
   orderSearch: true,
   inventory: true,
   identity: true,
-  profile: true
+  profile: true,
+  productAssociations: true
 }).partial();
 export {
   MedusaCapabilitiesSchema

package/src/index.d.ts

@@ -11,4 +11,5 @@ export * from './providers/order-search.provider.js';
 export * from './providers/price.provider.js';
 export * from './providers/product-search.provider.js';
 export * from './providers/product-recommendations.provider.js';
+export * from './providers/product-associations.provider.js';
 export * from './providers/profile.provider.js';

package/src/providers/product-associations.provider.d.ts

@@ -0,0 +1,16 @@
+import { ProductAssociationsProvider } from '@reactionary/core';
+import type { ProductIdentifier, ProductAssociation, ProductSearchResultItem, ProductSearchResultItemVariant, ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetSparepartsQuery, ProductAssociationsGetReplacementsQuery, Result, RequestContext, Cache } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaAPI } from '../core/client.js';
+import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
+export declare class MedusaProductAssociationsProvider extends ProductAssociationsProvider {
+    protected config: MedusaConfiguration;
+    protected medusa: MedusaAPI;
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusa: MedusaAPI);
+    protected fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductSearchResultItem[]>;
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociation[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociation[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociation[]>>;
+    protected parseSingle(_body: StoreProduct): ProductSearchResultItem;
+    protected parseVariant(variant: StoreProductVariant, product: StoreProduct): ProductSearchResultItemVariant;
+}

package/src/providers/product.provider.d.ts

@@ -6,6 +6,7 @@ import type { StoreProduct, StoreProductVariant } from '@medusajs/types';
 export declare class MedusaProductProvider extends ProductProvider {
     medusaApi: MedusaAPI;
     protected config: MedusaConfiguration;
+    protected alwaysIncludedFields: string[];
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, medusaApi: MedusaAPI);
     getById(payload: ProductQueryById): Promise<Result<Product>>;
     getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>>;

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

@@ -10,6 +10,7 @@ export declare const MedusaCapabilitiesSchema: z.ZodObject<{
     category: z.ZodOptional<z.ZodBoolean>;
     profile: z.ZodOptional<z.ZodBoolean>;
     productSearch: z.ZodOptional<z.ZodBoolean>;
+    productAssociations: z.ZodOptional<z.ZodBoolean>;
     productRecommendations: z.ZodOptional<z.ZodBoolean>;
     orderSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;