@reactionary/provider-medusa 0.1.13 → 0.2.2

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

@@ -1,4 +1,4 @@
-import type { Cache, Product, ProductAttribute, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext } from '@reactionary/core';
+import type { Cache, NotFoundError, Product, ProductAttribute, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext, Result } from '@reactionary/core';
 import { ProductProvider } from '@reactionary/core';
 import type { MedusaClient } from '../core/client.js';
 import type { MedusaConfiguration } from '../schema/configuration.schema.js';
@@ -7,9 +7,9 @@ export declare class MedusaProductProvider extends ProductProvider {
     client: MedusaClient;
     protected config: MedusaConfiguration;
     constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
-    getById(payload: ProductQueryById): Promise<Product>;
-    getBySlug(payload: ProductQueryBySlug): Promise<Product | null>;
-    getBySKU(payload: ProductQueryBySKU): Promise<Product>;
+    getById(payload: ProductQueryById): Promise<Result<Product>>;
+    getBySlug(payload: ProductQueryBySlug): Promise<Result<Product, NotFoundError>>;
+    getBySKU(payload: ProductQueryBySKU): Promise<Result<Product>>;
     protected parseSingle(_body: StoreProduct): Product;
     protected parseVariant(variant: StoreProductVariant, product: StoreProduct): {
         identifier: {

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

@@ -0,0 +1,30 @@
+import { type Profile, type ProfileMutationAddShippingAddress, type ProfileMutationMakeShippingAddressDefault, type ProfileMutationRemoveShippingAddress, type ProfileMutationSetBillingAddress, type ProfileMutationUpdate, type ProfileMutationUpdateShippingAddress, type ProfileQuerySelf as ProfileQueryById, type RequestContext, type Cache, type Result, type NotFoundError, ProfileProvider, type Address } from '@reactionary/core';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import type { MedusaClient } from '../core/client.js';
+import type { StoreCreateCustomerAddress, StoreCustomer, StoreCustomerAddress } from '@medusajs/types';
+/**
+ * Medusa Profile Provider
+ *
+ * Implements profile management using Medusa's customer APIs.
+ *
+ * TODO:
+ * - handle email and phone verification status properly using metadata or other means.
+ * - handle guest user scenarios (if applicable).
+ * - improve error handling and edge cases.
+ */
+export declare class MedusaProfileProvider extends ProfileProvider {
+    protected config: MedusaConfiguration;
+    protected client: MedusaClient;
+    protected includedFields: string[];
+    constructor(config: MedusaConfiguration, cache: Cache, context: RequestContext, client: MedusaClient);
+    getById(payload: ProfileQueryById): Promise<Result<Profile, NotFoundError>>;
+    update(payload: ProfileMutationUpdate): Promise<Result<Profile, NotFoundError>>;
+    addShippingAddress(payload: ProfileMutationAddShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    updateShippingAddress(payload: ProfileMutationUpdateShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    removeShippingAddress(payload: ProfileMutationRemoveShippingAddress): Promise<Result<Profile, NotFoundError>>;
+    makeShippingAddressDefault(payload: ProfileMutationMakeShippingAddressDefault): Promise<Result<Profile, NotFoundError>>;
+    setBillingAddress(payload: ProfileMutationSetBillingAddress): Promise<Result<Profile, NotFoundError>>;
+    protected createMedusaAddress(address: Address): StoreCreateCustomerAddress;
+    protected parseAddress(address: StoreCustomerAddress): Address;
+    protected parseSingle(customer: StoreCustomer): Profile;
+}

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

@@ -2,11 +2,12 @@ import type { z } from 'zod';
 export declare const MedusaCapabilitiesSchema: z.ZodObject<{
     price: z.ZodOptional<z.ZodBoolean>;
     product: z.ZodOptional<z.ZodBoolean>;
-    identity: z.ZodOptional<z.ZodBoolean>;
     cart: z.ZodOptional<z.ZodBoolean>;
     checkout: z.ZodOptional<z.ZodBoolean>;
-    productSearch: z.ZodOptional<z.ZodBoolean>;
+    identity: z.ZodOptional<z.ZodBoolean>;
     inventory: z.ZodOptional<z.ZodBoolean>;
     category: z.ZodOptional<z.ZodBoolean>;
+    profile: z.ZodOptional<z.ZodBoolean>;
+    productSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type MedusaCapabilities = z.infer<typeof MedusaCapabilitiesSchema>;

package/test/cart.provider.spec.js

@@ -1,5 +1,5 @@
-import { NoOpCache, createInitialRequestContext } from "@reactionary/core";
-import { beforeEach, describe, expect, it } from "vitest";
+import { NoOpCache, createInitialRequestContext, unwrapValue } from "@reactionary/core";
+import { assert, beforeEach, describe, expect, it } from "vitest";
 import { MedusaClient } from "../core/client.js";
 import { MedusaCartProvider } from "../providers/cart.provider.js";
 import { getMedusaTestConfiguration } from "./test-utils.js";
@@ -16,88 +16,99 @@ describe("Medusa Cart Provider", () => {
     provider = new MedusaCartProvider(getMedusaTestConfiguration(), new NoOpCache(), reqCtx, client);
   });
   describe("anonymous sessions", () => {
-    it("should be able to get an empty cart", async () => {
+    it("should get a NotFound for an unknown identifier", async () => {
       const cart = await provider.getById({
         cart: { key: "" }
       });
-      expect(cart.identifier.key).toBeFalsy();
-      expect(cart.items.length).toBe(0);
-      expect(cart.meta?.placeholder).toBe(true);
+      if (cart.success) {
+        assert.fail();
+      }
+      expect(cart.error.type).toBe("NotFound");
     });
     it("should be able to add an item to a cart", async () => {
       const cart = await provider.add({
-        cart: { key: "" },
         variant: {
           sku: testData.skuWithoutTiers
         },
         quantity: 1
       });
-      expect(cart.identifier.key).toBeDefined();
-      expect(cart.items.length).toBe(1);
-      expect(cart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
-      expect(cart.items[0].quantity).toBe(1);
-      expect(cart.items[0].price.totalPrice.value).toBeGreaterThan(0);
-      expect(cart.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
-      expect(cart.price.grandTotal.value).toBeGreaterThan(0);
-      expect(cart.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
-      expect(cart.price.grandTotal.value).toBe(cart.items[0].price.totalPrice.value);
-      expect(cart.meta?.placeholder).toBeFalsy();
+      if (!cart.success) {
+        assert.fail();
+      }
+      expect(cart.value.identifier.key).toBeDefined();
+      expect(cart.value.items.length).toBe(1);
+      expect(cart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(cart.value.items[0].quantity).toBe(1);
+      expect(cart.value.items[0].price.totalPrice.value).toBeGreaterThan(0);
+      expect(cart.value.items[0].price.totalPrice.currency).toBe(reqCtx.languageContext.currencyCode);
+      expect(cart.value.price.grandTotal.value).toBeGreaterThan(0);
+      expect(cart.value.price.grandTotal.currency).toBe(reqCtx.languageContext.currencyCode);
+      expect(cart.value.price.grandTotal.value).toBe(cart.value.items[0].price.totalPrice.value);
     });
     it("can add multiple different items to a cart", async () => {
       const cart = await provider.add({
-        cart: { key: "" },
         variant: {
           sku: testData.skuWithoutTiers
         },
         quantity: 1
       });
+      if (!cart.success) {
+        assert.fail();
+      }
       const updatedCart = await provider.add({
-        cart: cart.identifier,
+        cart: cart.value.identifier,
         variant: {
           sku: testData.skuWithTiers
         },
         quantity: 2
       });
-      expect(updatedCart.items.length).toBe(2);
-      expect(updatedCart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
-      expect(updatedCart.items[0].quantity).toBe(1);
-      expect(updatedCart.items[1].variant.sku).toBe(testData.skuWithTiers);
-      expect(updatedCart.items[1].quantity).toBe(2);
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+      expect(updatedCart.value.items.length).toBe(2);
+      expect(updatedCart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.value.items[0].quantity).toBe(1);
+      expect(updatedCart.value.items[1].variant.sku).toBe(testData.skuWithTiers);
+      expect(updatedCart.value.items[1].quantity).toBe(2);
     });
     it("should be able to change quantity of an item in a cart", async () => {
       const cart = await provider.add({
-        cart: { key: "" },
         variant: {
           sku: testData.skuWithoutTiers
         },
         quantity: 1
       });
+      if (!cart.success) {
+        assert.fail();
+      }
       const updatedCart = await provider.changeQuantity({
-        cart: cart.identifier,
-        item: cart.items[0].identifier,
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
         quantity: 3
       });
-      expect(updatedCart.items.length).toBe(1);
-      expect(updatedCart.items[0].variant.sku).toBe(testData.skuWithoutTiers);
-      expect(updatedCart.items[0].quantity).toBe(3);
-      expect(updatedCart.items[0].price.totalPrice.value).toBe(cart.items[0].price.totalPrice.value * 3);
-      expect(updatedCart.items[0].price.unitPrice.value).toBe(cart.items[0].price.unitPrice.value);
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+      expect(updatedCart.value.items.length).toBe(1);
+      expect(updatedCart.value.items[0].variant.sku).toBe(testData.skuWithoutTiers);
+      expect(updatedCart.value.items[0].quantity).toBe(3);
+      expect(updatedCart.value.items[0].price.totalPrice.value).toBe(cart.value.items[0].price.totalPrice.value * 3);
+      expect(updatedCart.value.items[0].price.unitPrice.value).toBe(cart.value.items[0].price.unitPrice.value);
     });
     it("cannot set quantity below 1", async () => {
-      const cart = await provider.add({
-        cart: { key: "" },
+      const cart = unwrapValue(await provider.add({
         variant: {
           sku: testData.skuWithoutTiers
         },
         quantity: 1
-      });
+      }));
       let updatedCart;
       try {
-        updatedCart = await provider.changeQuantity({
+        updatedCart = unwrapValue(await provider.changeQuantity({
           cart: cart.identifier,
           item: cart.items[0].identifier,
           quantity: 0
-        });
+        }));
         expect(updatedCart).toBeDefined();
       } catch (error) {
         expect(error).toBeDefined();
@@ -107,37 +118,46 @@ describe("Medusa Cart Provider", () => {
     });
     it("should be able to remove an item from a cart", async () => {
       const cart = await provider.add({
-        cart: { key: "" },
         variant: {
           sku: testData.skuWithoutTiers
         },
         quantity: 1
       });
+      if (!cart.success) {
+        assert.fail();
+      }
       const updatedCart = await provider.remove({
-        cart: cart.identifier,
-        item: cart.items[0].identifier
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier
       });
-      expect(updatedCart.items.length).toBe(0);
+      if (!updatedCart.success) {
+        assert.fail();
+      }
+      expect(updatedCart.value.items.length).toBe(0);
     });
     it("should be able to delete a cart", async () => {
       const cart = await provider.add({
-        cart: { key: "" },
         variant: {
           sku: testData.skuWithoutTiers
         },
         quantity: 1
       });
-      expect(cart.items.length).toBe(1);
-      expect(cart.identifier.key).toBeTruthy();
+      if (!cart.success) {
+        assert.fail();
+      }
+      expect(cart.value.items.length).toBe(1);
+      expect(cart.value.identifier.key).toBeTruthy();
       const deletedCart = await provider.deleteCart({
-        cart: cart.identifier
+        cart: cart.value.identifier
       });
-      expect(deletedCart.items.length).toBe(0);
-      expect(deletedCart.identifier.key).toBe("");
+      expect(deletedCart.success).toBe(true);
       const originalCart = await provider.getById({
-        cart: cart.identifier
+        cart: cart.value.identifier
       });
-      expect(originalCart.items.length).toBe(0);
+      if (originalCart.success) {
+        assert.fail();
+      }
+      expect(originalCart.error.type).toBe("NotFound");
     });
   });
 });

package/test/category.provider.spec.js

@@ -1,8 +1,12 @@
 import "dotenv/config";
-import { CategorySchema, NoOpCache, createInitialRequestContext } from "@reactionary/core";
+import {
+  CategorySchema,
+  NoOpCache,
+  createInitialRequestContext
+} from "@reactionary/core";
 import { MedusaCategoryProvider } from "../providers/category.provider.js";
 import { getMedusaTestConfiguration } from "./test-utils.js";
-import { describe, expect, it, beforeEach } from "vitest";
+import { describe, expect, it, beforeEach, assert } from "vitest";
 import { MedusaClient } from "../core/client.js";
 const testData = {
   topCategories: [
@@ -31,95 +35,153 @@ describe("Medusa Category Provider", () => {
     reqCtx = createInitialRequestContext();
     const config = getMedusaTestConfiguration();
     const client = new MedusaClient(config, reqCtx);
-    provider = new MedusaCategoryProvider(config, new NoOpCache(), reqCtx, client);
+    provider = new MedusaCategoryProvider(
+      config,
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
   });
   it("should be able to get top-categories", async () => {
-    const result = await provider.findTopCategories({ paginationOptions: { pageSize: 10, pageNumber: 1 } });
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.items[0].identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.items[0].name).toBe(testData.topCategories[0].name);
-    expect(result.items[1].identifier.key).toBe(testData.topCategories[1].key);
-    expect(result.items[1].name).toBe(testData.topCategories[1].name);
+    const result = await provider.findTopCategories({
+      paginationOptions: { pageSize: 10, pageNumber: 1 }
+    });
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.items[0].identifier.key).toBe(
+      testData.topCategories[0].key
+    );
+    expect(result.value.items[0].name).toBe(testData.topCategories[0].name);
+    expect(result.value.items[1].identifier.key).toBe(
+      testData.topCategories[1].key
+    );
+    expect(result.value.items[1].name).toBe(testData.topCategories[1].name);
   });
   it("should be able to get child categories for a category", async () => {
-    const result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 10, pageNumber: 1 } });
+    const result = await provider.findChildCategories({
+      parentId: { key: testData.topCategories[0].key },
+      paginationOptions: { pageSize: 10, pageNumber: 1 }
+    });
+    if (!result.success) {
+      assert.fail();
+    }
     for (const verificationData of testData.childCategoriesOfFirstTopcategory) {
-      const found = result.items.find((item) => item.identifier.key === verificationData.key);
+      const found = result.value.items.find(
+        (item) => item.identifier.key === verificationData.key
+      );
       expect(found).toBeDefined();
       expect(found?.name).toBe(verificationData.name);
     }
   });
   it("should be able to get child categories for a category, paged", async () => {
-    const result = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 1, pageNumber: 1 } });
-    expect(result.items.length).toBeGreaterThan(0);
-    expect(result.totalCount).toBeGreaterThan(1);
-    expect(result.totalPages).toBeGreaterThan(1);
-    expect(result.pageSize).toBe(1);
-    expect(result.pageNumber).toBe(1);
-    const result2 = await provider.findChildCategories({ parentId: { key: testData.topCategories[0].key }, paginationOptions: { pageSize: 1, pageNumber: 2 } });
-    expect(result2.items.length).toBeGreaterThan(0);
-    expect(result2.totalCount).toBeGreaterThan(1);
-    expect(result2.totalPages).toBeGreaterThan(1);
-    expect(result2.pageSize).toBe(1);
-    expect(result2.pageNumber).toBe(2);
-    for (const item of result2.items) {
-      expect(result.items.find((i) => i.identifier.key === item.identifier.key)).toBeUndefined();
+    const result = await provider.findChildCategories({
+      parentId: { key: testData.topCategories[0].key },
+      paginationOptions: { pageSize: 1, pageNumber: 1 }
+    });
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.totalCount).toBeGreaterThan(1);
+    expect(result.value.totalPages).toBeGreaterThan(1);
+    expect(result.value.pageSize).toBe(1);
+    expect(result.value.pageNumber).toBe(1);
+    const result2 = await provider.findChildCategories({
+      parentId: { key: testData.topCategories[0].key },
+      paginationOptions: { pageSize: 1, pageNumber: 2 }
+    });
+    if (!result2.success) {
+      assert.fail();
+    }
+    expect(result2.value.items.length).toBeGreaterThan(0);
+    expect(result2.value.totalCount).toBeGreaterThan(1);
+    expect(result2.value.totalPages).toBeGreaterThan(1);
+    expect(result2.value.pageSize).toBe(1);
+    expect(result2.value.pageNumber).toBe(2);
+    for (const item of result2.value.items) {
+      expect(
+        result.value.items.find((i) => i.identifier.key === item.identifier.key)
+      ).toBeUndefined();
     }
   });
   it("can load all breadcrumbs for a category", async () => {
     const leaf = testData.breadCrumb[testData.breadCrumb.length - 1];
-    const result = await provider.getBreadcrumbPathToCategory({ id: { key: leaf } });
-    expect(result.length).toBe(testData.breadCrumb.length);
+    const result = await provider.getBreadcrumbPathToCategory({
+      id: { key: leaf }
+    });
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.length).toBe(testData.breadCrumb.length);
     for (let i = 0; i < testData.breadCrumb.length; i++) {
-      expect(result[i].identifier.key).toBe(testData.breadCrumb[i]);
+      expect(result.value[i].identifier.key).toBe(testData.breadCrumb[i]);
     }
   });
   it("should be able to get a category by slug", async () => {
-    const result = await provider.getBySlug({ slug: testData.topCategories[0].slug });
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.name).toBe(testData.topCategories[0].name);
-      expect(result.slug).toBe(testData.topCategories[0].slug);
-      expect(result.parentCategory).toBeUndefined();
-      expect(result.text).not.toBe("");
-      expect(result.meta.placeholder).toBe(false);
+    const result = await provider.getBySlug({
+      slug: testData.topCategories[0].slug
+    });
+    if (!result.success) {
+      assert.fail();
     }
+    expect(result.value.name).toBe(testData.topCategories[0].name);
+    expect(result.value.slug).toBe(testData.topCategories[0].slug);
+    expect(result.value.parentCategory).toBeUndefined();
+    expect(result.value.text).not.toBe("");
   });
-  it("returns null if looking for slug that does not exist", async () => {
+  it("returns NotFound if looking for slug that does not exist", async () => {
     const result = await provider.getBySlug({ slug: "non-existent-slug" });
-    expect(result).toBeNull();
+    if (result.success) {
+      assert.fail();
+    }
+    expect(result.error.type).toBe("NotFound");
   });
   it("should be able to get a category by id", async () => {
-    const result = await provider.getById({ id: { key: testData.topCategories[0].key } });
-    expect(result.identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.name).toBe(testData.topCategories[0].name);
-    expect(result.slug).toBe(testData.topCategories[0].slug);
-    expect(result.parentCategory).toBeUndefined();
-    expect(result.text).toBe(testData.topCategories[0].text);
-    expect(result.meta.placeholder).toBe(false);
+    const result = await provider.getById({
+      id: { key: testData.topCategories[0].key }
+    });
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.identifier.key).toBe(testData.topCategories[0].key);
+    expect(result.value.name).toBe(testData.topCategories[0].name);
+    expect(result.value.slug).toBe(testData.topCategories[0].slug);
+    expect(result.value.parentCategory).toBeUndefined();
+    expect(result.value.text).toBe(testData.topCategories[0].text);
   });
   it.skip("should be able to get a category by id in alternate language", async () => {
     reqCtx.languageContext.locale = "da";
-    const result = await provider.getById({ id: { key: testData.topCategories[0].key } });
-    expect(result.identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.name).toBe(testData.topCategories[0].name + " [da Version]");
-    expect(result.slug).toBe(testData.topCategories[0].slug + "_da");
-    expect(result.parentCategory).toBeUndefined();
-    expect(result.text).toBe(testData.topCategories[0].text + " [da Version]");
-    expect(result.meta.placeholder).toBe(false);
+    const result = await provider.getById({
+      id: { key: testData.topCategories[0].key }
+    });
+    if (!result.success) {
+      assert.fail();
+    }
+    expect(result.value.identifier.key).toBe(testData.topCategories[0].key);
+    expect(result.value.name).toBe(testData.topCategories[0].name + " [da Version]");
+    expect(result.value.slug).toBe(testData.topCategories[0].slug + "_da");
+    expect(result.value.parentCategory).toBeUndefined();
+    expect(result.value.text).toBe(testData.topCategories[0].text + " [da Version]");
   });
-  it.skip("returns empty values if you choose a language that is not available", async () => {
+  it.skip("returns NotFound if you choose a language that is not available", async () => {
     reqCtx.languageContext.locale = "fr-FR";
-    const result = await provider.getById({ id: { key: testData.topCategories[0].key } });
-    expect(result.identifier.key).toBe(testData.topCategories[0].key);
-    expect(result.name).toBe("No Name");
-    expect(result.slug).toBe("");
-    expect(result.parentCategory).toBeUndefined();
-    expect(result.meta.placeholder).toBe(false);
+    const result = await provider.getById({
+      id: { key: testData.topCategories[0].key }
+    });
+    if (result.success) {
+      assert.fail();
+    }
+    expect(result.error.type).toBe("NotFound");
   });
-  it("returns a placeholder if you search for a category that does not exist", async () => {
-    const result = await provider.getById({ id: { key: "non-existent-category" } });
-    expect(result.identifier.key).toBe("non-existent-category");
-    expect(result.meta.placeholder).toBe(true);
+  it("returns NotFound if you search for a category that does not exist", async () => {
+    const result = await provider.getById({
+      id: { key: "non-existent-category" }
+    });
+    if (result.success) {
+      assert.fail();
+    }
+    expect(result.error.type).toBe("NotFound");
   });
 });