@reactionary/examples-node 0.3.12 → 0.3.14

package/package.json

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

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

@@ -9,277 +9,169 @@ const testData = {
   },
 };
 
-describe.each([PrimaryProvider.COMMERCETOOLS])(
-  'Product Reviews',
-  (provider) => {
-    let client: ReturnType<typeof createClient>;
+describe.each([PrimaryProvider.FAKE, PrimaryProvider.COMMERCETOOLS])('Product Reviews', (provider) => {
+  let client: ReturnType<typeof createClient>;
 
-    beforeEach(() => {
-      client = createClient(provider);
-    });
-
-    it('can get a rating summary for a product that has it', async () => {
-      const result = await client.productReviews.getRatingSummary({
-        product: { key: testData.product.id }
-      });
-
-      if (!result.success) {
-        assert.fail(JSON.stringify(result.error));
-      }
+  beforeEach(() => {
+    client = createClient(provider);
+  });
 
-      expect(result.value.averageRating).toBeGreaterThan(0);
-      expect(result.value.totalRatings).toBeGreaterThan(0);
+  it('can get a rating summary for a product that has it', async () => {
+    const result = await client.productReviews.getRatingSummary({
+      product: { key: testData.product.id },
     });
 
-    it('should return an empty result for an unknown product', async () => {
-      const result = await client.productReviews.getRatingSummary({
-        product: { key: 'unknown-product-id' }
-      });
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
 
-      if (result.success) {
-        assert.fail('Expected it to return NotFoundError');
-      }
+    expect(result.value.averageRating).toBeGreaterThan(0);
+    expect(result.value.totalRatings).toBeGreaterThan(0);
+  });
 
-      expect(result.error.type).toBe('NotFound');
+  it('should return an empty result for an unknown product', async () => {
+    const result = await client.productReviews.getRatingSummary({
+      product: { key: 'unknown-product-id' },
     });
 
-    it('can return a list of reviews for a product', async () => {
-      const result = await client.productReviews.listReviews({
-        product: { key: testData.product.id },
-        paginationOptions: {
-          pageNumber: 1,
-          pageSize: 2,
-        },
-      });
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
 
-      if (!result.success) {
-        assert.fail(JSON.stringify(result.error));
-      }
+    expect(result.value.averageRating).toBe(0);
+    expect(result.value.totalRatings).toBeUndefined();
+  });
 
-      expect(result.value.length).toBeLessThanOrEqual(2);
-      if (result.value.length > 0) {
-        expect(result.value[0].identifier.key).toBeDefined();
-        expect(result.value[0].authorName).toBeDefined();
-        expect(result.value[0].rating).toBeGreaterThan(0);
-        expect(result.value[0].content).toBeDefined();
-      }
+  it('can return a list of reviews for a product', async () => {
+    const result = await client.productReviews.findReviews({
+      product: { key: testData.product.id },
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 2,
+      },
     });
 
-    it('should return an empty list of reviews for an unknown product', async () => {
-      const result = await client.productReviews.listReviews({
-        product: { key: 'unknown-product-id' },
-        paginationOptions: {
-          pageNumber: 1,
-          pageSize: 2,
-        },
-      });
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
+
+    expect(result.value.items.length).toBeLessThanOrEqual(2);
+    if (result.value.items.length > 0) {
+      expect(result.value.items[0].identifier.key).toBeDefined();
+      expect(result.value.items[0].authorName).toBeDefined();
+      expect(result.value.items[0].rating).toBeGreaterThan(0);
+      expect(result.value.items[0].content).toBeDefined();
+    }
+  });
 
-      if (result.success) {
-        assert.fail('Expected it to return NotFoundError');
-      }
-      expect(result.error.type).toBe('NotFound');
+  it('should return an empty list of reviews for an unknown product', async () => {
+    const result = await client.productReviews.findReviews({
+      product: { key: 'unknown-product-id' },
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 2,
+      },
     });
 
-    it('can paginate the list of reviews for a product', async () => {
-      const firstPageResult = await client.productReviews.listReviews({
-        product: { key: testData.product.id },
-        paginationOptions: {
-          pageNumber: 1,
-          pageSize: 1,
-        },
-      });
-
-      if (!firstPageResult.success) {
-        assert.fail(JSON.stringify(firstPageResult.error));
-      }
-
-      expect(firstPageResult.value.length).toBe(1);
-      const firstReview = firstPageResult.value[0];
-      expect(firstReview.identifier.key).toBeDefined();
-
-      const secondPageResult = await client.productReviews.listReviews({
-        product: { key: testData.product.id },
-        paginationOptions: {
-          pageNumber: 2,
-          pageSize: 1,
-        },
-      });
+    if (!result.success) {
+      assert.fail(JSON.stringify(result.error));
+    }
+    expect(result.value.items.length).toBe(0);
+  });
 
-      if (!secondPageResult.success) {
-        assert.fail(JSON.stringify(secondPageResult.error));
-      }
+  it('can paginate the list of reviews for a product', async () => {
+    const firstPageResult = await client.productReviews.findReviews({
+      product: { key: testData.product.id },
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 1,
+      },
     });
 
-    describe('Submitting Reviews', () => {
-      it('cannot submit review if not authenticated', async () => {
-        const result = await client.productReviews.submitReview({
-          product: { key: testData.product.id },
-          rating: 4,
-          title: 'Great product!',
-          content: 'I really enjoyed using this product. Highly recommend it.',
-          authorName: 'John Doe',
-        });
-
-        if (result.success) {
-          assert.fail('Expected it to return an error for unauthenticated user');
-        } else {
-          expect(result.error.type).toBe('InvalidInput');
-        }
-      });
-
-      it('can submit a review for a product', async () => {
-
-        const newIdentity = await client.identity.register({
-          username: `testuser_${Date.now()}@example.com`,
-          password: 'password123',
-        });
-
-        const result = await client.productReviews.submitReview({
-          product: { key: testData.product.id },
-          rating: 4,
-          title: 'Great product!',
-          content: 'I really enjoyed using this product. Highly recommend it.',
-          authorName: 'John Doe',
-        });
+    if (!firstPageResult.success) {
+      assert.fail(JSON.stringify(firstPageResult.error));
+    }
 
-        if (!result.success) {
-          assert.fail(JSON.stringify(result.error));
-        }
-      });
-
-      it('can submit a rating without review', async () => {
-        const result = await client.productReviews.submitReview({
-          product: { key: testData.product.id },
-          rating: 5,
-          title: '',
-          content: '',
-          authorName: 'Jane Doe',
-        });
-      });
+    expect(firstPageResult.value.items.length).toBe(1);
+    const firstReview = firstPageResult.value.items[0];
+    expect(firstReview.identifier.key).toBeDefined();
 
-      it('should return an error when submitting a review with invalid rating', async () => {
-        const result = await client.productReviews.submitReview({
-          product: { key: testData.product.id },
-          rating: 6, // Invalid rating, should be between 1 and 5
-          title: 'Invalid rating',
-          content: 'This review has an invalid rating.',
-          authorName: 'Invalid User',
-        });
-
-        if (result.success) {
-          assert.fail('Expected it to return an error for invalid rating');
-        } else {
-          expect(result.error.type).toBe('InvalidInput');
-        }
-      });
+    const secondPageResult = await client.productReviews.findReviews({
+      product: { key: testData.product.id },
+      paginationOptions: {
+        pageNumber: 2,
+        pageSize: 1,
+      },
     });
-  });
-
-
-describe.each([PrimaryProvider.MEILISEARCH])(
-  'Product Recommendations - Similar - %s',
-  (provider) => {
-    let client: ReturnType<typeof createClient>;
 
-    beforeEach(() => {
-      client = createClient(provider);
-    });
+    if (!secondPageResult.success) {
+      assert.fail(JSON.stringify(secondPageResult.error));
+    }
+  });
 
-    it('should be able to return a list of products for recommendation - Similar ', async () => {
-      const result = await client.productRecommendations.getRecommendations({
-        algorithm: 'similar',
-        sourceProduct: {
-          key: testData.product.id,
-        },
-        numberOfRecommendations: 10,
+  describe('Submitting Reviews', () => {
+    it('cannot submit review if not authenticated', async () => {
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 4,
+        title: 'Great product!',
+        content: 'I really enjoyed using this product. Highly recommend it.',
+        authorName: 'John Doe',
       });
 
-      if (!result.success) {
-        assert.fail(JSON.stringify(result.error));
+      if (result.success) {
+        assert.fail('Expected it to return an error for unauthenticated user');
+      } else {
+        expect(result.error.type).toBe('InvalidInput');
       }
+    });
 
-      expect(result.value.length).toBeGreaterThan(0);
-      expect(result.value[0].recommendationReturnType).toBe('productSearchResultItem');
-      if (result.value[0].recommendationReturnType === 'productSearchResultItem') {
-        expect(result.value[0].product.identifier.key).toBeDefined();
-        expect(result.value[0].product.name).toBeDefined();
-        expect(result.value[0].product.slug).toBeDefined();
-        expect(result.value[0].product.variants).toBeDefined();
-        expect(result.value[0].product.variants.length).toBeGreaterThan(0);
-        expect(result.value[0].product.variants[0].variant.sku).toBeDefined();
-        expect(result.value[0].product.variants[0].image.sourceUrl).toBeDefined();
+    it('can submit a review for a product', async () => {
+      if (provider === PrimaryProvider.FAKE) {
+        return;
       }
-      expect(result.value[0].recommendationIdentifier.key).toBeDefined();
-    });
+      const newIdentity = await client.identity.register({
+        username: `testuser_${Date.now()}@example.com`,
+        password: 'password123',
+      });
 
-    it('should return an empty result for an unknown sku', async () => {
-      const result = await client.productRecommendations.getRecommendations({
-        algorithm: 'similar',
-        sourceProduct: {
-          key: 'unknown-product-id',
-        },
-        numberOfRecommendations: 10,
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 4,
+        title: 'Great product!',
+        content: 'I really enjoyed using this product. Highly recommend it.',
+        authorName: 'John Doe',
       });
 
       if (!result.success) {
         assert.fail(JSON.stringify(result.error));
       }
-
-      expect(result.value.length).toBe(0);
-    });
-  });
-
-
-
-describe.each([PrimaryProvider.ALGOLIA])(
-  'Product Recommendations - Related - %s',
-  (provider) => {
-    let client: ReturnType<typeof createClient>;
-
-    beforeEach(() => {
-      client = createClient(provider);
     });
 
-    it('should be able to return a list of products for recommendation - Related ', async () => {
-      const result = await client.productRecommendations.getRecommendations({
-        algorithm: 'related',
-        sourceProduct: {
-          key: testData.product.id,
-        },
-        numberOfRecommendations: 10,
+    it('can submit a rating without review', async () => {
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 5,
+        title: '',
+        content: '',
+        authorName: 'Jane Doe',
       });
-
-      if (!result.success) {
-        assert.fail(JSON.stringify(result.error));
-      }
-
-      expect(result.value.length).toBeGreaterThan(0);
-      expect(result.value[0].recommendationReturnType).toBe('productSearchResultItem');
-      if (result.value[0].recommendationReturnType === 'productSearchResultItem') {
-        expect(result.value[0].product.identifier.key).toBeDefined();
-        expect(result.value[0].product.name).toBeDefined();
-        expect(result.value[0].product.slug).toBeDefined();
-        expect(result.value[0].product.variants).toBeDefined();
-        expect(result.value[0].product.variants.length).toBeGreaterThan(0);
-        expect(result.value[0].product.variants[0].variant.sku).toBeDefined();
-        expect(result.value[0].product.variants[0].image.sourceUrl).toBeDefined();
-      }
-
     });
 
-    it('should return an empty result for an unknown sku', async () => {
-      const result = await client.productRecommendations.getRecommendations({
-        algorithm: 'related',
-        sourceProduct: {
-          key: 'unknown-product-id',
-        },
-        numberOfRecommendations: 10,
+    it('should return an error when submitting a review with invalid rating', async () => {
+      const result = await client.productReviews.submitReview({
+        product: { key: testData.product.id },
+        rating: 6, // Invalid rating, should be between 1 and 5
+        title: 'Invalid rating',
+        content: 'This review has an invalid rating.',
+        authorName: 'Invalid User',
       });
 
-      if (!result.success) {
-        assert.fail(JSON.stringify(result.error));
+      if (result.success) {
+        assert.fail('Expected it to return an error for invalid rating');
+      } else {
+        expect(result.error.type).toBe('InvalidInput');
       }
-
-      expect(result.value.length).toBe(0);
     });
   });
+});

package/src/utils.ts

@@ -8,6 +8,8 @@ import { withCommercetoolsCapabilities } from '@reactionary/provider-commercetoo
 import { withAlgoliaCapabilities } from '@reactionary/provider-algolia';
 import { withMedusaCapabilities } from '@reactionary/provider-medusa';
 import { withMeilisearchCapabilities } from '@reactionary/provider-meilisearch';
+import { withFakeCapabilities } from '@reactionary/provider-fake';
+import type { FakeConfiguration } from '@reactionary/provider-fake';
 
 export function getAlgoliaTestConfiguration() {
   return {
@@ -39,6 +41,20 @@ export function getMedusaTestConfiguration() {
 }
 
 
+export function getFakeConfiguration(): FakeConfiguration {
+  return {
+    jitter: {
+      mean: 0,
+      deviation: 0,
+    },
+    seeds: {
+      product: 1,
+      search: 1,
+      category: 1,
+    },
+  } satisfies FakeConfiguration;
+}
+
 export function getCommercetoolsTestConfiguration() {
   return {
     apiUrl: process.env['CTP_API_URL'] || '',
@@ -71,7 +87,8 @@ export enum PrimaryProvider {
   ALGOLIA = 'Algolia',
   COMMERCETOOLS = 'Commercetools',
   MEDUSA = 'Medusa',
-  MEILISEARCH = 'Meilisearch'
+  MEILISEARCH = 'Meilisearch',
+  FAKE = 'Fake',
 }
 
 export function createClient(provider: PrimaryProvider) {
@@ -99,7 +116,13 @@ export function createClient(provider: PrimaryProvider) {
       );
     }
 
-
+    if (provider === PrimaryProvider.FAKE) {
+      builder = builder.withCapability(
+        withFakeCapabilities( getFakeConfiguration() , {
+          productReviews: true
+        }
+      ))
+    }
 
     if (provider === PrimaryProvider.COMMERCETOOLS) {
       builder = builder.withCapability(