@unchainedshop/core-products 2.0.0-rc.4 → 2.0.0

package/jest.config.js

@@ -11,4 +11,8 @@ export default {
       },
     ],
   },
+  moduleNameMapper: {
+    '(.+)\\.js': '$1',
+  },
+  rootDir: '.',
 };

package/lib/mock/product.d.ts

@@ -0,0 +1,25 @@
+declare namespace _default {
+    const _id: string;
+    const type: string;
+    const status: string;
+    const sequence: number;
+    const authorId: string;
+    const tags: any[];
+    const created: Date;
+    const createdBy: string;
+    const slugs: string[];
+    const updated: Date;
+    const updatedBy: string;
+    namespace commerce {
+        const pricing: {
+            amount: number;
+            maxQuantity: number;
+            isTaxable: boolean;
+            isNetPrice: boolean;
+            currencyCode: string;
+            countryCode: string;
+        }[];
+    }
+    const published: Date;
+}
+export default _default;

package/lib/mock/product.js

@@ -0,0 +1,51 @@
+export default {
+    _id: 'aaf98dd6b1d4d6c0de605b9d',
+    type: 'SIMPLE_PRODUCT',
+    status: 'ACTIVE',
+    sequence: 10,
+    authorId: 'PKve0k9fLCUzn2EUi',
+    tags: [],
+    created: new Date('2022-10-28T10:41:13.346Z'),
+    createdBy: 'PKve0k9fLCUzn2EUi',
+    slugs: ['test'],
+    updated: new Date('2022-12-04T13:50:24.245Z'),
+    updatedBy: 'PKve0k9fLCUzn2EUi',
+    commerce: {
+        pricing: [
+            {
+                amount: 1000,
+                maxQuantity: null,
+                isTaxable: false,
+                isNetPrice: false,
+                currencyCode: 'CHF',
+                countryCode: 'CH',
+            },
+            {
+                amount: 20000,
+                maxQuantity: 2,
+                isTaxable: true,
+                isNetPrice: true,
+                currencyCode: 'ETB',
+                countryCode: 'ET',
+            },
+            {
+                amount: 1,
+                maxQuantity: 1,
+                isTaxable: false,
+                isNetPrice: false,
+                currencyCode: 'ETH',
+                countryCode: 'CH',
+            },
+            {
+                amount: 750,
+                maxQuantity: 2,
+                isTaxable: false,
+                isNetPrice: false,
+                currencyCode: 'CHF',
+                countryCode: 'CH',
+            },
+        ],
+    },
+    published: new Date('2022-12-04T13:31:26.406Z'),
+};
+//# sourceMappingURL=product.js.map

package/lib/mock/product.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"product.js","sourceRoot":"","sources":["../../src/mock/product.js"],"names":[],"mappings":"AAAA,eAAe;IACb,GAAG,EAAE,0BAA0B;IAC/B,IAAI,EAAE,gBAAgB;IACtB,MAAM,EAAE,QAAQ;IAChB,QAAQ,EAAE,EAAE;IACZ,QAAQ,EAAE,mBAAmB;IAC7B,IAAI,EAAE,EAAE;IACR,OAAO,EAAE,IAAI,IAAI,CAAC,0BAA0B,CAAC;IAC7C,SAAS,EAAE,mBAAmB;IAC9B,KAAK,EAAE,CAAC,MAAM,CAAC;IACf,OAAO,EAAE,IAAI,IAAI,CAAC,0BAA0B,CAAC;IAC7C,SAAS,EAAE,mBAAmB;IAC9B,QAAQ,EAAE;QACR,OAAO,EAAE;YACP;gBACE,MAAM,EAAE,IAAI;gBACZ,WAAW,EAAE,IAAI;gBACjB,SAAS,EAAE,KAAK;gBAChB,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,KAAK;gBACnB,WAAW,EAAE,IAAI;aAClB;YACD;gBACE,MAAM,EAAE,KAAK;gBACb,WAAW,EAAE,CAAC;gBACd,SAAS,EAAE,IAAI;gBACf,UAAU,EAAE,IAAI;gBAChB,YAAY,EAAE,KAAK;gBACnB,WAAW,EAAE,IAAI;aAClB;YACD;gBACE,MAAM,EAAE,CAAC;gBACT,WAAW,EAAE,CAAC;gBACd,SAAS,EAAE,KAAK;gBAChB,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,KAAK;gBACnB,WAAW,EAAE,IAAI;aAClB;YACD;gBACE,MAAM,EAAE,GAAG;gBACX,WAAW,EAAE,CAAC;gBACd,SAAS,EAAE,KAAK;gBAChB,UAAU,EAAE,KAAK;gBACjB,YAAY,EAAE,KAAK;gBACnB,WAAW,EAAE,IAAI;aAClB;SACF;KACF;IACD,SAAS,EAAE,IAAI,IAAI,CAAC,0BAA0B,CAAC;CAChD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@unchainedshop/core-products",
-  "version": "2.0.0-rc.4",
+  "version": "2.0.0",
   "main": "lib/products-index.js",
   "exports": {
     ".": "./lib/products-index.js",
@@ -31,9 +31,9 @@
   },
   "homepage": "https://github.com/unchainedshop/unchained#readme",
   "dependencies": {
-    "@unchainedshop/events": "^2.0.0-rc.4",
-    "@unchainedshop/file-upload": "^2.0.0-rc.4",
-    "@unchainedshop/utils": "^2.0.0-rc.4",
+    "@unchainedshop/events": "^2.0.0",
+    "@unchainedshop/file-upload": "^2.0.0",
+    "@unchainedshop/utils": "^2.0.0",
     "locale": "^0.1.0",
     "lru-cache": "^7.14.1",
     "simpl-schema": "=3.2.0"
@@ -41,9 +41,9 @@
   "devDependencies": {
     "@types/locale": "^0.1.1",
     "@types/node": "^18.11.18",
-    "@unchainedshop/types": "^2.0.0-rc.4",
-    "jest": "^29.3.1",
-    "ts-jest": "^29.0.3",
+    "@unchainedshop/types": "^2.0.0",
+    "jest": "^29.4.1",
+    "ts-jest": "^29.0.5",
     "typescript": "^4.9.4"
   }
 }

