@reactionary/examples-node 0.3.13 → 0.3.15

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@reactionary/examples-node",
-  "version": "0.3.13",
+  "version": "0.3.15",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.13",
-    "@reactionary/provider-commercetools": "0.3.13",
-    "@reactionary/provider-algolia": "0.3.13",
-    "@reactionary/provider-medusa": "0.3.13",
-    "@reactionary/provider-meilisearch": "0.3.13",
-    "@reactionary/provider-fake": "0.3.13"
+    "@reactionary/core": "0.3.15",
+    "@reactionary/provider-commercetools": "0.3.15",
+    "@reactionary/provider-algolia": "0.3.15",
+    "@reactionary/provider-medusa": "0.3.15",
+    "@reactionary/provider-meilisearch": "0.3.15",
+    "@reactionary/provider-fake": "0.3.15"
   },
   "type": "module"
 }

package/src/capabilities/product-associations.spec.ts

@@ -0,0 +1,233 @@
+import 'dotenv/config';
+import { assert, beforeEach, describe, expect, it, vi } from 'vitest';
+import { createClient, PrimaryProvider } from '../utils.js';
+import type { ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+
+const testData = {
+  productWithAssociations: {
+    id: 'product_102456',
+  },
+  productWithoutAssociations: {
+    id: 'product_100201',
+  },
+};
+
+describe.each([PrimaryProvider.FAKE, PrimaryProvider.COMMERCETOOLS, PrimaryProvider.MEDUSA] )(
+  'Product Associations - %s',
+  (provider) => {
+    let client: ReturnType<typeof createClient>;
+
+    beforeEach(() => {
+      client = createClient(provider);
+    });
+
+    describe('Accessories', () => {
+      it('should be able to return a list of accessories for a product that has them', async () => {
+        const result = await client.productAssociations.getAccessories({
+          forProduct: { key: testData.productWithAssociations.id },
+          numberOfAccessories: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBeGreaterThan(0);
+        const firstResult = result.value[0];
+        expect(firstResult.associationReturnType).toBe('productSearchResultItem');
+        if (firstResult.associationReturnType === 'productSearchResultItem') {
+          expect(firstResult.product.identifier.key).toBeDefined();
+          expect(firstResult.product.name).toBeDefined();
+          expect(firstResult.product.slug).toBeDefined();
+          expect(firstResult.product.variants).toBeDefined();
+          expect(firstResult.product.variants.length).toBeGreaterThan(0);
+          expect(firstResult.product.variants[0].variant.sku).toBeDefined();
+          expect(firstResult.product.variants[0].image.sourceUrl).toBeDefined();
+        }
+      });
+
+      it('can return a subset of the full list', async () => {
+        const result = await client.productAssociations.getAccessories({
+          forProduct: { key: testData.productWithAssociations.id },
+          numberOfAccessories: 2,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(2);
+      });
+
+
+      it('should return an empty list for a product that has no accessories', async () => {
+        const result = await client.productAssociations.getAccessories({
+          forProduct: { key: testData.productWithoutAssociations.id },
+          numberOfAccessories: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(0);
+      });
+
+      it('should return an empty result for an unknown product', async () => {
+        const result = await client.productAssociations.getAccessories({
+          forProduct: {
+            key: 'unknown-product-id',
+          },
+          numberOfAccessories: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(0);
+      });
+    });
+
+
+
+    describe('Spareparts', () => {
+      it('should be able to return a list of spareparts for a product that has them', async () => {
+        const result = await client.productAssociations.getSpareparts({
+          forProduct: { key: testData.productWithAssociations.id },
+          numberOfSpareparts: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBeGreaterThan(0);
+        const firstResult = result.value[0];
+        expect(firstResult.associationReturnType).toBe('productSearchResultItem');
+        if (firstResult.associationReturnType === 'productSearchResultItem') {
+          expect(firstResult.product.identifier.key).toBeDefined();
+          expect(firstResult.product.name).toBeDefined();
+          expect(firstResult.product.slug).toBeDefined();
+          expect(firstResult.product.variants).toBeDefined();
+          expect(firstResult.product.variants.length).toBeGreaterThan(0);
+          expect(firstResult.product.variants[0].variant.sku).toBeDefined();
+          expect(firstResult.product.variants[0].image.sourceUrl).toBeDefined();
+        }
+      });
+
+      it('can return a subset of the full list', async () => {
+        const result = await client.productAssociations.getSpareparts({
+          forProduct: { key: testData.productWithAssociations.id },
+          numberOfSpareparts: 1,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(1);
+      });
+
+
+      it('should return an empty list for a product that has no spareparts', async () => {
+        const result = await client.productAssociations.getSpareparts({
+          forProduct: { key: testData.productWithoutAssociations.id },
+          numberOfSpareparts: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(0);
+      });
+
+      it('should return an empty result for an unknown product', async () => {
+        const result = await client.productAssociations.getSpareparts({
+          forProduct: {
+            key: 'unknown-product-id',
+          },
+          numberOfSpareparts: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(0);
+      });
+    });
+
+
+
+
+    describe('Replacements', () => {
+      it.skip('should be able to return a list of replacements for a product that has them', async () => {
+        const result = await client.productAssociations.getReplacements({
+          forProduct: { key: testData.productWithAssociations.id },
+          numberOfReplacements: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBeGreaterThan(0);
+        const firstResult = result.value[0];
+        expect(firstResult.associationReturnType).toBe('productSearchResultItem');
+        if (firstResult.associationReturnType === 'productSearchResultItem') {
+          expect(firstResult.product.identifier.key).toBeDefined();
+          expect(firstResult.product.name).toBeDefined();
+          expect(firstResult.product.slug).toBeDefined();
+          expect(firstResult.product.variants).toBeDefined();
+          expect(firstResult.product.variants.length).toBeGreaterThan(0);
+          expect(firstResult.product.variants[0].variant.sku).toBeDefined();
+          expect(firstResult.product.variants[0].image.sourceUrl).toBeDefined();
+        }
+      });
+
+      it.skip('can return a subset of the full list', async () => {
+        const result = await client.productAssociations.getReplacements({
+          forProduct: { key: testData.productWithAssociations.id },
+          numberOfReplacements: 1,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(1);
+      });
+
+
+      it('should return an empty list for a product that has no replacements', async () => {
+        const result = await client.productAssociations.getReplacements({
+          forProduct: { key: testData.productWithoutAssociations.id },
+          numberOfReplacements: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(0);
+      });
+
+      it('should return an empty result for an unknown product', async () => {
+        const result = await client.productAssociations.getReplacements({
+          forProduct: {
+            key: 'unknown-product-id',
+          },
+          numberOfReplacements: 4,
+        });
+
+        if (!result.success) {
+          assert.fail(JSON.stringify(result.error));
+        }
+
+        expect(result.value.length).toBe(0);
+      });
+    });
+
+  });

package/src/capabilities/product.spec.ts

@@ -15,7 +15,7 @@ const testData = {
   },
 };
 
-describe.each([PrimaryProvider.COMMERCETOOLS])(
+describe.each([PrimaryProvider.COMMERCETOOLS, PrimaryProvider.MEDUSA])(
   'Product Capability - %s',
   (provider) => {
     let client: ReturnType<typeof createClient>;
@@ -45,7 +45,7 @@ describe.each([PrimaryProvider.COMMERCETOOLS])(
       const response = await client.product.getBySlug({
         slug: testData.product.slug,
       });
-      
+
       if (!response.success) {
         assert.fail();
       }
@@ -111,7 +111,7 @@ describe.each([PrimaryProvider.COMMERCETOOLS])(
 
     it('should return an error of NotFound for unknown slug', async () => {
       const response = await client.product.getBySlug({ slug: 'unknown-slug' });
-      
+
       if (response.success) {
         assert.fail();
       }

package/src/utils.ts

@@ -109,6 +109,7 @@ export function createClient(provider: PrimaryProvider) {
           price: true,
           productSearch: true,
           productRecommendations: true,
+          productAssociations: true,
           orderSearch: true,
           store: true,
           profile: true
@@ -119,7 +120,8 @@ export function createClient(provider: PrimaryProvider) {
     if (provider === PrimaryProvider.FAKE) {
       builder = builder.withCapability(
         withFakeCapabilities( getFakeConfiguration() , {
-          productReviews: true
+          productReviews: true,
+          productAssociations: true,
         }
       ))
     }
@@ -136,6 +138,7 @@ export function createClient(provider: PrimaryProvider) {
           order: true,
           price: true,
           productSearch: true,
+          productAssociations: true,
           productReviews: true,
           orderSearch: true,
           store: true,