@reactionary/provider-medusa 0.1.13 → 0.2.2

package/providers/identity.provider.js

@@ -17,8 +17,7 @@ import {
   IdentityMutationRegisterSchema,
   IdentityMutationLoginSchema,
   IdentityMutationLogoutSchema,
-  AnonymousIdentitySchema,
-  RegisteredIdentitySchema
+  success
 } from "@reactionary/core";
 import createDebug from "debug";
 const debug = createDebug("reactionary:medusa:identity");
@@ -30,13 +29,6 @@ class MedusaIdentityProvider extends IdentityProvider {
   }
   createAnonymousIdentity() {
     return {
-      meta: {
-        cache: {
-          hit: false,
-          key: ""
-        },
-        placeholder: false
-      },
       type: "Anonymous"
     };
   }
@@ -46,29 +38,22 @@ class MedusaIdentityProvider extends IdentityProvider {
       const token = await medusaClient.client.getToken();
       if (!token) {
         debug("No active session token found, returning anonymous identity");
-        return this.createAnonymousIdentity();
+        return success(this.createAnonymousIdentity());
       }
       const customerResponse = await medusaClient.store.customer.retrieve();
       if (customerResponse.customer) {
         debug("Customer authenticated:", customerResponse.customer.email);
-        return {
+        return success({
           id: {
             userId: customerResponse.customer.id
           },
-          meta: {
-            cache: {
-              hit: false,
-              key: ""
-            },
-            placeholder: false
-          },
           type: "Registered"
-        };
+        });
       }
-      return this.createAnonymousIdentity();
+      return success(this.createAnonymousIdentity());
     } catch (error) {
       debug("getSelf failed, returning anonymous identity:", error);
-      return this.createAnonymousIdentity();
+      return success(this.createAnonymousIdentity());
     }
   }
   async login(payload) {
@@ -78,12 +63,12 @@ class MedusaIdentityProvider extends IdentityProvider {
       payload.password,
       this.context
     );
-    return identity;
+    return success(identity);
   }
   async logout(_payload) {
     debug("Logging out user");
     const identity = await this.client.logout(this.context);
-    return identity;
+    return success(identity);
   }
   async register(payload) {
     debug("Registering new user:", payload.username);
@@ -98,8 +83,7 @@ class MedusaIdentityProvider extends IdentityProvider {
       lastName,
       this.context
     );
-    return identity;
-    ;
+    return success(identity);
   }
 }
 __decorateClass([

package/providers/inventory.provider.js

@@ -13,7 +13,8 @@ import {
   InventoryProvider,
   InventorySchema,
   InventoryQueryBySKUSchema,
-  Reactionary
+  Reactionary,
+  success
 } from "@reactionary/core";
 import { MedusaAdminClient } from "../core/client.js";
 import createDebug from "debug";
@@ -41,7 +42,7 @@ class MedusaInventoryProvider extends InventoryProvider {
         if (debug.enabled) {
           debug(`No inventory items found for SKU: ${sku}`);
         }
-        return this.createEmptyInventoryResult(sku, fulfillmentCenterKey);
+        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
       }
       const inventoryItem = inventoryResponse.inventory_items[0];
       const locationsResponse = await adminClient.admin.stockLocation.list({
@@ -66,19 +67,19 @@ class MedusaInventoryProvider extends InventoryProvider {
         if (debug.enabled) {
           debug(`No stock location found with name: ${fulfillmentCenterKey}`);
         }
-        return this.createEmptyInventoryResult(sku, fulfillmentCenterKey);
+        return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
       }
-      return this.parseSingle({
+      return success(this.parseSingle({
         sku: payload.variant.sku,
         fulfillmentCenterKey,
         quantity,
         inventoryItemId: inventoryItem.id
-      });
+      }));
     } catch (error) {
       if (debug.enabled) {
         debug(`Error fetching inventory for SKU: ${sku}`, error);
       }
-      return this.createEmptyInventoryResult(sku, fulfillmentCenterKey);
+      return success(this.createEmptyInventoryResult(sku, fulfillmentCenterKey));
     }
   }
   parseSingle(_body) {
@@ -95,16 +96,8 @@ class MedusaInventoryProvider extends InventoryProvider {
     if (quantity > 0) {
       status = "inStock";
     }
-    const meta = {
-      cache: {
-        hit: false,
-        key: this.generateCacheKeySingle(identifier)
-      },
-      placeholder: false
-    };
     const result = {
       identifier,
-      meta,
       quantity,
       status
     };
@@ -124,16 +117,8 @@ class MedusaInventoryProvider extends InventoryProvider {
     };
     const quantity = 0;
     const status = "outOfStock";
-    const meta = {
-      cache: {
-        hit: false,
-        key: this.generateCacheKeySingle(identifier)
-      },
-      placeholder: true
-    };
     const result = {
       identifier,
-      meta,
       quantity,
       status
     };

package/providers/price.provider.js

@@ -14,7 +14,8 @@ import {
   PriceSchema,
   CustomerPriceQuerySchema,
   ListPriceQuerySchema,
-  Reactionary
+  Reactionary,
+  success
 } from "@reactionary/core";
 import createDebug from "debug";
 const debug = createDebug("reactionary:medusa:price");
@@ -24,11 +25,13 @@ class MedusaPriceProvider extends PriceProvider {
     this.client = client;
     this.config = config;
   }
-  getListPrice(payload) {
-    return this.getBySKU(payload);
+  async getListPrice(payload) {
+    const result = await this.getBySKU(payload);
+    return success(result);
   }
-  getCustomerPrice(payload) {
-    return this.getBySKU(payload);
+  async getCustomerPrice(payload) {
+    const result = await this.getBySKU(payload);
+    return success(result);
   }
   async getBySKU(payload) {
     const sku = payload.variant.sku;
@@ -80,16 +83,8 @@ class MedusaPriceProvider extends PriceProvider {
         currency: this.context.languageContext.currencyCode
       };
     }
-    const meta = {
-      cache: {
-        hit: false,
-        key: this.generateCacheKeySingle(identifier)
-      },
-      placeholder: calculatedPrice === void 0
-    };
     const result = {
       identifier,
-      meta,
       tieredPrices: [],
       unitPrice
     };

package/providers/product-search.provider.js

@@ -17,11 +17,11 @@ import {
   ProductVariantOptionSchema,
   ProductOptionIdentifierSchema,
   ProductSearchResultItemVariantSchema,
-  createPaginatedResponseSchema,
   Reactionary,
   ProductSearchResultSchema,
   FacetValueIdentifierSchema,
-  FacetIdentifierSchema
+  FacetIdentifierSchema,
+  success
 } from "@reactionary/core";
 import createDebug from "debug";
 const debug = createDebug("reactionary:medusa:search");
@@ -65,13 +65,21 @@ class MedusaSearchProvider extends ProductSearchProvider {
     const client = await this.client.getClient();
     let categoryIdToFind = null;
     if (payload.search.categoryFilter?.key) {
-      debug(`Resolving category filter for key: ${payload.search.categoryFilter.key}`);
-      const category = await this.resolveCategoryIdByExternalId(payload.search.categoryFilter.key);
+      debug(
+        `Resolving category filter for key: ${payload.search.categoryFilter.key}`
+      );
+      const category = await this.resolveCategoryIdByExternalId(
+        payload.search.categoryFilter.key
+      );
       if (category) {
         categoryIdToFind = category.id;
-        debug(`Resolved category filter key ${payload.search.categoryFilter.key} to id: ${categoryIdToFind}`);
+        debug(
+          `Resolved category filter key ${payload.search.categoryFilter.key} to id: ${categoryIdToFind}`
+        );
       } else {
-        debug(`Could not resolve category filter for key: ${payload.search.categoryFilter.key}`);
+        debug(
+          `Could not resolve category filter for key: ${payload.search.categoryFilter.key}`
+        );
       }
     }
     const finalSearch = (payload.search.term || "").trim().replace("*", "");
@@ -83,19 +91,19 @@ class MedusaSearchProvider extends ProductSearchProvider {
     });
     const result = this.parsePaginatedResult(response);
     if (debug.enabled) {
-      debug(`Search for term "${payload.search.term}" returned ${response.products.length} products (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`);
+      debug(
+        `Search for term "${payload.search.term}" returned ${response.products.length} products (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
     }
     result.identifier = {
       ...payload.search
     };
-    result.meta = {
-      cache: { hit: false, key: "" },
-      placeholder: false
-    };
-    return result;
+    return success(result);
   }
   parsePaginatedResult(remote) {
-    const products = remote.products.map((p) => this.parseSingle(p));
+    const products = remote.products.map(
+      (p) => this.parseSingle(p)
+    );
     const result = {
       identifier: {
         facets: [],
@@ -106,10 +114,6 @@ class MedusaSearchProvider extends ProductSearchProvider {
         },
         term: ""
       },
-      meta: {
-        cache: { hit: false, key: "unknown" },
-        placeholder: false
-      },
       pageNumber: (Math.ceil(remote.offset / remote.limit) || 0) + 1,
       pageSize: remote.limit,
       totalCount: remote.count,
@@ -129,16 +133,8 @@ class MedusaSearchProvider extends ProductSearchProvider {
     if (heroVariant) {
       variants.push(this.parseVariant(heroVariant, _body));
     }
-    const meta = {
-      cache: {
-        hit: false,
-        key: ""
-      },
-      placeholder: false
-    };
     const result = {
       identifier,
-      meta,
       name,
       slug,
       variants
@@ -151,18 +147,18 @@ class MedusaSearchProvider extends ProductSearchProvider {
       altText: product.title || void 0
     });
     const mappedOptions = variant.options?.filter((x) => x.option?.title === "Color").map(
-      (opt) => ProductVariantOptionSchema.parse(
-        {
-          identifier: ProductOptionIdentifierSchema.parse({
-            key: opt.option_id
-          }),
-          name: opt.value || ""
-        }
-      )
+      (opt) => ProductVariantOptionSchema.parse({
+        identifier: ProductOptionIdentifierSchema.parse({
+          key: opt.option_id
+        }),
+        name: opt.value || ""
+      })
     ) || [];
     const mappedOption = variant.options?.[0];
     return ProductSearchResultItemVariantSchema.parse({
-      variant: ProductVariantIdentifierSchema.parse({ sku: variant.sku || "" }),
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || ""
+      }),
       image: img
     });
   }
@@ -174,7 +170,7 @@ class MedusaSearchProvider extends ProductSearchProvider {
       facet: facetIdentifier,
       key: payload.categoryPath[payload.categoryPath.length - 1].identifier.key
     });
-    return facetValueIdentifier;
+    return success(facetValueIdentifier);
   }
   parseFacetValue(facetValueIdentifier, label, count) {
     throw new Error("Method not implemented.");

package/providers/product.provider.js

@@ -17,7 +17,9 @@ import {
   ProductQueryBySKUSchema,
   ProductQueryBySlugSchema,
   ProductSchema,
-  Reactionary
+  Reactionary,
+  success,
+  error
 } from "@reactionary/core";
 import createDebug from "debug";
 const debug = createDebug("reactionary:medusa:product");
@@ -37,13 +39,13 @@ class MedusaProductProvider extends ProductProvider {
       response = await client.store.product.retrieve(payload.identifier.key, {
         fields: "+metadata,+categories.metadata.*"
       });
-    } catch (error) {
+    } catch (error2) {
       if (debug.enabled) {
-        debug(`Product with ID: ${payload.identifier.key} not found, returning empty product. Error %O `, error);
+        debug(`Product with ID: ${payload.identifier.key} not found, returning empty product. Error %O `, error2);
       }
-      return this.createEmptyProduct(payload.identifier.key);
+      return success(this.createEmptyProduct(payload.identifier.key));
     }
-    return this.parseSingle(response.product);
+    return success(this.parseSingle(response.product));
   }
   async getBySlug(payload) {
     const client = await this.client.getClient();
@@ -60,9 +62,12 @@ class MedusaProductProvider extends ProductProvider {
       debug(`Found ${response.count} products for slug: ${payload.slug}`);
     }
     if (response.count === 0) {
-      return null;
+      return error({
+        type: "NotFound",
+        identifier: payload
+      });
     }
-    return this.parseSingle(response.products[0]);
+    return success(this.parseSingle(response.products[0]));
   }
   async getBySKU(payload) {
     if (debug.enabled) {
@@ -76,7 +81,7 @@ class MedusaProductProvider extends ProductProvider {
     }
     product.variants = [];
     product.variants.push(variant);
-    return this.parseSingle(product);
+    return success(this.parseSingle(product));
   }
   parseSingle(_body) {
     const identifier = ProductIdentifierSchema.parse({ key: _body.id });
@@ -99,10 +104,6 @@ class MedusaProductProvider extends ProductProvider {
         ..._body.variants.slice(1).map((variant) => this.parseVariant(variant, _body))
       );
     }
-    const meta = {
-      cache: { hit: false, key: this.generateCacheKeySingle(identifier) },
-      placeholder: false
-    };
     const result = {
       brand: "",
       description,
@@ -110,7 +111,6 @@ class MedusaProductProvider extends ProductProvider {
       longDescription: "",
       mainVariant,
       manufacturer: "",
-      meta,
       name,
       options: [],
       parentCategories,