package/src/director/ProductPricingSheet.test.ts

@@ -0,0 +1,180 @@
+import { ProductPricingSheet } from "./ProductPricingSheet.js";
+
+
+const TAX = { category: 'TAX', amount: 50, isNetPrice: false, isTaxable: false };
+const TAX2 = { category: 'TAX', amount: 25, isNetPrice: false, isTaxable: false };
+const DISCOUNT = { category: 'DISCOUNT', amount: 20, isNetPrice: false, isTaxable: false, discountId: 'for-all'  };
+const DISCOUNT2 = { category: 'DISCOUNT', amount: 20, isNetPrice: false, isTaxable: false, discountId: 'for-all'  };
+const DISCOUNT3 = { category: 'DISCOUNT', amount: 20, isNetPrice: false, isTaxable: false, discountId: 'special'  };
+const ITEM1 = { category: 'ITEM', amount: 200, isNetPrice: true, isTaxable: false };
+const ITEM2 = { category: 'ITEM', amount: 200, isNetPrice: true, isTaxable: false };
+const calculations = [TAX, TAX2, DISCOUNT, DISCOUNT2, DISCOUNT3, ITEM1, ITEM2];
+
+describe('ProductPricingSheet', () => {
+    let pricingSheet
+
+    const pricingSheetParams = {
+        calculation:  calculations,
+        currency: 'CHF',
+        quantity: 2,
+      };
+      beforeEach(() => {
+        pricingSheet = ProductPricingSheet(pricingSheetParams);
+      })
+      
+    it('should return an object that implements the IProductPricingSheet interface', () => {
+        expect(pricingSheet).toBeDefined();
+        expect(pricingSheet.quantity).toEqual(2);
+        expect(pricingSheet.currency).toEqual('CHF');
+        expect(typeof pricingSheet.addItem).toBe('function');
+        expect(typeof pricingSheet.addDiscount).toBe('function');
+        expect(typeof pricingSheet.addTax).toBe('function');
+        expect(typeof pricingSheet.taxSum).toBe('function');
+        expect(typeof pricingSheet.itemSum).toBe('function');
+        expect(typeof pricingSheet.discountSum).toBe('function');
+        expect(typeof pricingSheet.unitPrice).toBe('function');
+        expect(typeof pricingSheet.discountPrices).toBe('function');
+        expect(typeof pricingSheet.getItemRows).toBe('function');
+        expect(typeof pricingSheet.getDiscountRows).toBe('function');
+        expect(typeof pricingSheet.getTaxRows).toBe('function');
+      });
+
+      it('gross() should return the GROSS sum of all ProductPricingCalculation', () => {
+        expect(pricingSheet.gross()).toEqual(535)
+      })
+
+      it('net() should return the NET sum of all ProductPricingCalculation (i.e before TAX)', () => {
+        expect(pricingSheet.net()).toEqual(460)
+      })
+
+      describe('total()', () => {
+        it('should return sum of all ProductPricingCalculations ', () => {            
+            expect(pricingSheet.total()).toEqual({"amount": 535, "currency": "CHF"})
+            expect(pricingSheet.total()).toEqual({ amount: pricingSheet.gross(), currency: "CHF"})
+         })
+
+         it('should return sum of all ProductPricingCalculations ', () => {            
+            expect(pricingSheet.total({useNetPrice: true})).toEqual({"amount": 460, "currency": "CHF"})
+            expect(pricingSheet.total({useNetPrice: true})).toEqual({ amount: pricingSheet.net(), currency: "CHF"})
+         })
+
+         it('should return sum of all ProductPricingCalculations for the provided category ', () => {            
+          expect(pricingSheet.total({category: 'ITEM'})).toEqual({"amount": 400, "currency": "CHF"})
+          expect(pricingSheet.total({category: 'DISCOUNT'})).toEqual({"amount": 60, "currency": "CHF"})
+          expect(pricingSheet.total({category: 'TAX'})).toEqual({"amount": 75, "currency": "CHF"})
+       })
+      })
+
+      describe('isValid()', () => {
+        it('should return true if there is at least 1 registered ProductPricingCalculation ', () => {            
+            expect(pricingSheet.isValid()).toEqual(true)
+        })
+        it('should return false if there is no registered ProductPricingCalculation ', () => {    
+          const sheet = ProductPricingSheet({...pricingSheetParams, calculation: []});        
+          expect(sheet.isValid()).toEqual(false)
+      })
+      })
+
+      describe('getItemRows', () => {
+        it('should return all the items registered on the ProductPricingSheet', () => {            
+            expect(pricingSheet.getItemRows()).toEqual([ITEM1, ITEM2])
+          })
+      })
+
+      describe('getRawPricingSheet', () => {
+        it('should return all registered ProductPricingCalculation', () => {
+            
+            expect(pricingSheet.getRawPricingSheet()).toEqual(calculations)
+          })
+
+      })
+
+      describe('getTaxRows', () => {
+        it('should return all the TAX registered on the ProductPricingSheet', () => {
+            
+            expect(pricingSheet.getTaxRows()).toEqual([TAX, TAX2])
+          })
+
+      })
+
+      describe('getDiscountRows', () => {
+        it('should return all the DISCOUNTS registered on the ProductPricingSheet', () => {
+            expect(pricingSheet.getDiscountRows('for-all')).toEqual([DISCOUNT, DISCOUNT2])
+          })
+
+      })
+
+      describe('taxSum', () => {
+        it('should return the sum of TAX calculation registered on the adapter', () => {            
+            expect(pricingSheet.taxSum()).toEqual(75)
+          })
+
+      })
+
+      describe('discountSum', () => {
+        it('should return the sum of DISCOUNT calculation registered on the adapter', () => {
+            expect(pricingSheet.discountSum()).toEqual(60)
+          })
+
+      })
+
+      describe('itemSum', () => {
+        it('should return the sum of TAX calculation registered on the adapter', () => {            
+          expect(pricingSheet.itemSum()).toEqual(400)
+        })
+
+      })
+
+      describe('unitPrice', () => {
+        it('should return the GROSS sum for a  product price useNetPrice:false', () => {            
+          expect(pricingSheet.unitPrice({useNetPrice: false})).toEqual({"amount": 268, "category": "ITEM", "currency": "CHF", "isNetPrice": false, "isTaxable": true})
+        })
+
+        it('should return the NET sum for a product price when useNetPrice:true', () => {            
+          expect(pricingSheet.unitPrice({useNetPrice: true})).toEqual({"amount": 230, "category": "ITEM", "currency": "CHF", "isNetPrice": true, "isTaxable": true})
+        })
+      })
+
+      describe('discountPrices', () => {
+        it('should return the sum of all discounts registered on the price sheet based on discountId', () => {            
+          expect(pricingSheet.discountPrices('for-all')).toEqual([{"amount": 40, "currency": "CHF", "discountId": "for-all"}])
+          expect(pricingSheet.discountPrices('special')).toEqual([{"amount": 20, "currency": "CHF", "discountId": "special"}])
+        })
+
+        it('should return empty array if discount with the provided discountId is not found', () => {            
+          expect(pricingSheet.discountPrices('non-existing')).toEqual([])
+        })
+
+      })
+
+      describe('addItem', () => {
+        it('should add ProductPricingCalculation ITEM category successfully', () => {            
+          expect(pricingSheet.getItemRows()).toEqual([ITEM1, ITEM2])
+          pricingSheet.addItem({amount: 300, isNetPrice: true, isTaxable: true})
+          expect(pricingSheet.getItemRows()).toEqual([ITEM1, ITEM2, {amount: 300, isNetPrice: true, isTaxable: true, category: 'ITEM', meta: undefined}])          
+        })
+
+      })
+
+      describe('addDiscount', () => {
+        it('should add ProductPricingCalculation DISCOUNT category successfully', () => {            
+          expect(pricingSheet.getDiscountRows('new')).toEqual([])
+          pricingSheet.addDiscount({amount: 300, isNetPrice: true, isTaxable: true, discountId: 'new'})
+          expect(pricingSheet.getDiscountRows('new')).toEqual([{amount: 300, isNetPrice: true, isTaxable: true, category: 'DISCOUNT', meta: undefined, discountId: 'new'}])          
+        })
+      })
+
+
+      describe('addTax', () => {
+        it('should add ProductPricingCalculation TAX category successfully', () => {            
+          expect(pricingSheet.getTaxRows()).toEqual([TAX, TAX2])
+          pricingSheet.addTax({amount: 50})
+          expect(pricingSheet.getTaxRows()).toEqual([TAX, TAX2, {amount: 50, isNetPrice: false, isTaxable: false, category: 'TAX'}])          
+        })
+      })
+      
+
+})
+
+
+  

