@commercetools-frontend/experimental-components 0.0.2

package/src/utils/ariaset/ariaset.spec.js

@@ -0,0 +1,20 @@
+import { filterAriaAttributes } from './ariaset';
+
+describe('filterAriaAttributes', () => {
+  it('filters aria attributes', () => {
+    const ariaAttrs = {
+      'aria-one': 1,
+      'aria-three': 3,
+    };
+    const nonAriaAttrs = {
+      two: 2,
+      four: 4,
+    };
+    const ariaObject = {
+      ...ariaAttrs,
+      ...nonAriaAttrs,
+    };
+
+    expect(filterAriaAttributes(ariaObject)).toEqual(ariaAttrs);
+  });
+});

package/src/utils/ariaset/index.js

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

package/src/utils/array-helpers/array-helpers.js

@@ -0,0 +1,2 @@
+export const setToArray = (values = []) =>
+  `id in (${values.map((value) => `"${value}"`).join(', ')})`;

package/src/utils/array-helpers/index.js

@@ -0,0 +1 @@
+export * from './array-helpers';

package/src/utils/attributes/attributes.js

@@ -0,0 +1,38 @@
+/**
+ * @param mixed value
+ * @param String definitionName
+ * @return Boolean
+ */
+export function isEmptyValue(value, definitionName = '') {
+  if (typeof value === 'string') return !value.length;
+
+  if (isEmpty(value)) return true;
+
+  /* eslint-disable indent */
+  switch (definitionName) {
+    case 'enum':
+    case 'lenum':
+      return isEmpty(value.key) || isEmpty(value.label);
+    case 'money':
+      return isEmpty(value.centAmount) || isEmpty(value.currencyCode);
+    case 'reference':
+      return isEmpty(value.typeId) || isEmpty(value.id);
+    default:
+      return isEmpty(value);
+  }
+}
+
+/**
+ * Filter out the empty values of the attribute-set by its definition
+ *
+ * @param [] values
+ * @param String definitionName
+ * @return []
+ */
+export function filterEmptyValues(values = [], definitionName) {
+  return values.filter((value) => !isEmptyValue(value, definitionName));
+}
+
+function isEmpty(value) {
+  return value === undefined || value === null;
+}

package/src/utils/attributes/attributes.spec.js

