@reactionary/source 0.0.52 → 0.2.16

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

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeEach, vi, assert } from 'vitest';
+import { MedusaPriceProvider } from '../providers/price.provider.js';
+import type { MedusaConfiguration } from '../schema/configuration.schema.js';
+import {
+  PriceSchema,
+  NoOpCache,
+  createInitialRequestContext,
+  type RequestContext,
+} from '@reactionary/core';
+import { getMedusaTestConfiguration } from './test-utils.js';
+import { MedusaAPI } from '../core/client.js';
+
+const testData = {
+  skuWithoutTiers: '8712581327934',
+  skuWithTiers: '8710895937641',
+};
+
+// FIXME: Currently broken in terms of actually looking up anything...
+describe('Medusa Price Provider', () => {
+  let provider: MedusaPriceProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    const config = getMedusaTestConfiguration();
+    const client = new MedusaAPI(config, reqCtx);
+
+    provider = new MedusaPriceProvider(config, new NoOpCache(), reqCtx, client);
+  });
+
+  it('should be able to get prices for a product without tiers', async () => {
+    const result = await provider.getCustomerPrice({
+      variant: { sku: testData.skuWithoutTiers },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.variant.sku).toBe(testData.skuWithoutTiers);
+    expect(result.value.unitPrice.value).toBeGreaterThan(0);
+    expect(result.value.unitPrice.currency).toBe(
+      reqCtx.languageContext.currencyCode
+    );
+    expect(result.value.tieredPrices.length).toBe(0);
+  });
+
+  it.skip('should be able to get prices for a product with tiers', async () => {
+    const result = await provider.getCustomerPrice({
+      variant: { sku: testData.skuWithTiers },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.variant.sku).toBe(testData.skuWithTiers);
+    expect(result.value.unitPrice.value).toBeGreaterThan(0);
+    expect(result.value.unitPrice.currency).toBe(reqCtx.languageContext.currencyCode);
+    expect(result.value.tieredPrices.length).toBeGreaterThan(0);
+
+    expect(result.value.tieredPrices[0].minimumQuantity).toBeGreaterThan(0);
+    expect(result.value.tieredPrices[0].price.value).toBeLessThanOrEqual(
+      result.value.unitPrice.value
+    );
+    expect(result.value.tieredPrices[0].price.currency).toBe(
+      reqCtx.languageContext.currencyCode
+    );
+  });
+
+  it('should return NotFound for an unknown SKU', async () => {
+    const result = await provider.getCustomerPrice({
+      variant: { sku: 'unknown-sku' },
+    });
+
+    if (result.success) {
+      assert.fail();
+    }
+  });
+
+  it('can look up multiple prices at once', async () => {
+    const skus = [
+      testData.skuWithTiers,
+      testData.skuWithoutTiers,
+      'unknown-sku',
+    ];
+    const results = await Promise.all(
+      skus.map((sku) => provider.getCustomerPrice({ variant: { sku: sku } }))
+    );
+
+    const success = results.filter(x => x.success);
+
+    if (results.length !== success.length) {
+      assert.fail();
+    }
+
+    expect(success).toHaveLength(skus.length);
+    expect(success[0].value.identifier.variant.sku).toBe(testData.skuWithTiers);
+    expect(success[0].value.unitPrice.value).toBeGreaterThan(0);
+    expect(success[1].value.identifier.variant.sku).toBe(testData.skuWithoutTiers);
+    expect(success[1].value.unitPrice.value).toBeGreaterThan(0);
+    expect(success[2].value.identifier.variant.sku).toBe('unknown-sku');
+  });
+});

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