package/{tests/products-index.test.js → src/module/buildFindSelector.test.ts}

@@ -1,61 +1,66 @@
-import {buildFindSelector} from "../lib/module/configureProductsModule.js"
+import { buildFindSelector } from "./configureProductsModule";
+
 describe('Product', () => {
   describe("buildFindSelector", () => {
     it('Return correct filter object object when no parameter is passed', async () => {
-      expect(buildFindSelector({})).toEqual({ status: { $eq: 'ACTIVE' } })
+      expect(buildFindSelector({}as any)).toEqual( { status: { '$eq': 'ACTIVE' } })
     })
-
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector, queryString, slugs, tags ', async () => {
-      expect(buildFindSelector({includeDrafts: true, productIds: ['product-1-id', 'product-id-2'], productSelector: {type: "SIMPLE_PRODUCT"}, queryString: "hello world", slugs: ['slug-1', 'slug-2'], tags: ['tag-1', 'tag-2'] })).toEqual( {
+      expect(buildFindSelector({ includeDrafts: true, productIds: ['product-1-id', 'product-id-2'], productSelector: {type: "SIMPLE_PRODUCT"}, queryString: "hello world", 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 ] }
-      })
-    });
+      }
+)
+  });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector, queryString, slugs ', async () => {
-      expect(buildFindSelector({includeDrafts: true, productIds: ['product-1-id', 'product-id-2'], productSelector: {type: "SIMPLE_PRODUCT"}, queryString: "hello world", slugs: ['slug-1', 'slug-2']})).toEqual( {
+      expect(buildFindSelector({includeDrafts: true, productIds: ['product-1-id', 'product-id-2'], productSelector: {type: "SIMPLE_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 ] }
+        status: { '$in': [ 'ACTIVE', null ] },
+        
       })
     });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector, queryString ', async () => {
-      expect(buildFindSelector({includeDrafts: true, productIds: ['product-1-id', 'product-id-2'], productSelector: {type: "SIMPLE_PRODUCT"}, queryString: "hello world"})).toEqual( {
+      expect(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 ] }
+        status: { '$in': [ 'ACTIVE', null ] },
+        
       })
     });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds, productSelector ', async () => {