@@ -0,0 +1,180 @@
+import { filterEmptyValues, isEmptyValue } from './attributes';
+
+describe('utility functions', () => {
+  describe('isEmptyValue', () => {
+    describe('empty values', () => {
+      it('should be considered empty with empty string and type "text"', () => {
+        expect(isEmptyValue('', 'text')).toBe(true);
+      });
+
+      it('should be considered empty for null / undefined / empty values when the type is "money"', () => {
+        expect(isEmptyValue(undefined, 'money')).toBe(true);
+        expect(isEmptyValue(null, 'money')).toBe(true);
+        expect(isEmptyValue({}, 'money')).toBe(true);
+      });
+
+      it('should be considered empty for undefined centAmount and type "money"', () => {
+        expect(
+          isEmptyValue({ centAmount: undefined, currencyCode: 'EU' }, 'money')
+        ).toBe(true);
+      });
+
+      it('should be considered empty for undefined currencyCode and type "money"', () => {
+        expect(
+          isEmptyValue({ centAmount: 0, currencyCode: undefined }, 'money')
+        ).toBe(true);
+      });
+
+      it('should be considered empty for null / undefined / empty values when the type is "reference"', () => {
+        expect(isEmptyValue(undefined, 'reference')).toBe(true);
+        expect(isEmptyValue(null, 'reference')).toBe(true);
+        expect(isEmptyValue({}, 'reference')).toBe(true);
+      });
+
+      it('should be considered empty for empty keys when the type is "reference"', () => {
+        expect(isEmptyValue({ typeId: null, id: null }, 'reference')).toBe(
+          true
+        );
+      });
+
+      it('should be considered empty for empty typeId when the type is "reference"', () => {
+        expect(isEmptyValue({ typeId: null, id: 1337 }, 'reference')).toBe(
+          true
+        );
+      });
+
+      it('should be considered empty for empty id when the the type is "reference"', () => {
+        expect(isEmptyValue({ typeId: 1337, id: null }, 'reference')).toBe(
+          true
+        );
+      });
+
+      it('should be considered empty for null / undefined / empty values when the type is "enum"', () => {
+        expect(isEmptyValue(undefined, 'enum')).toBe(true);
+        expect(isEmptyValue(null, 'enum')).toBe(true);
+        expect(isEmptyValue({}, 'enum')).toBe(true);
+      });
+
+      it('should be considered empty for empty keys when the type is "enum"', () => {
+        expect(isEmptyValue({ key: null, label: undefined }, 'enum')).toBe(
+          true
+        );
+      });
+
+      it('should be considered empty for empty label when the type is "enum"', () => {
+        expect(isEmptyValue({ key: 'xxx', label: null }, 'enum')).toBe(true);
+      });
+    });
+
+    describe('non-empty values', () => {
+      it('should consider not empty with type null', () => {
+        expect(isEmptyValue([], null)).toBe(false);
+        expect(isEmptyValue({}, null)).toBe(false);
+      });
+
+      it('should consider not empty when the type is "money" and the centAmount is 0', () => {
+        expect(
+          isEmptyValue({ centAmount: 0, currencyCode: 'EU' }, 'money')
+        ).toBe(false);
+      });
+
+      it('should consider not empty when the type is "reference" and the reference attributes are filled', () => {
+        expect(isEmptyValue({ typeId: 1337, id: 9999 }, 'reference')).toBe(
+          false
+        );
+      });
+
+      it('should consider not empty when the type is "enum" and the enum attributes are filled', () => {
+        expect(isEmptyValue({ key: 'xxx', label: {} }, 'enum')).toBe(false);
+      });
+    });
+  });
+
+  describe('filterEmptyValues', () => {
+    describe('type is "text"', () => {
+      const mockTextValues = ['not empty text', '', 'empty text?', null];
+      const filteredValues = filterEmptyValues(mockTextValues, null);
+
+      it('should have all values without null or empty strings', () => {
+        expect(filteredValues).toEqual(['not empty text', 'empty text?']);
+      });
+    });
+
+    describe('type is "enum"', () => {
+      const mockEnum = [
+        { key: null, label: undefined },
+        { key: 'xxx', label: {} },
+        { key: 'xxx', label: null },
+        null,
+        undefined,
+      ];
+
+      it('should have only one value in the set', () => {
+        const filteredValues = filterEmptyValues(mockEnum, 'enum');
+        expect(filteredValues).toEqual([{ key: 'xxx', label: {} }]);
+      });
+
+      it('should have all values without null or undefined', () => {
+        const filteredValuesNoDefinition = filterEmptyValues(mockEnum, null);
+        expect(filteredValuesNoDefinition).toEqual([
+          { key: null, label: undefined },
+          { key: 'xxx', label: {} },
+          { key: 'xxx', label: null },
+        ]);
+      });
+    });
+
+    describe('type is "money"', () => {
+      const mockMoney = [
+        { centAmount: undefined, currencyCode: 'EU' },
+        { centAmount: 0, currencyCode: undefined },
+        { centAmount: 0, currencyCode: 'EU' },
+        null,
+        undefined,
+      ];
+
+      it('should have only one value in the set', () => {
+        const filteredValues = filterEmptyValues(mockMoney, 'money');
+        expect(filteredValues).toEqual([{ centAmount: 0, currencyCode: 'EU' }]);
+      });
+
+      it('should have all values without null or undefined', () => {
+        const filteredValuesNoDefinition = filterEmptyValues(mockMoney, null);
+        expect(filteredValuesNoDefinition).toEqual([
+          { centAmount: undefined, currencyCode: 'EU' },
+          { centAmount: 0, currencyCode: undefined },
+          { centAmount: 0, currencyCode: 'EU' },
+        ]);
+      });
+    });
+
+    describe('type is "reference"', () => {
+      const mockReference = [
+        { typeId: null, id: null },
+        { typeId: null, id: 1337 },
+        { typeId: 1337, id: null },
+        { typeId: 1337, id: 9999 },
+        null,
+        undefined,
+      ];
+
+      it('should have only one value in the set', () => {
+        const filteredValues = filterEmptyValues(mockReference, 'reference');
+        expect(filteredValues).toEqual([{ typeId: 1337, id: 9999 }]);
+      });
+
+      it('should have all values without null or undefined', () => {
+        const filteredValuesNoDefinition = filterEmptyValues(
+          mockReference,
+          null
+        );
+        expect(filteredValuesNoDefinition).toEqual([
+          { typeId: null, id: null },
+          { typeId: null, id: 1337 },
+          { typeId: 1337, id: null },
+          { typeId: 1337, id: 9999 },
+        ]);
+      });
+    });
+  });
+});

