@commercetools-frontend/experimental-components 0.0.2

package/src/utils/prices/prices.spec.js

@@ -0,0 +1,265 @@
+import { PRECISION_TYPES } from '../constants';
+import {
+  getPriceChannelName,
+  getDiscountValue,
+  getSelectedPrice,
+  getNetUnitPrice,
+  getMinimumPricesByCurrencyCode,
+} from './prices';
+
+describe('getPriceChannelName', () => {
+  describe('when there is no channel on price', () => {
+    describe.each([{}, { channel: {} }])('with price: %j', (price) => {
+      it('should return null', () => {
+        expect(getPriceChannelName(price)).toBe(null);
+      });
+    });
+  });
+
+  describe('when price has a channel with a name', () => {
+    it('should return name', () => {
+      const price = { channel: { name: 'channel-1' } };
+      expect(getPriceChannelName(price)).toBe('channel-1');
+    });
+  });
+
+  describe('when price has a channel with no name but a key', () => {
+    it('should return the key', () => {
+      const price = { channel: { key: 'channel-1-key' } };
+      expect(getPriceChannelName(price)).toBe('channel-1-key');
+    });
+  });
+});
+
+describe('getDiscountValue', () => {
+  it('should have property of fractionalAmount when price is precise and discount is cent', () => {
+    const price = {
+      value: {
+        currencyCode: 'EUR',
+        preciseAmount: 1000000,
+        fractionDigits: 5,
+        type: PRECISION_TYPES.highPrecision,
+      },
+      discounted: {
+        value: {
+          currencyCode: 'EUR',
+          centAmount: 900,
+          fractionDigits: 2,
+          type: PRECISION_TYPES.centPrecision,
+        },
+      },
+    };
+
+    expect(getDiscountValue(price)).toHaveProperty('fractionedAmount', 1);
+  });
+
+  it('should return the discount value between price and discounted', () => {
+    const price = {
+      value: {
+        currencyCode: 'EUR',
+        centAmount: 1000,
+      },
+      discounted: {
+        value: {
+          currencyCode: 'EUR',
+          centAmount: 900,
+        },
+      },
+    };
+    expect(getDiscountValue(price)).toEqual({
+      currencyCode: 'EUR',
+      centAmount: 100,
+    });
+  });
+
+  it('should return 0 in money format when no discount is set', () => {
+    const price = {
+      value: {
+        currencyCode: 'EUR',
+        centAmount: 1000,
+      },
+    };
+    expect(getDiscountValue(price)).toEqual({
+      currencyCode: 'EUR',
+      centAmount: 0,
+    });
+  });
+});
+
+describe('getSelectedPrice', () => {
+  it('should return the discounted price', () => {
+    const price = {
+      value: {
+        currencyCode: 'EUR',
+        centAmount: 1000,
+      },
+      discounted: {
+        value: {
+          currencyCode: 'EUR',
+          centAmount: 900,
+        },
+      },
+    };
+    expect(getSelectedPrice(price)).toEqual({
+      value: {
+        currencyCode: 'EUR',
+        centAmount: 900,
+      },
+    });
+  });
+
+  it('should return the price in money format when no discount is set', () => {
+    const price = {
+      value: {
+        currencyCode: 'EUR',
+        centAmount: 1000,
+      },
+    };
+    expect(getSelectedPrice(price)).toEqual({
+      value: {
+        currencyCode: 'EUR',
+        centAmount: 1000,
+      },
+    });
+  });
+});
+
+describe('getNetUnitPrice', () => {
+  let price;
+  describe('with taxRate', () => {
+    describe('if taxRate is includedInPrice', () => {
+      describe('if amount should be rounded', () => {
+        beforeEach(() => {
+          price = getNetUnitPrice({
+            lineItem: {
+              taxRate: {
+                amount: 0.19,
+                includedInPrice: true,
+              },
+              // See https://jira.commercetools.com/browse/MCD-742
+              price: { value: { currencyCode: 'EUR', centAmount: 19499 } },
+            },
+            shouldRoundAmount: true,
+          });
+        });
+        it('should return rounded price value', () => {
+          expect(price).toEqual({ currencyCode: 'EUR', centAmount: 16386 });
+        });
+      });
+      describe('if amount should not be rounded', () => {
+        beforeEach(() => {
+          price = getNetUnitPrice({
+            lineItem: {
+              taxRate: {
+                amount: 0.19,
+                includedInPrice: true,
+              },
+              // See https://jira.commercetools.com/browse/MCD-742
+              price: { value: { currencyCode: 'EUR', centAmount: 19499 } },
+            },
+            shouldRoundAmount: false,
+          });
+        });
+        it('should return raw price value', () => {
+          expect(price).toEqual({
+            currencyCode: 'EUR',
+            centAmount: 16385.714285714286,
+          });
+        });
+      });
+    });
+    describe('if taxRate is not includedInPrice', () => {
+      beforeEach(() => {
+        price = getNetUnitPrice({
+          lineItem: {
+            taxRate: { amount: 0.19, includedInPrice: false },
+            price: { value: { currencyCode: 'EUR', centAmount: 1000 } },
+          },
+          shouldRoundAmount: true,
+        });
+      });
+      it('should return price value', () => {
+        expect(price).toEqual({ currencyCode: 'EUR', centAmount: 1000 });
+      });
+    });
+  });
+  describe('without taxRate', () => {
+    beforeEach(() => {
+      price = getNetUnitPrice({
+        lineItem: {
+          price: { value: { currencyCode: 'EUR', centAmount: 1000 } },
+        },
+        shouldRoundAmount: true,
+      });
+    });
+    it('should return price value', () => {
+      expect(price).toEqual({ currencyCode: 'EUR', centAmount: 1000 });
+    });
+  });
+});
+
+describe('getMinimumPricesByCurrencyCode', () => {
+  let prices;
+  describe('with empty prices', () => {
+    beforeEach(() => {
+      prices = [];
+    });
+    it('should return empty array', () => {
+      expect(getMinimumPricesByCurrencyCode(prices)).toHaveLength(0);
+    });
+  });
+  describe('with prices', () => {
+    beforeEach(() => {
+      prices = [
+        {
+          value: {
+            currencyCode: 'EUR',
+            centAmount: 1000,
+          },
+        },
+        {
+          value: {
+            currencyCode: 'EUR',
+            centAmount: 9000,
+          },
+        },
+        {
+          value: {
+            currencyCode: 'EUR',
+            centAmount: 10000,
+          },
+        },
+        {
+          value: {
+            currencyCode: 'USD',
+            centAmount: 1000,
+          },
+        },
+        {
+          value: {
+            currencyCode: 'USD',
+            centAmount: 9000,
+          },
+        },
+        {
+          value: {
+            currencyCode: 'USD',
+            centAmount: 10000,
+          },
+        },
+      ];
+    });
+    it('should return only minimum prices for each currency', () => {
+      expect(getMinimumPricesByCurrencyCode(prices)).toEqual([
+        {
+          currencyCode: 'EUR',
+          centAmount: 1000,
+        },
+        {
+          currencyCode: 'USD',
+          centAmount: 1000,
+        },
+      ]);
+    });
+  });
+});