@@ -0,0 +1,146 @@
+import 'dotenv/config';
+import type { RequestContext } from '@reactionary/core';
+import {
+  NoOpCache,
+  ProductSchema,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { MedusaProductProvider } from '../providers/product.provider.js';
+import { getMedusaTestConfiguration } from './test-utils.js';
+import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
+import { MedusaAPI } from '../index.js';
+
+const testData = {
+  product: {
+    name: 'LV-CA31 SCART Cable',
+    slug: 'lv-ca31-scart-cable-101080',
+    image: 'https://images.icecat.biz/img/norm/high/101080-3513.jpg',
+    sku: '4960999194479',
+  },
+  productWithMultiVariants: {
+    slug: 'hp-gk859aa-mouse-office-bluetooth-laser-1600-dpi-1377612',
+  },
+};
+
+describe('Medusa Product Provider', () => {
+  let provider: MedusaProductProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
+    provider = new MedusaProductProvider(
+      getMedusaTestConfiguration(),
+      new NoOpCache(),
+      reqCtx,
+      client
+    );
+  });
+
+  it('should be able to get a product by id', async () => {
+    const slugResult = await provider.getBySlug({
+      slug: testData.product.slug,
+    });
+
+    if (!slugResult.success) {
+      assert.fail();
+    }
+
+    const result = await provider.getById({
+      identifier: slugResult.value.identifier,
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBe(slugResult.value.identifier.key);
+    expect(result.value.name).toBe(testData.product.name);
+
+    expect(result.value.mainVariant).toBeDefined();
+    expect(result.value.mainVariant.identifier.sku).toBe(testData.product.sku);
+    expect(result.value.mainVariant.images[0].sourceUrl).toBe(
+      testData.product.image
+    );
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
+  });
+
+  it('should be able to get a product with multiple variants by slug', async () => {
+    const result = await provider.getBySlug({
+      slug: testData.productWithMultiVariants.slug,
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBeTruthy();
+    expect(result.value.slug).toBe(testData.productWithMultiVariants.slug);
+    expect(result.value.mainVariant).toBeDefined();
+    expect(result.value.variants.length).toBeGreaterThan(0);
+    expect(result.value.variants[0].identifier.sku).toBeTruthy();
+    expect(result.value.variants[0].identifier.sku).not.toBe(
+      result.value.mainVariant.identifier.sku
+    );
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
+  });
+
+  it('should be able to get a product by sku', async () => {
+    const slugResult = await provider.getBySlug({
+      slug: testData.product.slug,
+    });
+
+    if (!slugResult.success) {
+      assert.fail();
+    }
+
+    const result = await provider.getBySKU({
+      variant: { sku: testData.product.sku },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.identifier.key).toBe(slugResult.value.identifier.key);
+    expect(result.value.name).toBe(testData.product.name);
+    expect(result.value.mainVariant).toBeDefined();
+    expect(result.value.mainVariant.identifier.sku).toBe(testData.product.sku);
+    expect(result.value.mainVariant.images[0].sourceUrl).toBe(testData.product.image);
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
+  });
+
+  it('should return null for unknown slug', async () => {
+    const result = await provider.getBySlug({ slug: 'unknown-slug' });
+
+    expect(result).toBeNull();
+  });
+
+  it('should contain both product level and variant level attributes', async () => {
+    const result = await provider.getBySlug({ slug: testData.product.slug });
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.sharedAttributes.length).toBeGreaterThan(1);
+    expect(result.value.sharedAttributes[1].values.length).toBeGreaterThan(0);
+    expect(result.value.sharedAttributes[1].values[0].value).toBeTruthy();
+  });
+
+  it('should return a placeholder product for unknown id', async () => {
+    const result = await provider.getById({
+      identifier: { key: 'unknown-id' },
+    });
+
+    if (!result.success) {
+      assert.fail();
+    }
+  });
+});

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

@@ -0,0 +1,203 @@
+import 'dotenv/config';
+import { createInitialRequestContext, NoOpCache, ProductSearchQueryByTermSchema, ProductSearchResultItemSchema, type ProductSearchQueryCreateNavigationFilter } from '@reactionary/core';
+import { assert, describe, expect, it } from 'vitest';
+import { MedusaSearchProvider } from '../providers/product-search.provider.js';
+import { getMedusaTestConfiguration } from './test-utils.js';
+import { MedusaAPI } from '../index.js';
+import { MedusaCategoryProvider } from '../providers/category.provider.js';
+
+const testData = {
+  searchTerm: 'printer',
+}
+describe('Medusa Search Provider', () => {
+  const reqCtx = createInitialRequestContext();
+  const client = new MedusaAPI(getMedusaTestConfiguration(), reqCtx);
+  const provider = new MedusaSearchProvider(
+    getMedusaTestConfiguration(),
+    new NoOpCache(),
+    reqCtx,
+    client
+  );
+
+  const categoryProvider = new MedusaCategoryProvider(
+    getMedusaTestConfiguration(),
+    new NoOpCache(),
+    reqCtx,
+    client
+  );
+
+  it('should be able to get a result by term', async () => {
+    const result = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
+      term: testData.searchTerm,
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 20,
+      },
+      facets: [],
+      filters: [],
+    }}));
+
+    if (!result.success) {
+      assert.fail();
+    }
+
+    expect(result.value.items.length).toBeGreaterThan(0);
+    expect(result.value.facets.length).toBe(0);
+  });
+
+  it('should be able to paginate', async () => {
+    const firstPage = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
+      term: testData.searchTerm,
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 2,
+      },
+      facets: [],
+      filters: []
+    }}));
+
+    const secondPage = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
+      term: testData.searchTerm,
+      paginationOptions: {
+        pageNumber: 2,
+        pageSize: 2
+      },
+      facets: [],
+      filters: []
+    }}));
+
+    if (!firstPage.success || !secondPage.success) {
+      assert.fail();
+    }
+
+    expect(firstPage.value.pageNumber).toBe(1);
+    expect(secondPage.value.pageNumber).toBe(2);
+    expect(firstPage.value.items[0].identifier.key).not.toEqual(
+      secondPage.value.items[0].identifier.key
+    );
+  });
+
+  it ('should be able to apply a top level category filter', async () => {
+      // First, get a category to filter on
+      const categories = await categoryProvider.findTopCategories({
+        paginationOptions: {
+          pageNumber: 1,
+          pageSize: 2,
+        },
+      });
+
+      if (!categories.success) {
+        assert.fail();
+      }
+
+      // medusa does not support subtree searches, so we have to drill down to a leaf category
+      let candidate = categories.value.items[0];
+      while(candidate) {
+        const children = await categoryProvider.findChildCategories({
+          parentId: candidate.identifier,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 10,
+          },
+        });
+
+        if (!children.success) {
+          assert.fail();
+        }
+
+        if(children.value.items.length > 0) {
+          candidate = children.value.items[0];
+        } else {
+          break;
+        }
+      }
+
+      const unfilteredSearch = await provider.queryByTerm({
+        search: {
+          term: "",
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 1,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!unfilteredSearch.success) {
+        assert.fail();
+      }
+
+      expect(unfilteredSearch.value.totalCount).toBeGreaterThan(0);
+
+      const breadCrumb = await categoryProvider.getBreadcrumbPathToCategory({
+        id: candidate.identifier,
+      });
+
+      if (!breadCrumb.success) {
+        assert.fail();
+      }
+
+      expect(breadCrumb.value.length).toBeGreaterThan(0);
+
+      const categoryFilter = await provider.createCategoryNavigationFilter({
+        categoryPath: breadCrumb.value,
+      } satisfies ProductSearchQueryCreateNavigationFilter);
+
+      if (!categoryFilter.success) {
+        assert.fail();
+      }
+
+      const filteredSearch = await provider.queryByTerm({
+        search: {
+          term: "",
+          categoryFilter: categoryFilter.value,
+          paginationOptions: {
+            pageNumber: 1,
+            pageSize: 1,
+          },
+          facets: [],
+          filters: [],
+        },
+      });
+
+      if (!filteredSearch.success) {
+        assert.fail();
+      }
+
+      expect(filteredSearch.value.totalCount).toBeLessThan(unfilteredSearch.value.totalCount);
+      expect(filteredSearch.value.totalCount).toBeGreaterThan(0);
+  });
+
+  it('should be able to change page size', async () => {
+    const smallPage = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
+      term: testData.searchTerm,
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 2,
+      },
+      facets: [],
+      filters: [],
+    }}));
+
+    const largePage = await provider.queryByTerm(ProductSearchQueryByTermSchema.parse({ search: {
+      term: testData.searchTerm,
+      paginationOptions: {
+        pageNumber: 1,
+        pageSize: 30,
+      },
+      facets: [],
+      filters: [],
+    }}));
+
+    if (!smallPage.success || !largePage.success) {
+      assert.fail();
+    }
+
+    expect(smallPage.value.items.length).toBe(2);
+    expect(smallPage.value.pageSize).toBe(2);
+    expect(largePage.value.items.length).toBe(30);
+    expect(largePage.value.pageSize).toBe(30);
+  });
+
+});