-      expect(buildFindSelector({includeDrafts: true, productIds: ['product-1-id', 'product-id-2'], productSelector: {type: "SIMPLE_PRODUCT"}})).toEqual( {
+      expect(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 ] }
+        status: { '$in': [ 'ACTIVE', null ] },
+        
       })
     });
 
     it('Return correct filter object object when passed includeDraft:true, productsIds ', async () => {
-      expect(buildFindSelector({includeDrafts: true, productIds: ['product-1-id', 'product-id-2']})).toEqual( {
+      expect(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 ] }
+        status: { '$in': [ 'ACTIVE', null ] },
+        
       })
     });
 
     it('Return filter tags if passed as a string ', async () => {
-      expect(buildFindSelector({tags: "string-tag"})).toEqual({ tags: 'string-tag', status: { '$eq': 'ACTIVE' } })
+      expect(buildFindSelector({tags: "string-tag"}as any)).toEqual({ tags: 'string-tag', status: { '$eq': 'ACTIVE' } })
     });
 
     it('includeDrafts true  should add null to status filter array as null ', async () => {
-      expect(buildFindSelector({includeDrafts: true})).toEqual({status: { '$in': [ 'ACTIVE', null ] }} )
+      expect(buildFindSelector({includeDrafts: true}as any)).toEqual({status: { '$in': [ 'ACTIVE', null ] }} )
     });
 
   });

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