package/src/utils/product-selections/convert-product-selection-from-graphql.js

@@ -0,0 +1,80 @@
+import {
+  applyTransformedLocalizedFields,
+  transformLocalizedFieldToLocalizedString,
+} from '@commercetools-frontend/l10n';
+
+const transformCustomFieldFromGraphQLResponse = (resource) => ({
+  type: {
+    typeId: 'type',
+    id: resource.custom.type.id,
+    obj: {
+      key: resource.custom.type.key,
+      name: transformLocalizedFieldToLocalizedString(
+        resource.custom.type.nameAllLocales
+      ),
+      fieldDefinitions: resource.custom.type.fieldDefinitions.map(
+        (fieldDefinition) => ({
+          name: fieldDefinition.name,
+          required: fieldDefinition.required,
+          type: do {
+            if (fieldDefinition.type?.elementType?.name === 'LocalizedEnum')
+              ({
+                ...fieldDefinition.type,
+                elementType: {
+                  ...fieldDefinition.type.elementType,
+                  values: fieldDefinition.type.elementType.values.map(
+                    (value) => ({
+                      key: value.key,
+                      label: transformLocalizedFieldToLocalizedString(
+                        value.labelAllLocales
+                      ),
+                    })
+                  ),
+                },
+              });
+            else if (fieldDefinition.type?.name === 'LocalizedEnum')
+              ({
+                ...fieldDefinition.type,
+                values: fieldDefinition.type.values.map((value) => ({
+                  key: value.key,
+                  label: transformLocalizedFieldToLocalizedString(
+                    value.labelAllLocales
+                  ),
+                })),
+              });
+            else fieldDefinition.type;
+          },
+          label: transformLocalizedFieldToLocalizedString(
+            fieldDefinition.labelAllLocales
+          ),
+        })
+      ),
+    },
+  },
+  fields: resource.custom.customFieldsRaw.reduce(
+    (fields, customField) => ({
+      ...fields,
+      [customField.name]: customField.value,
+    }),
+    {}
+  ),
+});
+
+// eslint-disable-next-line import/prefer-default-export
+export const convertProductSelectionFromGraphQl = (productSelection) => {
+  // the reason to default to null is that the consumer of the hook should expect consistent value.
+  // Incase the product selection is not missing or if the current project dose not yet have access to the feature,
+  // in either case we return null
+  if (!productSelection) return null;
+  return {
+    ...applyTransformedLocalizedFields(productSelection, [
+      {
+        from: 'nameAllLocales',
+        to: 'name',
+      },
+    ]),
+    custom: productSelection?.custom
+      ? transformCustomFieldFromGraphQLResponse(productSelection)
+      : null,
+  };
+};