package/providers/medusa/src/test/test-utils.ts

@@ -0,0 +1,13 @@
+import 'dotenv/config';
+
+import { MedusaConfigurationSchema, type MedusaConfiguration } from '../schema/configuration.schema.js';
+
+export function getMedusaTestConfiguration(): MedusaConfiguration {
+  return MedusaConfigurationSchema.parse({
+        publishable_key: process.env['MEDUSA_PUBLISHABLE_KEY'] || '',
+        adminApiKey: process.env['MEDUSA_ADMIN_KEY'] || '',
+        apiUrl: process.env['MEDUSA_API_URL'] || '',
+        defaultCurrency: process.env['MEDUSA_DEFAULT_CURRENCY'] || '',
+    });
+}
+

package/providers/medusa/src/utils/medusa-helpers.ts

@@ -0,0 +1,89 @@
+import type { StoreCart, StoreOrder } from '@medusajs/types';
+import type { CostBreakDown, Currency } from '@reactionary/core';
+import createDebug from 'debug';
+
+const debug = createDebug('reactionary:medusa:helpers');
+
+/**
+ * Parses cost breakdown from Medusa StoreCart
+ */
+export function parseMedusaCostBreakdown(remote: StoreCart | StoreOrder): CostBreakDown {
+  const grandTotal = remote.total || 0;
+  const shippingTotal = remote.shipping_total || 0;
+  const taxTotal = remote.tax_total || 0;
+  const discountTotal = remote.discount_total || 0;
+  const subtotal = remote.subtotal || 0;
+  const currency = (remote.currency_code || 'EUR').toUpperCase() as Currency;
+
+  return {
+    totalTax: {
+      value: taxTotal,
+      currency,
+    },
+    totalDiscount: {
+      value: discountTotal,
+      currency,
+    },
+    totalSurcharge: {
+      value: 0,
+      currency,
+    },
+    totalShipping: {
+      value: shippingTotal,
+      currency,
+    },
+    totalProductPrice: {
+      value: subtotal,
+      currency,
+    },
+    grandTotal: {
+      value: grandTotal,
+      currency,
+    },
+  };
+}
+
+/**
+ * Parses item price structure from Medusa line item
+ */
+export function parseMedusaItemPrice(
+  remoteItem: { unit_price?: number; quantity: number; discount_total?: number },
+  currency: Currency
+) {
+  const unitPrice = remoteItem.unit_price || 0;
+  const totalPrice = unitPrice * remoteItem.quantity || 0;
+  const discountTotal = remoteItem.discount_total || 0;
+
+  return {
+    unitPrice: {
+      value: unitPrice,
+      currency,
+    },
+    unitDiscount: {
+      value: discountTotal / remoteItem.quantity,
+      currency,
+    },
+    totalPrice: {
+      value: totalPrice,
+      currency,
+    },
+    totalDiscount: {
+      value: discountTotal,
+      currency,
+    },
+  };
+}
+
+/**
+ * Handles provider errors with consistent formatting
+ */
+export function handleProviderError(action: string, error: unknown): never {
+  if (debug.enabled) {
+    debug(`Failed to ${action}:`, error);
+  }
+  throw new Error(
+    `Failed to ${action}: ${
+      error instanceof Error ? error.message : 'Unknown error'
+    }`
+  );
+}