@@ -0,0 +1,98 @@
+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);
+  });
+
+  it('normalizeRate converting between FIAT with 2 decimals', () => {
+    expect(normalizeRate({
+      isoCode: "USD",
+      decimals: 2
+    } as any, {
+      isoCode: "CHF",
+      decimals: 2
+    } as any, { quoteCurrency: "USD", rate: 0.9} as any)).toBe(1.1111111111111112);
+
+    expect(normalizeRate({
+      isoCode: "CHF", // in Rappen
+      decimals: 2
+    } as any, {
+      isoCode: "USD", // in Pennies
+      decimals: 2
+    } as any, { quoteCurrency: "USD", rate: 0.9} as any)).toBe(0.9);
+  });
+
+  it('normalizeRate converting between FIAT with 0 and 2 decimals', () => {
+    expect(normalizeRate({
+      isoCode: "CLP", // in Pesos
+      decimals: 0
+    } as any, {
+      isoCode: "CHF", // in Rappen
+      decimals: 2
+    } as any, { baseCurrency: "CLP", quoteCurrency: "CHF", rate: 0.0010451376} as any)).toBe(0.10451376);
+
+    expect(normalizeRate({
+      isoCode: "CLP", // in Pesos
+      decimals: 0
+    } as any, {
+      isoCode: "CHF", // in Rappen
+      decimals: 2
+    } as any, {
+      baseCurrency: "CHF", quoteCurrency: "CLP", rate: 956.75994,
+      expiresAt: undefined,
+      timestamp: undefined
+    })).toBe(0.10451942626276765);
+  });
+
+  it('normalizeRate converting FIAT to/from Crypto with Crypto->Fiat Pair', () => {
+    expect(normalizeRate({
+      isoCode: "USD", // in Pennies
+      decimals: 2
+    } as any, {
+      isoCode: "BTC", // In Satoshis
+      decimals: 9
+    } as any, { baseCurrency: "BTC", quoteCurrency: "USD", rate: 19284.61} as any)).toBe(518.5482102049251);
+
+    expect(normalizeRate({
+      isoCode: "ETH", // in GWEI
+      decimals: 18
+    } as any, {
+      isoCode: "CHF", // in Rappen
+      decimals: 2
+    } as any, { baseCurrency: "ETH", quoteCurrency: "CHF", rate: 1311.63} as any)).toBe(0.000131163);
+
+    // 1 ETH = 0.000131163
+  });
+
+  it('normalizeRate converting FIAT to/from Crypto with Fiat->Crypto Pair', () => {
+    expect(normalizeRate({
+      isoCode: "USD", // in Pennies
+      decimals: 2
+    } as any, {
+      isoCode: "BTC", // in Satoshis
+      decimals: 8
+    } as  any, { baseCurrency: "USD", quoteCurrency: "BTC", rate: 0.000052} as any)).toBe(52);
+
+    // 1 USD = 100 Pennies
+    // 100 Pennies = 5200 Satoshis
+
+    expect(normalizeRate({
+      isoCode: "ETH", // in GWEI
+      decimals: 18
+    } as any, {
+      isoCode: "CLP", // in Pesos
+      decimals: 0
+    } as any, { baseCurrency: "CLP", quoteCurrency: "ETH", rate: 0.000000794} as any)).toBe(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

@@ -0,0 +1,84 @@
+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);
+  });
+
+  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([
+      {
+        amount: 20000,
+        maxQuantity: 2,
+        isTaxable: true,
+        isNetPrice: true,
+        currencyCode: 'ETB',
+        countryCode: 'ET',
+      },
+    ]);
+    expect(getPriceLevels({ product, countryCode: 'CH' } as any)).toHaveLength(3);
+    expect(getPriceLevels({ product, countryCode: 'CH' } as any)).toEqual([
+      {
+        amount: 1000,
+        maxQuantity: null,
+        isTaxable: false,
+        isNetPrice: false,
+        currencyCode: 'CHF',
+        countryCode: 'CH',
+      },
+      {
+        amount: 1,
+        maxQuantity: 1,
+        isTaxable: false,
+        isNetPrice: false,
+        currencyCode: 'ETH',
+        countryCode: 'CH',
+      },
+      {
+        amount: 750,
+        maxQuantity: 2,
+        isTaxable: false,
+        isNetPrice: false,
+        currencyCode: 'CHF',
+        countryCode: 'CH',
+      },
+    ]);
+  });
+
+  it('Should return all prices for a given country sorted by max quantity ASC', () => {
+    expect(getPriceLevels({ product, countryCode: 'CH' } as any)).toEqual([
+      {
+        amount: 1000,
+        maxQuantity: null,
+        isTaxable: false,
+        isNetPrice: false,
+        currencyCode: 'CHF',
+        countryCode: 'CH',
+      },
+      {
+        amount: 1,
+        maxQuantity: 1,
+        isTaxable: false,
+        isNetPrice: false,
+        currencyCode: 'ETH',
+        countryCode: 'CH',
+      },
+      {
+        amount: 750,
+        maxQuantity: 2,
+        isTaxable: false,
+        isNetPrice: false,
+        currencyCode: 'CHF',
+        countryCode: 'CH',
+      },
+    ]);
+  });
+
+  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);
+  });
+});

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

@@ -0,0 +1,53 @@
+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(
+      getPriceRange({
+        productId: product._id,
+        prices: getPriceLevels({ product, countryCode: 'CH', currencyCode: 'CHF' } as any),
+      }),
+    ).toEqual({
+      minPrice: {
+        _id: '3e94daeb7a9600e9bb07b50c92c21ac9002da34a2d8fe799a6ce885404b545b9',
+        isTaxable: false,
+        isNetPrice: false,
+        amount: 750,
+        currencyCode: 'CHF',
+      },
+      maxPrice: {
+        _id: 'b6a9702eb217f07ad5fa8c3a378e072d49b667813db0e127fab7cf5e2c4b2639',
+        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(
+      getPriceRange({
+        productId: product._id,
+        prices: getPriceLevels({ product, countryCode: 'DE', currencyCode: 'EUR' } as any),
+      }),
+    ).toEqual({
+      minPrice: {
+        _id: '00f750fe893f9f5e04c31a6a6f1a60f5d941182e388b7908a02e5bc855d16797',
+        isTaxable: false,
+        isNetPrice: false,
+        amount: NaN,
+        currencyCode: undefined,
+      },
+      maxPrice: {
+        _id: '00f750fe893f9f5e04c31a6a6f1a60f5d941182e388b7908a02e5bc855d16797',
+        isTaxable: false,
+        isNetPrice: false,
+        amount: NaN,
+        currencyCode: undefined,
+      },
+    });
+  });
+});