package/src/utils/attributes/index.js

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

package/src/utils/build-search-query/build-search-query.js

@@ -0,0 +1,27 @@
+import oneLine from 'common-tags/lib/oneLine';
+
+const buildSearchQuery = (searchQuery, searchMode, fragments) => {
+  if (!searchQuery) return '';
+
+  const buildAllFieldsQueryString = (query) => {
+    const fragmentsArray = Object.values(fragments);
+    return `( ${fragmentsArray
+      .map((fragment) => fragment.getQuery(query))
+      .join(' or ')} )`;
+  };
+
+  const trimmedSearchQuery = oneLine(searchQuery);
+
+  if (searchMode === 'allFields') {
+    return buildAllFieldsQueryString(trimmedSearchQuery);
+  }
+  if (
+    !fragments[searchMode] ||
+    typeof fragments[searchMode]?.getQuery !== 'function'
+  ) {
+    return '';
+  }
+
+  return fragments[searchMode].getQuery(trimmedSearchQuery);
+};
+export default buildSearchQuery;

package/src/utils/build-search-query/build-search-query.spec.js

@@ -0,0 +1,129 @@
+import oneLine from 'common-tags/lib/oneLine';
+import { transformAllToProperNounCase } from '../../internal-index';
+import buildSearchQuery from './build-search-query';
+
+const applyTransformers = (value, transformers) =>
+  transformers.reduce((acc, curr) => {
+    if (typeof curr !== 'function') return acc;
+    return curr(acc);
+  }, value);
+
+const getAllCasesList = (value) =>
+  `("${value}", "${value.toLowerCase()}", "${transformAllToProperNounCase(
+    value
+  )}")`;
+
+const queryFragments = {
+  customerEmail: {
+    getQuery(searchString) {
+      return `customerEmail = "${searchString}"`;
+    },
+    transformers: [],
+  },
+  orderNumber: {
+    getQuery(searchString) {
+      return `orderNumber = "${searchString}"`;
+    },
+    transformers: [],
+  },
+  shippingAddressLastName: {
+    getQuery(searchString) {
+      return `shippingAddress(lastName in ${applyTransformers(
+        searchString,
+        this.transformers
+      )})`;
+    },
+    transformers: [getAllCasesList],
+  },
+  billingAddressLastName: {
+    getQuery(searchString) {
+      return `billingAddress(lastName in ${applyTransformers(
+        searchString,
+        this.transformers
+      )})`;
+    },
+    transformers: [getAllCasesList],
+  },
+  shippingAddressCity: {
+    getQuery(searchString) {
+      return `shippingAddress(city in ${applyTransformers(
+        searchString,
+        this.transformers
+      )})`;
+    },
+    transformers: [getAllCasesList],
+  },
+  billingAddressCity: {
+    getQuery(searchString) {
+      return `billingAddress(city in ${applyTransformers(
+        searchString,
+        this.transformers
+      )})`;
+    },
+    transformers: [getAllCasesList],
+  },
+  shippingAddressPostalCode: {
+    getQuery(searchString) {
+      return `shippingAddress(postalCode="${searchString}")`;
+    },
+  },
+  billingAddressPostalCode: {
+    getQuery(searchString) {
+      return `billingAddress(postalCode="${searchString}")`;
+    },
+    transformers: [],
+  },
+  lineItemsVariantsSKU: {
+    getQuery(searchString) {
+      return `lineItems(variant(sku="${searchString}"))`;
+    },
+    transformers: [],
+  },
+};
+
+describe('buildSearchQuery', () => {
+  describe('when searchMode is provided', () => {
+    it('should build a query only for the order number', () => {
+      expect(
+        buildSearchQuery('test-order-number', 'orderNumber', queryFragments)
+      ).toEqual(`orderNumber = "test-order-number"`);
+    });
+  });
+  describe('when all fields should be queried', () => {
+    it('should build a query for all fields', () => {
+      expect(buildSearchQuery('fooBar', 'allFields', queryFragments)).toEqual(
+        oneLine`(
+            customerEmail = "fooBar"
+             or orderNumber = "fooBar"
+             or shippingAddress(lastName in ("fooBar", "foobar", "Foobar"))
+             or billingAddress(lastName in ("fooBar", "foobar", "Foobar"))
+             or shippingAddress(city in ("fooBar", "foobar", "Foobar"))
+             or billingAddress(city in ("fooBar", "foobar", "Foobar"))
+             or shippingAddress(postalCode="fooBar")
+             or billingAddress(postalCode="fooBar")
+             or lineItems(variant(sku="fooBar"))
+          )`
+      );
+    });
+  });
+
+  describe('when searchText is a string value (untrimmed)', () => {
+    it('should return correctly formatted and trimmed query', () => {
+      expect(
+        buildSearchQuery(' fooBar  ', 'allFields', queryFragments)
+      ).toEqual(
+        oneLine`(
+            customerEmail = "fooBar"
+             or orderNumber = "fooBar"
+             or shippingAddress(lastName in ("fooBar", "foobar", "Foobar"))
+             or billingAddress(lastName in ("fooBar", "foobar", "Foobar"))
+             or shippingAddress(city in ("fooBar", "foobar", "Foobar"))
+             or billingAddress(city in ("fooBar", "foobar", "Foobar"))
+             or shippingAddress(postalCode="fooBar")
+             or billingAddress(postalCode="fooBar")
+             or lineItems(variant(sku="fooBar"))
+          )`
+      );
+    });
+  });
+});

