@unchainedshop/core-products 3.1.1 → 3.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/core-products",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "main": "lib/products-index.js",
   "types": "lib/products-index.d.ts",
   "type": "module",
@@ -9,8 +9,8 @@
     "build": "tsc -b",
     "prepublishOnly": "npm run clean && npm run build",
     "watch": "tsc -w",
-    "test": "NODE_OPTIONS=--experimental-vm-modules jest --detectOpenHandles --forceExit",
-    "test:watch": "NODE_OPTIONS=--experimental-vm-modules jest --watch --detectOpenHandles --forceExit"
+    "test": "tsx --test",
+    "test:watch": "tsx --test --watch"
   },
   "repository": {
     "type": "git",
@@ -37,8 +37,7 @@
   },
   "devDependencies": {
     "@types/node": "^22.13.4",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.2.5",
+    "tsx": "^4.19.2",
     "typescript": "^5.7.3"
   }
 }

package/src/module/buildFindSelector.test.ts

@@ -1,12 +1,14 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
 import { buildFindSelector } from './configureProductsModule';
 
 describe('Product', () => {
   describe('buildFindSelector', () => {
     it('Return correct filter object object when no parameter is passed', () => {
-      expect(buildFindSelector({} as any)).toEqual({ status: { $eq: 'ACTIVE' } });
+      assert.deepStrictEqual(buildFindSelector({} as any), { status: { $eq: 'ACTIVE' } });
     });
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector, queryString, slugs, tags ', () => {
-      expect(
+      assert.deepStrictEqual(
         buildFindSelector({
           includeDrafts: true,
           productIds: ['product-1-id', 'product-id-2'],
@@ -15,18 +17,19 @@ describe('Product', () => {
           slugs: ['slug-1', 'slug-2'],
           tags: ['tag-1', 'tag-2'],
         } as any),
-      ).toEqual({
-        type: 'SIMPLE_PRODUCT',
-        _id: { $in: ['product-1-id', 'product-id-2'] },
-        slugs: { $in: ['slug-1', 'slug-2'] },
-        tags: { $all: ['tag-1', 'tag-2'] },
-        $text: { $search: 'hello world' },
-        status: { $in: ['ACTIVE', null] },
-      });
+        {
+          type: 'SIMPLE_PRODUCT',
+          _id: { $in: ['product-1-id', 'product-id-2'] },
+          slugs: { $in: ['slug-1', 'slug-2'] },
+          tags: { $all: ['tag-1', 'tag-2'] },
+          $text: { $search: 'hello world' },
+          status: { $in: ['ACTIVE', null] },
+        },
+      );
     });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector, queryString, slugs ', () => {
-      expect(
+      assert.deepStrictEqual(
         buildFindSelector({
           includeDrafts: true,
           productIds: ['product-1-id', 'product-id-2'],
@@ -34,63 +37,67 @@ describe('Product', () => {
           queryString: 'hello world',
           slugs: ['slug-1', 'slug-2'],
         } as any),
-      ).toEqual({
-        type: 'SIMPLE_PRODUCT',
-        _id: { $in: ['product-1-id', 'product-id-2'] },
-        slugs: { $in: ['slug-1', 'slug-2'] },
-        $text: { $search: 'hello world' },
-        status: { $in: ['ACTIVE', null] },
-      });
+        {
+          type: 'SIMPLE_PRODUCT',
+          _id: { $in: ['product-1-id', 'product-id-2'] },
+          slugs: { $in: ['slug-1', 'slug-2'] },
+          $text: { $search: 'hello world' },
+          status: { $in: ['ACTIVE', null] },
+        },
+      );
     });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector, queryString ', () => {
-      expect(
+      assert.deepStrictEqual(
         buildFindSelector({
           includeDrafts: true,
           productIds: ['product-1-id', 'product-id-2'],
           productSelector: { type: 'SIMPLE_PRODUCT' },
           queryString: 'hello world',
         } as any),
-      ).toEqual({
-        type: 'SIMPLE_PRODUCT',
-        _id: { $in: ['product-1-id', 'product-id-2'] },
-        $text: { $search: 'hello world' },
-        status: { $in: ['ACTIVE', null] },
-      });
+        {
+          type: 'SIMPLE_PRODUCT',
+          _id: { $in: ['product-1-id', 'product-id-2'] },
+          $text: { $search: 'hello world' },
+          status: { $in: ['ACTIVE', null] },
+        },
+      );
     });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector ', () => {
-      expect(
+      assert.deepStrictEqual(
         buildFindSelector({
           includeDrafts: true,
           productIds: ['product-1-id', 'product-id-2'],
           productSelector: { type: 'SIMPLE_PRODUCT' },
         } as any),
-      ).toEqual({
-        type: 'SIMPLE_PRODUCT',
-        _id: { $in: ['product-1-id', 'product-id-2'] },
-        status: { $in: ['ACTIVE', null] },
-      });
+        {
+          type: 'SIMPLE_PRODUCT',
+          _id: { $in: ['product-1-id', 'product-id-2'] },
+          status: { $in: ['ACTIVE', null] },
+        },
+      );
     });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds ', () => {