package/src/utils/product-selections/index.js

@@ -0,0 +1 @@
+export * from './convert-product-selection-from-graphql';

package/src/utils/product-types/index.js

@@ -0,0 +1 @@
+export * from './product-types';

package/src/utils/product-types/product-types.js

@@ -0,0 +1,122 @@
+import sortBy from 'lodash.sortby';
+import uniqBy from 'lodash.uniqby';
+import { defaultMemoize } from 'reselect';
+
+const getIsAttributeOfTypeEnum = (attributeType) =>
+  attributeType.name === 'enum' ||
+  attributeType.name === 'lenum' ||
+  (attributeType.name === 'set' &&
+    (attributeType.elementType.name === 'enum' ||
+      attributeType.elementType.name === 'lenum'));
+
+export function mergeEnumValues(attribute, attributeToMergeValuesWith) {
+  const enumValues =
+    attribute.type.name === 'set'
+      ? attribute.type.elementType.values
+      : attribute.type.values;
+
+  const enumValuesToMergeWith =
+    attributeToMergeValuesWith.type.name === 'set'
+      ? attributeToMergeValuesWith.type.elementType.values
+      : attributeToMergeValuesWith.type.values;
+
+  return uniqBy([...enumValues, ...enumValuesToMergeWith], 'key');
+}
+
+export function updateEnumValuesOnAttribute(attribute, enumValues) {
+  const isAttributeOfTypeSet = attribute.type.name === 'set';
+  const type = isAttributeOfTypeSet
+    ? {
+        ...attribute.type,
+        elementType: {
+          ...attribute.type.elementType,
+          values: enumValues,
+        },
+      }
+    : {
+        ...attribute.type,
+        values: enumValues,
+      };
+
+  return {
+    ...attribute,
+    type,
+  };
+}
+
+export const getAllValidAttributes = defaultMemoize((productTypes) => {
+  const allAttributes = {};
+  productTypes.forEach((productType) => {
+    productType.attributes.forEach((attribute) => {
+      if (attribute.isSearchable && attribute.type.name !== 'nested') {
+        const attributeOfSameName = allAttributes[attribute.name];
+        // Attributes that are of the same name and are of type enum or set enum,
+        // should have their enum values merged, since we have cases where there
+        // are 2 or more productTypes having attributes with the same name
+        // and are missing values.
+        //
+        // example input:
+        // productTypes = [
+        //   {
+        //     attributes: [
+        //       {
+        //         name: 'enum-of-same-name',
+        //         type: {
+        //           name: 'enum',
+        //           values: [
+        //             { key: enum-1, label: enum-1 },
+        //             { key: enum-3, label: enum-3 },
+        //             { key: enum-5, label: enum-5 },
+        //           ],
+        //         },
+        //       },
+        //     ],
+        //   },
+        //   {
+        //     attributes: [
+        //       {
+        //         name: 'enum-of-same-name',
+        //         type: {
+        //           name: 'enum',
+        //           values: [
+        //             { key: enum-2, label: enum-2 },
+        //             { key: enum-4, label: enum-4 },
+        //           ],
+        //         },
+        //       },
+        //     ],
+        //   },
+        // ]
+        //
+        // expected output:
+        // attributes = [
+        //   {
+        //     name: 'enum-of-same-name',
+        //     type: {
+        //       name: 'enum',
+        //       values: [
+        //         { key: enum-1, label: enum-1 },
+        //         { key: enum-2, label: enum-2 },
+        //         { key: enum-3, label: enum-3 },
+        //         { key: enum-4, label: enum-4 },
+        //         { key: enum-5, label: enum-5 },
+        //       ],
+        //     },
+        //   },
+        // ]
+        if (attributeOfSameName && getIsAttributeOfTypeEnum(attribute.type)) {
+          const mergedEnumValues = mergeEnumValues(
+            attributeOfSameName,
+            attribute
+          );
+          allAttributes[attribute.name] = updateEnumValuesOnAttribute(
+            attributeOfSameName,
+            sortBy(mergedEnumValues, 'key')
+          );
+        } else if (!attributeOfSameName)
+          allAttributes[attribute.name] = attribute;
+      }
+    });
+  });
+  return Object.values(allAttributes);
+});