@reactionary/source 0.0.52 → 0.2.16

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

@@ -1,75 +1,80 @@
 import 'dotenv/config';
-import type { RequestContext} from '@reactionary/core';
-import { NoOpCache, PriceSchema, createInitialRequestContext } from '@reactionary/core';
+import type { RequestContext } from '@reactionary/core';
+import {
+  NoOpCache,
+  PriceSchema,
+  createInitialRequestContext,
+} from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { FakePriceProvider } from '../providers/price.provider.js';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
 
 const testData = {
   skuWithoutTiers: 'SGB-01',
-  skuWithTiers: 'GMCT-01-with-tiers'
-}
+  skuWithTiers: 'GMCT-01-with-tiers',
+};
 
 describe('Fake Price Provider', () => {
   let provider: FakePriceProvider;
   let reqCtx: RequestContext;
 
-  beforeAll( () => {
-    provider = new FakePriceProvider(getFakerTestConfiguration(), PriceSchema, new NoOpCache());
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    provider = new FakePriceProvider(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx
+    );
   });
 
-  beforeEach( () => {
-    reqCtx = createInitialRequestContext()
-  })
-
   it('should be able to get prices for a product without tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithoutTiers }}, reqCtx);
+    const result = await provider.getListPrice({
+      variant: { sku: testData.skuWithoutTiers },
+    });
 
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.sku.key).toBe(testData.skuWithoutTiers);
-      expect(result.unitPrice.value).toBeGreaterThan(0);
-      expect(result.unitPrice.currency).toBe('USD');
-      expect(result.tieredPrices.length).toBe(0);
+    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('USD');
+    expect(result.value.tieredPrices.length).toBe(0);
   });
 
   it('should be able to get prices for a product with tiers', async () => {
-    const result = await provider.getBySKU({ sku: { key: testData.skuWithTiers }}, reqCtx);
+    const result = await provider.getListPrice({
+      variant: { sku: testData.skuWithTiers },
+    });
 
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.sku.key).toBe(testData.skuWithTiers);
-      expect(result.unitPrice.value).toBeGreaterThan(0);
-      expect(result.unitPrice.currency).toBe('USD');
-      expect(result.tieredPrices.length).toBeGreaterThan(0);
+    if (!result.success) {
+      assert.fail();
+    }
 
-      expect(result.tieredPrices[0].minimumQuantity).toBeGreaterThan(0);
-      expect(result.tieredPrices[0].price.value).toBeLessThanOrEqual(result.unitPrice.value);
-      expect(result.tieredPrices[0].price.currency).toBe('USD');
+    expect(result.value.identifier.variant.sku).toBe(testData.skuWithTiers);
+    expect(result.value.unitPrice.value).toBeGreaterThan(0);
+    expect(result.value.unitPrice.currency).toBe('USD');
+    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('USD');
   });
 
   it('should return a placeholder price for an unknown SKU', async () => {
-    const result = await provider.getBySKU({ sku: { key: 'unknown-sku' }}, reqCtx);
+    const result = await provider.getListPrice({
+      variant: { sku: 'unknown-sku' },
+    });
 
-    expect(result).toBeTruthy();
-    if (result) {
-      expect(result.identifier.sku.key).toBe('unknown-sku');
-      expect(result.unitPrice.value).toBe(-1);
-      expect(result.unitPrice.currency).toBe('USD');
-      expect(result.tieredPrices.length).toBe(0);
-      expect(result.meta?.placeholder).toBe(true);
+    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.getBySKU({ sku: { key: sku }}, reqCtx)));
 
-    expect(results).toHaveLength(skus.length);
-    expect(results[0].identifier.sku.key).toBe(testData.skuWithTiers);
-    expect(results[1].identifier.sku.key).toBe(testData.skuWithoutTiers);
-    expect(results[2].identifier.sku.key).toBe('unknown-sku');
+    expect(result.value.identifier.variant.sku).toBe('unknown-sku');
+    expect(result.value.unitPrice.value).toBe(-1);
+    expect(result.value.unitPrice.currency).toBe('USD');
+    expect(result.value.tieredPrices.length).toBe(0);
   });
 });

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

@@ -1,27 +1,35 @@
 import 'dotenv/config';
 
 import type { RequestContext } from '@reactionary/core';
-import { createInitialRequestContext, MemoryCache, ProductSchema } from '@reactionary/core';
+import { createInitialRequestContext, MemoryCache } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { FakeProductProvider } from '../providers/index.js';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
 
 describe('Fake Product Provider', () => {
   let provider: FakeProductProvider;
   let reqCtx: RequestContext;
 
-  beforeAll(async () => {
-    provider = new FakeProductProvider(getFakerTestConfiguration(), ProductSchema, new MemoryCache());
-  });
-
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
+    provider = new FakeProductProvider(getFakerTestConfiguration(),  new MemoryCache(), reqCtx);
   })
 
   it('should cache repeat product lookups by id', async () => {
-    const first = await provider.getById({ id: '1234' }, reqCtx);
+    const first = await provider.getById({ identifier: { key : '1234' }});
+
+    if (!first.success) {
+      assert.fail();
+    }
+
     expect(first.meta.cache.hit).toBe(false);
 
-    const second = await provider.getById({ id: '1234' }, reqCtx);
+    const second = await provider.getById({ identifier: { key : '1234' }});
+    
+    if (!second.success) {
+      assert.fail();
+    }
+
     expect(second.meta.cache.hit).toBe(true);
   });
 });