-      expect(
+      assert.deepStrictEqual(
         buildFindSelector({ includeDrafts: true, productIds: ['product-1-id', 'product-id-2'] } as any),
-      ).toEqual({
-        _id: { $in: ['product-1-id', 'product-id-2'] },
-        status: { $in: ['ACTIVE', null] },
-      });
+        {
+          _id: { $in: ['product-1-id', 'product-id-2'] },
+          status: { $in: ['ACTIVE', null] },
+        },
+      );
     });
 
     it('Return filter tags if passed as a string ', () => {
-      expect(buildFindSelector({ tags: 'string-tag' } as any)).toEqual({
+      assert.deepStrictEqual(buildFindSelector({ tags: 'string-tag' } as any), {
         tags: 'string-tag',
         status: { $eq: 'ACTIVE' },
       });
     });
 
     it('includeDrafts true  should add null to status filter array as null ', () => {
-      expect(buildFindSelector({ includeDrafts: true } as any)).toEqual({
+      assert.deepStrictEqual(buildFindSelector({ includeDrafts: true } as any), {
         status: { $in: ['ACTIVE', null] },
       });
     });

package/src/module/utils/configureProductPrices.test.ts

@@ -1,17 +1,19 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
 import { getDecimals, normalizeRate } from '../configureProductPrices.js';
 
 describe('Rate conversion', () => {
   it('getDecimals', () => {
-    expect(getDecimals(18)).toBe(9);
-    expect(getDecimals(8)).toBe(8);
-    expect(getDecimals(1)).toBe(1);
-    expect(getDecimals(null)).toBe(2);
-    expect(getDecimals(undefined)).toBe(2);
-    expect(getDecimals(0)).toBe(0);
+    assert.strictEqual(getDecimals(18), 9);
+    assert.strictEqual(getDecimals(8), 8);
+    assert.strictEqual(getDecimals(1), 1);
+    assert.strictEqual(getDecimals(null), 2);
+    assert.strictEqual(getDecimals(undefined), 2);
+    assert.strictEqual(getDecimals(0), 0);
   });
 
   it('normalizeRate converting between FIAT with 2 decimals', () => {
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'USD',
@@ -23,9 +25,10 @@ describe('Rate conversion', () => {
         } as any,
         { quoteCurrency: 'USD', rate: 0.9 } as any,
       ),
-    ).toBe(1.1111111111111112);
+      1.1111111111111112,
+    );
 
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'CHF', // in Rappen
@@ -37,11 +40,12 @@ describe('Rate conversion', () => {
         } as any,
         { quoteCurrency: 'USD', rate: 0.9 } as any,
       ),
-    ).toBe(0.9);
+      0.9,
+    );
   });
 
   it('normalizeRate converting between FIAT with 0 and 2 decimals', () => {
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'CLP', // in Pesos
@@ -53,9 +57,10 @@ describe('Rate conversion', () => {
         } as any,
         { baseCurrency: 'CLP', quoteCurrency: 'CHF', rate: 0.0010451376 } as any,
       ),
-    ).toBe(0.10451376);
+      0.10451376,
+    );
 
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'CLP', // in Pesos
@@ -73,11 +78,12 @@ describe('Rate conversion', () => {
           timestamp: undefined,
         },
       ),
-    ).toBe(0.10451942626276765);
+      0.10451942626276765,
+    );
   });
 
   it('normalizeRate converting FIAT to/from Crypto with Crypto->Fiat Pair', () => {
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'USD', // in Pennies
@@ -89,9 +95,10 @@ describe('Rate conversion', () => {
         } as any,
         { baseCurrency: 'BTC', quoteCurrency: 'USD', rate: 19284.61 } as any,
       ),
-    ).toBe(518.5482102049251);
+      518.5482102049251,
+    );
 
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'ETH', // in GWEI
@@ -103,13 +110,14 @@ describe('Rate conversion', () => {
         } as any,
         { baseCurrency: 'ETH', quoteCurrency: 'CHF', rate: 1311.63 } as any,
       ),