package/providers/medusa/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+      "module": "NodeNext",
+      "moduleResolution": "nodenext",
+      "forceConsistentCasingInFileNames": true,
+      "strict": true,
+      "importHelpers": true,
+      "noImplicitOverride": true,
+      "noImplicitReturns": true,
+      "noFallthroughCasesInSwitch": true,
+      "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/providers/medusa/tsconfig.lib.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/providers/medusa/tsconfig.spec.json

@@ -0,0 +1,4 @@
+{
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
+}

package/providers/medusa/vitest.config.ts

@@ -0,0 +1,15 @@
+/// <reference types="vitest" />
+import { defineConfig, defineProject } from 'vitest/config';
+import tsconfigPaths from 'vite-tsconfig-paths';
+import { resolve } from 'path';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+
+export default defineProject({
+  plugins: [nxViteTsPaths()],
+  test: {
+    root: resolve(__dirname),
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.{test,spec}.{js,ds,ba,vv,ft,ts}', 'src/**/*.test.{ts,js}'],
+  },
+});

package/providers/meilisearch/README.md

@@ -0,0 +1,48 @@
+# Meilisearch provider for Reactionary
+
+## Supports
+
+
+| Feature | Support | Notes |
+| -----------   | ----------- | --------- |
+| product       | Full      |          |
+| productSearch | Full     |  |
+| identity | N/A     | |
+| cart |  N/A     |  |
+| checkout | N/A     |  |
+| order | N/A    | Possibly later |
+| inventory | N/A     |  |
+| price | N/A  |  |
+| category | N/A     | Possibly later |
+| store | N/A    | Possibly later |
+
+
+## Notes
+The expected Meilisearch schema must contain at least these fields
+
+```json
+{
+  id: string;
+  slug:string;
+  name: string;
+  variants: [
+    { 
+      sku: string; 
+      image: string;
+    }
+  ]
+}
+```
+
+You can have more, for use with facets, and additional searchable fields, but these must be in the index, and constitutes what we are expecting to get back.
+
+The `id` corresponds to your productIdentifier, and `sku` should match your SKU
+
+
+## Building
+
+Run `nx build provider-meilisearch` to build the library.
+
+## Running unit tests
+
+Run `nx test provider-meilisearch` to execute the unit tests via [Jest](https://jestjs.io).

package/providers/meilisearch/eslint.config.mjs

@@ -0,0 +1,22 @@
+import baseConfig from '../../eslint.config.mjs';
+
+export default [
+  ...baseConfig,
+  {
+    files: ['**/*.json'],
+    rules: {
+      '@nx/dependency-checks': [
+        'error',
+        {
+          ignoredFiles: [
+            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+          ],
+        },
+      ],
+    },
+    languageOptions: {
+      parser: await import('jsonc-eslint-parser'),
+    },
+  },
+];

package/providers/meilisearch/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@reactionary/provider-meilisearch",
+  "version": "0.0.1",
+  "main": "index.js",
+  "types": "src/index.d.ts",
+  "dependencies": {
+    "@reactionary/core": "0.0.1",
+    "meilisearch": "0.55.0",
+    "zod": "4.1.9"
+  },
+  "type": "module",
+  "sideEffects": false
+}