package/providers/fake/src/test/profile.provider.spec.ts

@@ -0,0 +1,167 @@
+import 'dotenv/config';
+import type { RequestContext } from '@reactionary/core';
+import { NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import { getFakerTestConfiguration } from './test-utils.js';
+import { describe, expect, it, beforeEach, assert } from 'vitest';
+import { FakeProfileProvider } from '../providers/profile.provider.js';
+
+describe('Fake Profile Provider', () => {
+  let provider: FakeProfileProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    provider = new FakeProfileProvider(
+      getFakerTestConfiguration(),
+      new NoOpCache(),
+      reqCtx
+    );
+  });
+
+  describe('should have operations return structurally valid data', () => {
+    it('for getById', async () => {
+      const result = await provider.getById({
+        identifier: {
+          userId: '1234',
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.userId).toBe('1234');
+    });
+
+    it('for addShippingAddress', async () => {
+      const result = await provider.addShippingAddress({
+        address: {
+          city: 'City',
+          countryCode: 'DK',
+          firstName: 'FirstName',
+          lastName: 'LastName',
+          identifier: {
+            nickName: '1234Fake',
+          },
+          postalCode: '2300',
+          region: 'Region',
+          streetAddress: 'StreetAddress',
+          streetNumber: '42',
+        },
+        identifier: {
+          userId: '1234',
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.userId).toBe('1234');
+    });
+
+    it('for makeShippingAddressDefault', async () => {
+      const result = await provider.makeShippingAddressDefault({
+        addressIdentifier: {
+          nickName: '1234Fake',
+        },
+        identifier: {
+          userId: '1234',
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.userId).toBe('1234');
+    });
+
+    it('for removeShippingAddress', async () => {
+      const result = await provider.removeShippingAddress({
+        addressIdentifier: {
+          nickName: '1234Fake',
+        },
+        identifier: {
+          userId: '1234',
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.userId).toBe('1234');
+    });
+
+    it('for setBillingAddress', async () => {
+      const result = await provider.setBillingAddress({
+        address: {
+          city: 'City',
+          countryCode: 'DK',
+          firstName: 'FirstName',
+          lastName: 'LastName',
+          identifier: {
+            nickName: '1234Fake',
+          },
+          postalCode: '2300',
+          region: 'Region',
+          streetAddress: 'StreetAddress',
+          streetNumber: '42',
+        },
+        identifier: {
+          userId: '1234',
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.userId).toBe('1234');
+    });
+
+    it('for update', async () => {
+      const result = await provider.update({
+        email: 'foo@example.com',
+        identifier: {
+          userId: '1234',
+        },
+        phone: '40102030',
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.userId).toBe('1234');
+    });
+
+    it('for updateShippingAddress', async () => {
+      const result = await provider.updateShippingAddress({
+        address: {
+          city: 'City',
+          countryCode: 'DK',
+          firstName: 'FirstName',
+          lastName: 'LastName',
+          identifier: {
+            nickName: '1234Fake',
+          },
+          postalCode: '2300',
+          region: 'Region',
+          streetAddress: 'StreetAddress',
+          streetNumber: '42',
+        },
+        identifier: {
+          userId: '1234',
+        },
+      });
+
+      if (!result.success) {
+        assert.fail();
+      }
+
+      expect(result.value.identifier.userId).toBe('1234');
+    });
+  });
+});

package/providers/fake/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "nodenext",
+    "module": "NodeNext",
     "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,

package/providers/fake/tsconfig.lib.json

@@ -6,6 +6,6 @@
     "types": ["node"]
   },
   "include": ["src/**/*.ts"],
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts", "src/**/test-utils.ts"]
+  "exclude": ["src/**/*.spec.ts", "src/**/*.test.ts", "src/**/test-utils.ts"]
 
 }

package/providers/fake/tsconfig.spec.json

@@ -1,14 +1,4 @@
 {
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "jest.config.cjs",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/test-utils.ts",
-    "src/**/*.d.ts"
-  ]
+  "extends": "./tsconfig.lib.json",
+  "exclude": []
 }

package/providers/fake/vitest.config.ts

@@ -0,0 +1,14 @@
+/// <reference types="vitest" />
+import { defineConfig, defineProject } from 'vitest/config';
+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/**/*.spec.ts', 'src/**/*.test.ts'],
+  },
+});

package/providers/medusa/README.md

@@ -0,0 +1,30 @@
+# Medusa provider for Reactionary
+
+## Supports
+
+| Feature | Support | Notes |
+| -----------   | ----------- | --------- |
+| product       | Full  (*)      | Mandatory customization to support lookup by sku          |
+| productSearch | Partial     | No facets in medusa search |
+| identity | Planned     | |
+| cart | Full     |  |
+| checkout | In progress     |  |
+| order | Planned     |  |
+| inventory | Planned     |  |
+| price | Planned   |  |
+| category | Planned     |  |
+| store | Planned    |  |
+
+
+## Notes
+Medusa is expected to be version 2.11+
+
+
+## Workarounds in place
+Medusa needs an Admin key, to be able to do the following things
+- Resolve product by SKU.
+
+Since medusa can't search and filter on `sku`, you have to import the value for `sku` into `barcode`, `ean` or `upc`. Either will do.
+The assumption is, that your SKU is either an semi-internal erp dictated partnumber, OR the products `gtin`.
+
+

package/providers/medusa/TESTING.md

@@ -0,0 +1,98 @@
+# Medusa Provider Testing
+
+This document describes the testing setup for the Medusa provider.
+
+## Test Setup
+
+The Medusa provider uses [Vitest](https://vitest.dev/) for testing, which is already configured in the workspace.
+
+### Configuration
+
+- **Test runner**: Vitest
+- **Configuration**: `vitest.config.ts`
+- **Test files**: `src/**/*.spec.ts` and `src/**/*.test.ts`
+- **Coverage**: HTML and text reports
+
+### Running Tests
+
+```bash
+# Run all tests
+npx nx test medusa
+
+# Run tests in watch mode
+npx nx test:watch medusa
+
+# Run tests with UI
+npx nx test:ui medusa
+
+# Run tests with coverage
+npx nx test medusa --coverage
+```
+
+### Test Structure
+
+Tests are organized by component:
+
+- `src/core/client.spec.ts` - Tests for MedusaClient
+- `src/providers/cart.provider.spec.ts` - Tests for MedusaCartProvider
+
+### Mocking
+
+The tests use Vitest's built-in mocking capabilities:
+
+- **Medusa SDK**: Mocked using `vi.mock('@medusajs/js-sdk')`
+- **Debug**: Mocked using `vi.mock('debug')`
+- **External dependencies**: Mocked as needed
+
+### Coverage
+
+Coverage reports are generated in the `../../coverage/providers/medusa` directory and include:
+
+- Line coverage
+- Branch coverage
+- Function coverage
+- Statement coverage
+
+HTML reports can be viewed by opening `coverage/index.html` in a browser.
+
+## Writing Tests
+
+### Example Test Structure
+
+```typescript
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { MyClass } from './my-class.js';
+
+// Mock external dependencies
+vi.mock('external-library', () => ({
+  default: vi.fn(),
+}));
+
+describe('MyClass', () => {
+  let instance: MyClass;
+
+  beforeEach(() => {
+    instance = new MyClass();
+  });
+
+  describe('method', () => {
+    it('should do something', () => {
+      const result = instance.method();
+      expect(result).toBe(expected);
+    });
+  });
+});
+```
+
+### Best Practices
+
+1. **Use descriptive test names** that explain what the test does
+2. **Group related tests** using `describe` blocks
+3. **Mock external dependencies** to keep tests isolated
+4. **Test both success and error cases**
+5. **Use beforeEach** for common setup
+6. **Assert on behavior**, not implementation details
+
+## Continuous Integration
+
+Tests are automatically run as part of the CI/CD pipeline and must pass before code can be merged.

package/providers/medusa/eslint.config.mjs

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

package/providers/medusa/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@reactionary/provider-medusa",
+  "version": "0.0.1",
+  "type": "module",
+  "main": "index.js",
+  "types": "src/index.d.ts",
+  "dependencies": {
+    "zod": "4.1.9",
+    "@reactionary/core": "0.0.1",
+    "@medusajs/js-sdk": "^2.0.0",
+    "debug": "^4.3.4",
+    "@medusajs/types": "^2.11.0",
+    "dotenv": "^17.2.2"
+  },
+  "devDependencies": {
+    "vitest": "*",
+    "@vitest/ui": "*",
+    "@vitest/coverage-v8": "*",
+    "vite-tsconfig-paths": "*"
+  },
+  "sideEffects": false
+}

package/providers/medusa/project.json

@@ -0,0 +1,34 @@
+{
+  "name": "provider-medusa",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "providers/medusa/src",
+  "projectType": "library",
+  "release": {
+    "version": {
+      "currentVersionResolver": "git-tag",
+      "fallbackCurrentVersionResolver": "disk",
+      "preserveLocalDependencyProtocols": false,
+      "manifestRootsToUpdate": ["dist/{projectRoot}"]
+    }
+  },
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/esbuild:esbuild",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/providers/medusa",
+        "main": "providers/medusa/src/index.ts",
+        "tsConfig": "providers/medusa/tsconfig.lib.json",
+        "assets": ["providers/medusa/*.md"],
+        "format": ["esm"],
+        "bundle": false
+      }
+    },
+    "nx-release-publish": {
+      "options": {
+        "packageRoot": "dist/{projectRoot}"
+      }
+    }
+  }
+}