package/tests/product-index.test.ts

@@ -0,0 +1,7 @@
+describe('Product', () => {
+
+  it('Product', async () => {
+   expect(true).toBeTruthy()
+  });
+
+});

package/tsconfig.json

@@ -1,29 +1,11 @@
 {
+  "extends": "../shared/base.tsconfig.json",
   "compilerOptions": {
-    "allowJs": true,
-    "allowSyntheticDefaultImports": true,
-    "declaration": true,
-    "esModuleInterop": true,
-    "experimentalDecorators": true,
-    "forceConsistentCasingInFileNames": true,
-    "lib": [
-      "esnext"
-    ],
-    "module": "Node16",
-    "moduleResolution": "Node16",
-    "noImplicitReturns": true,
-    "noUnusedLocals": false,
+    "rootDir": "src",
     "outDir": "lib",
-    "preserveWatchOutput": true,
-    "skipLibCheck": true,
-    "sourceMap": true,
-    "target": "ES2022",
-    "types": [
-      "node",
-      "jest"
-    ]
   },
+  "exclude": ["**/*.test.ts", "**/*.test.js", "tests"],
   "include": [
-    "src"
+    "./src"
   ]
 }

package/tests/configureProductPrices.test.js

@@ -1,318 +0,0 @@
-import { getDecimals, normalizeRate } from '../lib/module/configureProductPrices.js';
-import { getPriceLevels } from '../lib/module/utils/getPriceLevels.js';
-import { getPriceRange } from '../lib/module/utils/getPriceRange.js';
-import product from './mock/product'
-
-describe('Rate conversion', () => {
-  test('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);
-  });
-
-  test('normalizeRate converting between FIAT with 2 decimals', () => {
-    expect(normalizeRate({
-      isoCode: "USD",
-      decimals: 2
-    }, {
-      isoCode: "CHF",
-      decimals: 2
-    }, { quoteCurrency: "USD", rate: 0.9})).toBe(1.1111111111111112);
-
-    expect(normalizeRate({
-      isoCode: "CHF", // in Rappen
-      decimals: 2
-    }, {
-      isoCode: "USD", // in Pennies
-      decimals: 2
-    }, { quoteCurrency: "USD", rate: 0.9})).toBe(0.9);
-  });
-
-  test('normalizeRate converting between FIAT with 0 and 2 decimals', () => {
-    expect(normalizeRate({
-      isoCode: "CLP", // in Pesos
-      decimals: 0
-    }, {
-      isoCode: "CHF", // in Rappen
-      decimals: 2
-    }, { baseCurrency: "CLP", quoteCurrency: "CHF", rate: 0.0010451376})).toBe(0.10451376);
-
-    expect(normalizeRate({
-      isoCode: "CLP", // in Pesos
-      decimals: 0
-    }, {
-      isoCode: "CHF", // in Rappen
-      decimals: 2
-    }, { baseCurrency: "CHF", quoteCurrency: "CLP", rate: 956.75994})).toBe(0.10451942626276765);
-  });
-
-  test('normalizeRate converting FIAT to/from Crypto with Crypto->Fiat Pair', () => {
-    expect(normalizeRate({
-      isoCode: "USD", // in Pennies
-      decimals: 2
-    }, {
-      isoCode: "BTC", // In Satoshis
-      decimals: 9
-    }, { baseCurrency: "BTC", quoteCurrency: "USD", rate: 19284.61})).toBe(518.5482102049251);
-
-    expect(normalizeRate({
-      isoCode: "ETH", // in GWEI
-      decimals: 18
-    }, {
-      isoCode: "CHF", // in Rappen
-      decimals: 2
-    }, { baseCurrency: "ETH", quoteCurrency: "CHF", rate: 1311.63})).toBe(0.000131163);
-
-    // 1 ETH = 0.000131163
-  });
-
-  test('normalizeRate converting FIAT to/from Crypto with Fiat->Crypto Pair', () => {
-    expect(normalizeRate({
-      isoCode: "USD", // in Pennies
-      decimals: 2
-    }, {
-      isoCode: "BTC", // in Satoshis
-      decimals: 8
-    }, { baseCurrency: "USD", quoteCurrency: "BTC", rate: 0.000052})).toBe(52);
-
-    // 1 USD = 100 Pennies
-    // 100 Pennies = 5200 Satoshis
-
-    expect(normalizeRate({
-      isoCode: "ETH", // in GWEI
-      decimals: 18
-    }, {
-      isoCode: "CLP", // in Pesos
-      decimals: 0
-    }, { baseCurrency: "CLP", quoteCurrency: "ETH", rate: 0.000000794})).toBe(0.0012594458438287153);
-    
-    // 1 ETH = 1,000,000,000 GWEI (10^9)
-    // 1,000,000,000 GWEI = 1’259’445 CLP
-  });
-});
-
-describe('Price level', () => {
-  it('Should return empty array when country code is not specified', () => {
-    expect(getPriceLevels({product,  currencyCode: "CHF"})).toHaveLength(0)
-  })
-
-  it('Should return empty array when country code is not specified', () => {
-    expect(getPriceLevels({product,  countryCode: "ET"})).toHaveLength(1)
-    expect(getPriceLevels({product,  countryCode: "ET"})).toEqual([
-      {
-        amount: 20000,
-        maxQuantity: 2,
-        isTaxable: true,
-        isNetPrice: true,
-        currencyCode: 'ETB',
-        countryCode: 'ET'
-      }
-    ])
-    expect(getPriceLevels({product,  countryCode: "CH"})).toHaveLength(3)
-    expect(getPriceLevels({product,  countryCode: "CH"})).toEqual([
-      {
-        amount: 1000,
-        maxQuantity: null,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      },
-      {
-        amount: 1,
-        maxQuantity: 1,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'ETH',
-        countryCode: 'CH'
-      },
-      {
-        amount: 750,
-        maxQuantity: 2,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      }
-    ])
-  })
-
-
-  it('Should return all prices for a given country sorted by max quantity ASC', () => {
-    expect(getPriceLevels({product,  countryCode: "CH"})).toEqual([
-      {
-        amount: 1000,
-        maxQuantity: null,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      },
-      {
-        amount: 1,
-        maxQuantity: 1,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'ETH',
-        countryCode: 'CH'
-      },
-      {
-        amount: 750,
-        maxQuantity: 2,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      }
-    ])
-  })
-
-  it('Should return all prices currencyCode', () => {
-    expect(getPriceLevels({product,  countryCode: "CH", currencyCode: "CHF"})).toHaveLength(2)
-    expect(getPriceLevels({product,  countryCode: "CH", currencyCode: "ETH"})).toHaveLength(1)
-    
-  })
-})
-
-
-
-describe('Price Range', () => {
-  it('Should return the minimum and maximum price of a product when there are multiple prices', () => {
-    expect(getPriceRange({productId: product._id, prices: getPriceLevels({product, countryCode: "CH", currencyCode: "CHF"}) })).toEqual({
-      minPrice: {
-        _id: '3e94daeb7a9600e9bb07b50c92c21ac9002da34a2d8fe799a6ce885404b545b9',
-        isTaxable: false,
-        isNetPrice: false,
-        amount: 750,
-        currencyCode: 'CHF'
-      },
-      maxPrice: {
-        _id: 'b6a9702eb217f07ad5fa8c3a378e072d49b667813db0e127fab7cf5e2c4b2639',
-        isTaxable: false,
-        isNetPrice: false,
-        amount: 1000,
-        currencyCode: 'CHF'
-      }
-    })
-  })
-
-  it('Should return the same price as minimum and maximum when only one price exist for a given currency', () => {
-    expect(getPriceRange({productId: product._id, prices: getPriceLevels({product, countryCode: "ET", currencyCode: "ETB"}) })).toEqual({
-      minPrice: {
-        _id: '1740965265959af6ecda7cc3e06454069d6ed4e21ae052791ab172a342c82fa0',
-        isTaxable: true,
-        isNetPrice: true,
-        amount: 20000,
-        currencyCode: 'ETB'
-      },
-      maxPrice: {
-        _id: '1740965265959af6ecda7cc3e06454069d6ed4e21ae052791ab172a342c82fa0',
-        isTaxable: true,
-        isNetPrice: true,
-        amount: 20000,
-        currencyCode: 'ETB'
-      }
-    })
-  })
-
-  it('Should still return and object with min and max price field when no price list is provided', () => {
-
-    
-    expect(getPriceRange({productId: product._id, prices: getPriceLevels({product, countryCode: "DE", currencyCode: "EUR"}) })).toEqual({
-      minPrice: {
-        _id: '00f750fe893f9f5e04c31a6a6f1a60f5d941182e388b7908a02e5bc855d16797',
-        isTaxable: false,
-        isNetPrice: false,
-        amount: NaN,
-        currencyCode: undefined
-      },
-      maxPrice: {
-        _id: '00f750fe893f9f5e04c31a6a6f1a60f5d941182e388b7908a02e5bc855d16797',
-        isTaxable: false,
-        isNetPrice: false,
-        amount: NaN,
-        currencyCode: undefined
-      }
-    })
-  })
-
-  it('Should return empty array when country code is not specified', () => {
-    expect(getPriceLevels({product,  countryCode: "ET"})).toHaveLength(1)
-    expect(getPriceLevels({product,  countryCode: "ET"})).toEqual([
-      {
-        amount: 20000,
-        maxQuantity: 2,
-        isTaxable: true,
-        isNetPrice: true,
-        currencyCode: 'ETB',
-        countryCode: 'ET'
-      }
-    ])
-    expect(getPriceLevels({product,  countryCode: "CH"})).toHaveLength(3)
-    expect(getPriceLevels({product,  countryCode: "CH"})).toEqual([
-      {
-        amount: 1000,
-        maxQuantity: null,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      },
-      {
-        amount: 1,
-        maxQuantity: 1,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'ETH',
-        countryCode: 'CH'
-      },
-      {
-        amount: 750,
-        maxQuantity: 2,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      }
-    ])
-  })
-
-
-  it('Should return all prices for a given country sorted by max quantity ASC', () => {
-    expect(getPriceLevels({product,  countryCode: "CH"})).toEqual([
-      {
-        amount: 1000,
-        maxQuantity: null,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      },
-      {
-        amount: 1,
-        maxQuantity: 1,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'ETH',
-        countryCode: 'CH'
-      },
-      {
-        amount: 750,
-        maxQuantity: 2,
-        isTaxable: false,
-        isNetPrice: false,
-        currencyCode: 'CHF',
-        countryCode: 'CH'
-      }
-    ])
-  })
-
-  it('Should return all prices currencyCode', () => {
-    expect(getPriceLevels({product,  countryCode: "CH", currencyCode: "CHF"})).toHaveLength(2)
-    expect(getPriceLevels({product,  countryCode: "CH", currencyCode: "ETH"})).toHaveLength(1)
-    
-  })
-})