-    ).toBe(0.000131163);
+      0.000131163,
+    );
 
     // 1 ETH = 0.000131163
   });
 
   it('normalizeRate converting FIAT to/from Crypto with Fiat->Crypto Pair', () => {
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'USD', // in Pennies
@@ -121,12 +129,13 @@ describe('Rate conversion', () => {
         } as any,
         { baseCurrency: 'USD', quoteCurrency: 'BTC', rate: 0.000052 } as any,
       ),
-    ).toBe(52);
+      52,
+    );
 
     // 1 USD = 100 Pennies
     // 100 Pennies = 5200 Satoshis
 
-    expect(
+    assert.strictEqual(
       normalizeRate(
         {
           isoCode: 'ETH', // in GWEI
@@ -138,7 +147,8 @@ describe('Rate conversion', () => {
         } as any,
         { baseCurrency: 'CLP', quoteCurrency: 'ETH', rate: 0.000000794 } as any,
       ),
-    ).toBe(0.0012594458438287153);
+      0.0012594458438287153,
+    );
 
     // 1 ETH = 1,000,000,000 GWEI (10^9)
     // 1,000,000,000 GWEI = 1’259’445 CLP

package/src/module/utils/getPriceLevels.test.ts

@@ -1,14 +1,16 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
 import { getPriceLevels } from './getPriceLevels.js';
 import product from '../../mock/product.js';
 
 describe('Price level', () => {
   it('Should return empty array when country code is not specified', () => {
-    expect(getPriceLevels({ product, currencyCode: 'CHF' } as any)).toHaveLength(0);
+    assert.strictEqual(getPriceLevels({ product, currencyCode: 'CHF' } as any).length, 0);
   });
 
   it('Should return empty array when country code is not specified', () => {
-    expect(getPriceLevels({ product, countryCode: 'ET' } as any)).toHaveLength(1);
-    expect(getPriceLevels({ product, countryCode: 'ET' } as any)).toEqual([
+    assert.strictEqual(getPriceLevels({ product, countryCode: 'ET' } as any).length, 1);
+    assert.deepStrictEqual(getPriceLevels({ product, countryCode: 'ET' } as any), [
       {
         amount: 20000,
         maxQuantity: 2,
@@ -18,8 +20,8 @@ describe('Price level', () => {
         countryCode: 'ET',
       },
     ]);
-    expect(getPriceLevels({ product, countryCode: 'CH' } as any)).toHaveLength(3);
-    expect(getPriceLevels({ product, countryCode: 'CH' } as any)).toEqual([
+    assert.strictEqual(getPriceLevels({ product, countryCode: 'CH' } as any).length, 3);
+    assert.deepStrictEqual(getPriceLevels({ product, countryCode: 'CH' } as any), [
       {
         amount: 1000,
         maxQuantity: null,
@@ -48,7 +50,7 @@ describe('Price level', () => {
   });
 
   it('Should return all prices for a given country sorted by max quantity ASC', () => {
-    expect(getPriceLevels({ product, countryCode: 'CH' } as any)).toEqual([
+    assert.deepStrictEqual(getPriceLevels({ product, countryCode: 'CH' } as any), [
       {
         amount: 1000,
         maxQuantity: null,
@@ -77,7 +79,13 @@ describe('Price level', () => {
   });
 
   it('Should return all prices currencyCode', () => {
-    expect(getPriceLevels({ product, countryCode: 'CH', currencyCode: 'CHF' } as any)).toHaveLength(2);
-    expect(getPriceLevels({ product, countryCode: 'CH', currencyCode: 'ETH' } as any)).toHaveLength(1);
+    assert.strictEqual(
+      getPriceLevels({ product, countryCode: 'CH', currencyCode: 'CHF' } as any).length,
+      2,
+    );
+    assert.strictEqual(
+      getPriceLevels({ product, countryCode: 'CH', currencyCode: 'ETH' } as any).length,
+      1,
+    );
   });
 });

package/src/module/utils/getPriceRange.test.ts

@@ -1,49 +1,53 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
 import { getPriceRange } from './getPriceRange.js';
 import product from '../../mock/product.js';
 import { getPriceLevels } from './getPriceLevels.js';
 
 describe('Price Range', () => {
   it('Should return the minimum and maximum price of a product when there are multiple prices', () => {
-    expect(
+    assert.deepStrictEqual(
       getPriceRange({
         productId: product._id,
         prices: getPriceLevels({ product, countryCode: 'CH', currencyCode: 'CHF' } as any),
       }),
-    ).toEqual({
-      minPrice: {
-        isTaxable: false,
-        isNetPrice: false,
-        amount: 750,
-        currencyCode: 'CHF',
+      {
+        minPrice: {
+          isTaxable: false,
+          isNetPrice: false,
+          amount: 750,
+          currencyCode: 'CHF',
+        },
+        maxPrice: {
+          isTaxable: false,
+          isNetPrice: false,
+          amount: 1000,
+          currencyCode: 'CHF',
+        },
       },
-      maxPrice: {
-        isTaxable: false,
-        isNetPrice: false,
-        amount: 1000,
-        currencyCode: 'CHF',
-      },
-    });
+    );
   });
 
   it('Should still return and object with min and max price field when no price list is provided', () => {
-    expect(
+    assert.deepStrictEqual(
       getPriceRange({
         productId: product._id,
         prices: getPriceLevels({ product, countryCode: 'DE', currencyCode: 'EUR' } as any),
       }),
-    ).toEqual({
-      minPrice: {
-        isTaxable: false,
-        isNetPrice: false,
-        amount: NaN,
-        currencyCode: undefined,
-      },
-      maxPrice: {
-        isTaxable: false,
-        isNetPrice: false,
-        amount: NaN,
-        currencyCode: undefined,
+      {
+        minPrice: {
+          isTaxable: false,
+          isNetPrice: false,
+          amount: NaN,
+          currencyCode: undefined,
+        },
+        maxPrice: {
+          isTaxable: false,
+          isNetPrice: false,
+          amount: NaN,
+          currencyCode: undefined,
+        },
       },
-    });
+    );
   });
 });

package/tests/product-index.test.ts

@@ -1,5 +1,7 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
 describe('Product', () => {
   it('Product', () => {
-    expect(true).toBeTruthy();
+    assert(true);
   });
 });

package/jest.config.js

@@ -1,18 +0,0 @@
-/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
-export default {
-  preset: 'ts-jest/presets/default-esm', // or other ESM presets
-  testEnvironment: 'node',
-  extensionsToTreatAsEsm: ['.ts'],
-  transform: {
-    '^.+\\.tsx?$': [
-      'ts-jest',
-      {
-        useESM: true,
-      },
-    ],
-  },
-  moduleNameMapper: {
-    '^(\\.{1,2}/.*)\\.js$': '$1',
-  },
-  rootDir: '.',
-};