package/src/utils/build-search-query/index.js

@@ -0,0 +1 @@
+export { default } from './build-search-query';

package/src/utils/bulk-notifications/get-bulk-notification.js

@@ -0,0 +1,34 @@
+import { DOMAINS } from '@commercetools-frontend/constants';
+
+export const getBulkNotification = ({ counts, texts }) => {
+  if (counts.successful === 0)
+    return {
+      kind: 'error',
+      domain: DOMAINS.SIDE,
+      text: texts.failure,
+    };
+
+  if (counts.failed === 0)
+    return {
+      kind: 'success',
+      domain: DOMAINS.SIDE,
+      text: texts.success,
+    };
+
+  return {
+    kind: 'warning',
+    domain: DOMAINS.SIDE,
+    text: texts.warning,
+  };
+};
+
+export const getCountsFromBulkSummary = (bulkSummary) => {
+  const total = bulkSummary.length;
+  const successful = bulkSummary.filter((item) => item.success).length;
+  const failed = total - successful;
+  return {
+    successful,
+    total,
+    failed,
+  };
+};

package/src/utils/bulk-notifications/get-bulk-notification.spec.js

@@ -0,0 +1,142 @@
+import { DOMAINS } from '@commercetools-frontend/constants';
+import {
+  getBulkNotification,
+  getCountsFromBulkSummary,
+} from './get-bulk-notification';
+
+const createTexts = () => ({
+  failure: 'textForFailure',
+  success: 'textForSuccess',
+  warning: 'textForWarning',
+});
+
+describe('getBulkNotification', () => {
+  describe('with no successful counts', () => {
+    let notification;
+
+    beforeEach(() => {
+      notification = getBulkNotification({
+        texts: createTexts(),
+        counts: { successful: 0 },
+      });
+    });
+
+    it('should return an `kind` error notification', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          kind: 'error',
+        })
+      );
+    });
+
+    it('should return an `DOMAIN` side notification', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          domain: DOMAINS.SIDE,
+        })
+      );
+    });
+
+    it('should return an `text` for `failure`', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          text: 'textForFailure',
+        })
+      );
+    });
+  });
+
+  describe('with no failed counts', () => {
+    let notification;
+
+    beforeEach(() => {
+      notification = getBulkNotification({
+        texts: createTexts(),
+        counts: { failed: 0 },
+      });
+    });
+
+    it('should return an `kind` success notification', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          kind: 'success',
+        })
+      );
+    });
+
+    it('should return an `DOMAIN` side notification', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          domain: DOMAINS.SIDE,
+        })
+      );
+    });
+
+    it('should return an `text` for `failure`', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          text: 'textForSuccess',
+        })
+      );
+    });
+  });
+
+  describe('with both failed and success counts', () => {
+    let notification;
+
+    beforeEach(() => {
+      notification = getBulkNotification({
+        texts: createTexts(),
+        counts: { failed: 1, success: 2 },
+      });
+    });
+
+    it('should return an `kind` warning notification', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          kind: 'warning',
+        })
+      );
+    });
+
+    it('should return an `DOMAIN` side notification', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          domain: DOMAINS.SIDE,
+        })
+      );
+    });
+
+    it('should return an `text` for `failure`', () => {
+      expect(notification).toEqual(
+        expect.objectContaining({
+          text: 'textForWarning',
+        })
+      );
+    });
+  });
+});
+
+describe('getCountsFromBulkSummary', () => {
+  let counts;
+
+  beforeEach(() => {
+    counts = getCountsFromBulkSummary([
+      { success: true },
+      { success: true },
+      { success: false },
+    ]);
+  });
+
+  it('should return the total of all counts', () => {
+    expect(counts.total).toBe(3);
+  });
+
+  it('should return the failed counts', () => {
+    expect(counts.failed).toBe(1);
+  });
+
+  it('should return the succesful counts', () => {
+    expect(counts.successful).toBe(2);
+  });
+});