package/tests/products-review.test.js

@@ -1,74 +0,0 @@
-import {buildFindSelector} from "../lib/module/configureProductReviewsModule"
-describe('Product Review', () => {
-  describe("buildFindSelector", () => {
-    it('Return correct filter object object when no parameter is passed', async () => {
-      expect(buildFindSelector({})).toEqual({deleted: null})
-    })
-
-    it('Return correct filter object object when passed authorId, productId, queryString & updated', async () => {
-      expect(buildFindSelector({authorId: "admin-id", productId: "product-id", queryString: "hello world", updated: {start: new Date("2022-12-04T14:54:51.184Z"), end: new Date("2022-12-04T14:54:51.184Z")}})).toEqual( {
-        productId: 'product-id',
-        authorId: 'admin-id',
-        deleted: null,
-        '$text': { '$search': 'hello world' },
-        
-        updated: {
-          '$gte': new Date("2022-12-04T14:54:51.184Z"),
-          '$lte': new Date("2022-12-04T14:54:51.184Z")
-        }
-      })
-    });
-
-    it('Return correct filter object object when passed authorId, productId & queryString ', async () => {
-      expect(buildFindSelector({authorId: "admin-id", productId: "product-id", queryString: "hello world",})).toEqual( {
-        productId: 'product-id',
-        authorId: 'admin-id',
-        deleted: null,
-        '$text': { '$search': 'hello world' },
-      })
-    });
-
-    it('Return correct filter object object when passed authorId &  productId ', async () => {
-      expect(buildFindSelector({authorId: "admin-id", productId: "product-id"})).toEqual( {
-        productId: 'product-id',
-        authorId: 'admin-id',
-        deleted: null,
-      })
-    });
-
-    it('Return correct filter object object when passed authorId ', async () => {
-      expect(buildFindSelector({authorId: "admin-id"})).toEqual( {
-        authorId: 'admin-id',
-        deleted: null,
-      })
-    });
-
-    it('Set created date filter to unix start time if created.start is not provided  ', async () => {
-      expect(buildFindSelector({created: { end: new Date("2022-12-04T14:54:51.184Z")}})).toEqual({
-        deleted: null,
-        created: {
-          '$gte': new Date(0),
-          '$lte': new Date("2022-12-04T14:54:51.184Z")
-        }
-      })
-    });
-
-    it('Set updated date filter to unix start time if updated.start is not provided  ', async () => {
-      expect(buildFindSelector({updated: { end: new Date("2022-12-04T14:54:51.184Z")}})).toEqual({
-        deleted: null,
-        updated: {
-          '$gte': new Date(0),
-          '$lte': new Date("2022-12-04T14:54:51.184Z")
-        }
-      })
-    });
-
-    it('Should filter created date greater that provided when created.end is not provided', async () => {      
-      expect(buildFindSelector({created: { start: new Date("2022-12-04T14:54:51.184Z")}})).toEqual({ deleted: null, created: { '$gte': new Date("2022-12-04T14:54:51.184Z") } })
-    });
-
-    it('Should filter updated date greater that provided when updated.end is not provided', async () => {      
-      expect(buildFindSelector({updated: { start: new Date("2022-12-04T14:54:51.184Z")}})).toEqual({ deleted: null, updated: { '$gte': new Date("2022-12-04T14:54:51.184Z") } })
-    });
-  })
-});