@reactionary/source 0.0.52 → 0.2.16

package/providers/medusa/src/schema/medusa.schema.ts

@@ -0,0 +1,31 @@
+import { CartIdentifierSchema, OrderIdentifierSchema } from '@reactionary/core';
+import { z } from 'zod';
+
+export const MedusaCartIdentifierSchema = CartIdentifierSchema.extend({
+  region_id: z.string().optional(),
+});
+
+export const MedusaOrderIdentifierSchema = OrderIdentifierSchema.extend({
+  display_id: z.number().optional(),
+});
+
+export const MedusaRegionSchema = z.looseObject({
+  id: z.string(),
+  name: z.string(),
+  currency_code: z.string(),
+});
+
+export 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 type MedusaCartIdentifier = z.infer<typeof MedusaCartIdentifierSchema>;
+export type MedusaOrderIdentifier = z.infer<typeof MedusaOrderIdentifierSchema>;
+
+export type MedusaSession = z.infer<typeof MedusaSessionSchema>;
+export type MedusaRegion = z.infer<typeof MedusaRegionSchema>;

package/providers/medusa/src/test/cart.provider.spec.ts

@@ -0,0 +1,240 @@
+
+import { NoOpCache, createInitialRequestContext, unwrapValue, type Cart, type CartMutationItemAdd, type RequestContext } from '@reactionary/core';
+import { assert, beforeEach, describe, expect, it } from 'vitest';
+import { MedusaAPI } from '../core/client.js';
+import { MedusaCartProvider } from '../providers/cart.provider.js';
+import { getMedusaTestConfiguration } from './test-utils.js';
+
+
+const testData = {
+  skuWithoutTiers: '4047443491480',
+  skuWithTiers: '0819927012825'
+}
+
+
+describe('Medusa Cart Provider', () => {
+  let provider: MedusaCartProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach( () => {
+    reqCtx = createInitialRequestContext();
+    const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
+    provider = new MedusaCartProvider(getMedusaTestConfiguration(), new NoOpCache(), reqCtx, client);
+  });
+
+  describe('anonymous sessions', () => {
+    it('should get a NotFound for an unknown identifier', async () => {
+      const cart = await provider.getById({
+        cart: { key: '' },
+      });
+
+      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({
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      });
+
+      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({
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      } satisfies CartMutationItemAdd);
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      const updatedCart = await provider.add({
+          cart: cart.value.identifier,
+          variant: {
+            sku: testData.skuWithTiers,
+          },
+          quantity: 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({
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      const updatedCart = await provider.changeQuantity({
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
+        quantity: 3
+      });
+
+      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 = unwrapValue(await provider.add({
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }));
+      let updatedCart: Cart;
+      try {
+        updatedCart = unwrapValue(await provider.changeQuantity({
+          cart: cart.identifier,
+          item: cart.items[0].identifier,
+          quantity: 0
+        }));
+        expect(updatedCart).toBeDefined();
+      } catch (error) {
+        expect(error).toBeDefined();
+        return;
+      }
+      throw new Error('Should have thrown an error');
+
+    });
+
+
+    it('should be able to remove an item from a cart', async () => {
+      const cart = await provider.add({
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      });
+
+      if (!cart.success) {
+        assert.fail();
+      }
+
+      const updatedCart = await provider.remove({
+        cart: cart.value.identifier,
+        item: cart.value.items[0].identifier,
+      });
+
+      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({
+          variant: {
+            sku: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      });
+
+      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.value.identifier,
+      });
+
+      expect(deletedCart.success).toBe(true);
+
+      const originalCart = await provider.getById({
+        cart: cart.value.identifier,
+      });
+
+      if (originalCart.success) {
+        assert.fail();
+      }
+
+      expect(originalCart.error.type).toBe('NotFound');
+    });
+/*
+    it('can load the product information for cart items', async () => {
+
+      const cart = await provider.add({
+          cart: { key: '' },
+          sku: {
+            key: testData.skuWithoutTiers,
+          },
+          quantity: 1
+      }, reqCtx);
+      expect(cart.items[0].sku).toBeDefined();
+
+      const product = await productProvider.getBySKU( { sku: cart.items[0].sku }, reqCtx);
+      expect(product).toBeTruthy();
+      if (product) {
+        expect(product.skus.some(s => s.identifier.key === cart.items[0].sku.key)).toBe(true);
+      }
+    }); */
+    /**
+    it('should be able to create a cart for an anonymous user, then login and merge the cart', async () => {
+    });
+
+    it('should be able to create a cart for an anonymous user, then register and merge the cart', async () => {
+    });
+
+    it('should be able to clear the cart', async () => { });
+
+    it('should be able to check out the cart', async () => { });
+    */
+
+  });
+
+
+});

package/providers/medusa/src/test/category.provider.spec.ts

@@ -0,0 +1,231 @@
+import 'dotenv/config';
+import type { RequestContext } 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, assert } from 'vitest';
+import { MedusaAPI } from '../core/client.js';
+
+const testData = {
+  topCategories: [
+    {
+      key: '2833',
+      name: 'Computers & Peripherals',
+      slug: 'computers-and-peripherals',
+      text: 'Computers & Peripherals',
+    },
+    {
+      key: '9541',
+      name: 'Computer Spare Parts & Accessories',
+      slug: 'computer-spare-parts-and-accessories',
+    },
+  ],
+
+  childCategoriesOfFirstTopcategory: [
+    { key: '225', name: 'Printers & Scanners' },
+    { key: '830', name: 'Computer Cables' },
+  ],
+
+  breadCrumb: ['2833', '225', '373'],
+};
+
+describe('Medusa Category Provider', () => {
+  let provider: MedusaCategoryProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    const config = getMedusaTestConfiguration();
+    const client = new MedusaAPI(config, reqCtx);
+
+    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 },
+    });
+
+    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 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    for (const verificationData of testData.childCategoriesOfFirstTopcategory) {
+      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 },
+    });
+
+    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 },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.length).toBe(testData.breadCrumb.length);
+    for (let i = 0; i < testData.breadCrumb.length; 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,
+    });
+
+    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 NotFound if looking for slug that does not exist', async () => {
+    const result = await provider.getBySlug({ slug: 'non-existent-slug' });
+
+    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 },
+    });
+
+    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 },
+    });
+
+    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 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 },
+    });
+
+    if (result.success) {
+      assert.fail();
+    }
+
+    expect(result.error.type).toBe('NotFound');
+  });
+
+  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');
+  });
+});