package/src/utils/bulk-notifications/index.js

@@ -0,0 +1,4 @@
+export {
+  getBulkNotification,
+  getCountsFromBulkSummary,
+} from './get-bulk-notification';

package/src/utils/business-roles/business-roles.js

@@ -0,0 +1,24 @@
+// Keys have to match enum values on core ws
+// https://github.com/sphereio/sphere-backend/blob/master/ws/core/users.md#-businessrole
+const businessRoleKeys = [
+  'ExecutiveManagement',
+  'BusinessIntelligence',
+  'BuyingPlanningAndInventoryManagement',
+  'DataQualityAndContentManagement',
+  'CustomerService',
+  'FinanceAndAccounting',
+  'LegalAndPeople',
+  'LogisticsAndSupplyChain',
+  'FulfillmentAndOperationsManagement',
+  'OfflineRetailStore',
+  'Marketing',
+  'BusinessDevSalesAndAccountManagement',
+  'UXUIDesign',
+  'TechProductManagement',
+  'TechProjectAndProgramManagement',
+  'SoftwareDevelopmentAndSolutionsArchitect',
+  'OperationsITAndSupportEngineering',
+  'Other',
+];
+
+export default businessRoleKeys;

package/src/utils/business-roles/index.js

@@ -0,0 +1,4 @@
+import businessRoles from './business-roles';
+import messages from './messages';
+
+export { businessRoles, messages };