@commercetools-frontend/experimental-components 0.0.2

package/src/utils/filters/graphql/number/number.spec.js

@@ -0,0 +1,65 @@
+import numberTransformer from './number';
+
+const filterKey = 'level';
+
+describe('number query builder', () => {
+  it('should correctly build a single, "equalTo" query', () => {
+    const queries = [{ type: 'equalTo', value: 6 }];
+    const result = numberTransformer(filterKey, queries);
+
+    const expected = `${filterKey}: range(6 to 6)`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "lessThan" query', () => {
+    const queries = [{ type: 'lessThan', value: 6 }];
+    const result = numberTransformer(filterKey, queries);
+
+    const expected = `${filterKey}: range(* to 5)`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "moreThan" query', () => {
+    const queries = [{ type: 'moreThan', value: 6 }];
+    const result = numberTransformer(filterKey, queries);
+
+    const expected = `${filterKey}: range(7 to *)`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "range" query', () => {
+    const queries = [
+      {
+        type: 'range',
+        value: { from: 2, to: 4 },
+      },
+    ];
+    const result = numberTransformer(filterKey, queries);
+
+    const expected = `${filterKey}: range(2 to 4)`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a mix of queries', () => {
+    const queries = [
+      { type: 'equalTo', value: 1 },
+      { type: 'lessThan', value: 2 },
+      { type: 'moreThan', value: 3 },
+      {
+        type: 'range',
+        value: { from: 6, to: 7 },
+      },
+    ];
+    const result = numberTransformer(filterKey, queries);
+
+    const expected = `${filterKey}: range(1 to 1), (* to 1), (4 to *), (6 to 7)`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should return null for invalid filters', () => {
+    const queries = [{ type: 'equalTo', value: 'something invalid' }];
+    const result = numberTransformer(filterKey, queries, () => false);
+
+    expect(result).toBe(null);
+  });
+});

package/src/utils/filters/graphql/reference/index.js

@@ -0,0 +1 @@
+export { default } from './reference';

package/src/utils/filters/graphql/reference/reference.js

@@ -0,0 +1,26 @@
+export default function referenceTransformer(
+  filterKey,
+  filters,
+  filterValidator = isFilterValid
+) {
+  const queries = filters.map(({ type, value }) => {
+    if (!filterValidator({ type, value })) return '';
+
+    switch (type) {
+      case 'equalTo':
+        return `"${value}"`;
+      default:
+        return '';
+    }
+  });
+
+  const queryString = queries.filter((q) => q !== '').join(', ');
+
+  return queryString === '' ? null : `${filterKey}.id: ${queryString}`;
+}
+
+export function isFilterValid({ type, value }) {
+  if (type === 'equalTo' && ![null, undefined, ''].includes(value)) return true;
+
+  return false;
+}

package/src/utils/filters/graphql/reference/reference.spec.js

@@ -0,0 +1,20 @@
+import referenceTransformer from './reference';
+
+const filterKey = 'parent';
+
+describe('reference query builder', () => {
+  it('should correctly build a single, "equalTo" query', () => {
+    const queries = [{ type: 'equalTo', value: 'something' }];
+    const result = referenceTransformer(filterKey, queries);
+
+    const expected = `${filterKey}.id: "something"`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should return null for invalid filters', () => {
+    const queries = [{ type: 'equalTo', value: 'something invalid' }];
+    const result = referenceTransformer(filterKey, queries, () => false);
+
+    expect(result).toBe(null);
+  });
+});

package/src/utils/filters/graphql/text/index.js

@@ -0,0 +1 @@
+export { default } from './text';

package/src/utils/filters/graphql/text/text.js

@@ -0,0 +1,8 @@
+export default function textTransformer(filterKey, queries) {
+  if (queries.length === 0) return null;
+
+  // Note: we assume for now that there can only be 1 text filter.
+  const queryValue = queries[0].value;
+
+  return queryValue ? `${filterKey}:"${queryValue}"` : null;
+}

package/src/utils/filters/graphql/text/text.spec.js

@@ -0,0 +1,35 @@
+import textTransformer from './text';
+
+const filterKey = 'productTypeNames';
+
+describe('text query builder', () => {
+  describe('with `queries`', () => {
+    let queries;
+    let expected;
+
+    beforeEach(() => {
+      queries = [{ type: 'text', value: 'foo' }];
+      expected = `${filterKey}:"${queries[0].value}"`;
+    });
+
+    it('should build with `key` and `value`', () => {
+      expect(textTransformer(filterKey, queries)).toEqual(expected);
+    });
+
+    describe('without `value`', () => {
+      beforeEach(() => {
+        queries = [{ type: 'text', value: null }];
+      });
+
+      it('return `null`', () => {
+        expect(textTransformer(filterKey, [])).toBe(null);
+      });
+    });
+  });
+
+  describe('without `queries`', () => {
+    it('return `null`', () => {
+      expect(textTransformer(filterKey, [])).toBe(null);
+    });
+  });
+});

package/src/utils/filters/is-date/index.js

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

package/src/utils/filters/is-date/is-date.js

@@ -0,0 +1,17 @@
+import moment from 'moment';
+
+export function isValidISOTime({ value = '', strict = true }) {
+  return moment(value.trim(), 'HH:mm:ss.SSS', strict).isValid();
+}
+
+export function isValidISODate({ value = '', strict = true }) {
+  return moment(value.trim(), 'YYYY-MM-DD', strict).isValid();
+}
+
+export function isValidISODateTime({ value = '', strict = true }) {
+  const trimmedValue = value.trim();
+  return (
+    moment(trimmedValue, 'YYYY-MM-DDTHH:mm:ss.SSSZ', strict).isValid() ||
+    moment(trimmedValue, 'YYYY-MM-DDTHH:mm:ss.SSS', strict).isValid()
+  );
+}

package/src/utils/filters/is-date/is-date.spec.js

@@ -0,0 +1,73 @@
+import { isValidISOTime, isValidISODate, isValidISODateTime } from './is-date';
+
+describe('is date', () => {
+  describe('isValidISOTime', () => {
+    describe('when strict flag enabled', () => {
+      it('should return true when valid ISO time format and delimiters', () => {
+        expect(isValidISOTime({ value: '13:00:00.123' })).toBe(true);
+      });
+      it('should return false when invalid ISO time format', () => {
+        expect(isValidISOTime({ value: '13:0:0.123' })).toBe(false);
+      });
+      it('should return false when non-strict valid ISO time format', () => {
+        expect(isValidISOTime({ value: 'Time 13:00:00.123' })).toBe(false);
+      });
+    });
+    describe('when strict flag disabled', () => {
+      it('should return true when non strict valid ISO time format', () => {
+        expect(
+          isValidISOTime({ value: 'Time 13:00:00.123', strict: false })
+        ).toBe(true);
+      });
+    });
+  });
+  describe('isValidISODate', () => {
+    describe('when strict flag enabled', () => {
+      it('should return true when valid ISO date format and delimiters', () => {
+        expect(isValidISODate({ value: '2017-06-30' })).toBe(true);
+      });
+      it('should return false when invalid ISO date format', () => {
+        expect(isValidISODate({ value: '2017-6-30' })).toBe(false);
+      });
+      it('should return false when non-strict valid ISO date format', () => {
+        expect(isValidISODate({ value: 'Date 2017-06-30' })).toBe(false);
+      });
+    });
+    describe('when strict flag disabled', () => {
+      it('should return true when non strict valid ISO date format', () => {
+        expect(
+          isValidISODate({ value: 'Date 2017-06-30', strict: false })
+        ).toBe(true);
+      });
+    });
+  });
+  describe('isValidISODateTime', () => {
+    describe('when strict flag enabled', () => {
+      it('should return true when valid ISO datetime format and delimiters', () => {
+        expect(isValidISODateTime({ value: '2017-06-30T13:00:00.123Z' })).toBe(
+          true
+        );
+      });
+      it('should return false when invalid ISO datetime format', () => {
+        expect(isValidISODateTime({ value: '2017-6-30T13:00:00.123Z' })).toBe(
+          false
+        );
+      });
+      it('should return false when non-strict valid ISO datetime format', () => {
+        expect(
+          isValidISODateTime({ value: 'Datetime 2017-06-30T13:00:00.123Z' })
+        ).toBe(false);
+      });
+    });
+    describe('when strict flag disabled', () => {
+      it('should return true when non strict valid ISO datetime format', () => {
+        expect(
+          isValidISODateTime({
+            value: 'Datetime 2017-06-30T13:00:00.123Z',
+            strict: false,
+          })
+        ).toBe(true);
+      });
+    });
+  });
+});

package/src/utils/filters/is-empty/index.js

@@ -0,0 +1 @@
+export { default } from './is-empty';

package/src/utils/filters/is-empty/is-empty.js

@@ -0,0 +1,9 @@
+import { FILTER_TYPES } from '../../constants';
+import isEmptyRange from './range';
+import isEmptySingle from './single';
+
+export default function isEmptyFilter({ type, value }) {
+  if (type === FILTER_TYPES.range) return isEmptyRange({ value });
+
+  return isEmptySingle({ value });
+}

package/src/utils/filters/is-empty/is-empty.spec.js

@@ -0,0 +1,20 @@
+import isEmptyFilter from './is-empty';
+
+jest.mock('./single', () => jest.fn(() => '__single_return_value__'));
+jest.mock('./range', () => jest.fn(() => '__range_return_value__'));
+
+describe('isEmptyFilter', () => {
+  describe('without `type`', () => {
+    describe('with `value`', () => {
+      it('should invoke single validator (as standard validator)', () => {
+        expect(isEmptyFilter({ value: 1 })).toBe('__single_return_value__');
+      });
+    });
+  });
+
+  describe('with `range` type', () => {
+    it('should invoke range validator', () => {
+      expect(isEmptyFilter({ type: 'range' })).toBe('__range_return_value__');
+    });
+  });
+});

package/src/utils/filters/is-empty/range/index.js

@@ -0,0 +1 @@
+export { default } from './range';

package/src/utils/filters/is-empty/range/range.js

@@ -0,0 +1,8 @@
+const invalidValues = [null, undefined, ''];
+
+export default function isEmpty({ value }) {
+  return (
+    invalidValues.includes(value) ||
+    (invalidValues.includes(value.from) && invalidValues.includes(value.to))
+  );
+}

package/src/utils/filters/is-empty/range/range.spec.js

@@ -0,0 +1,22 @@
+import isEmpty from './range';
+
+describe('range filter validator', () => {
+  it('should return true for an "undefined" filter', () => {
+    expect(isEmpty({})).toEqual(true);
+  });
+  it('should return true for an "null" filter', () => {
+    expect(isEmpty({ value: null })).toEqual(true);
+  });
+  it('should return false when from === null', () => {
+    const filter = { value: { from: null, to: 'nice' } };
+    expect(isEmpty(filter)).toEqual(false);
+  });
+  it('should return false when to === null', () => {
+    const filter = { value: { from: 'nice', to: null } };
+    expect(isEmpty(filter)).toEqual(false);
+  });
+  it('should return false for a valid filter', () => {
+    const filter = { value: { from: 'nice', to: 'nicer' } };
+    expect(isEmpty(filter)).toEqual(false);
+  });
+});

package/src/utils/filters/is-empty/single/index.js

@@ -0,0 +1 @@
+export { default } from './single';

package/src/utils/filters/is-empty/single/single.js

@@ -0,0 +1,5 @@
+const invalidValues = [null, undefined, ''];
+
+export default function validateSingleFilter({ value }) {
+  return invalidValues.includes(value);
+}

package/src/utils/filters/is-empty/single/single.spec.js

@@ -0,0 +1,17 @@
+import validateSingleFilter from './single';
+
+describe('single filter validator', () => {
+  it('should return true for an "undefined" filter', () => {
+    expect(validateSingleFilter({})).toBe(true);
+  });
+  it('should return true for a "null" filter', () => {
+    expect(validateSingleFilter({ value: null })).toBe(true);
+  });
+  it('should return true for an empty string', () => {
+    expect(validateSingleFilter({ value: '' })).toBe(true);
+  });
+  it('should return false for a valid filter', () => {
+    const filter = { value: 'nice' };
+    expect(validateSingleFilter(filter)).toBe(false);
+  });
+});

package/src/utils/filters/localized-string/index.js

@@ -0,0 +1 @@
+export { default } from './localized-string';

package/src/utils/filters/localized-string/localized-string.js

@@ -0,0 +1,4 @@
+export default (localizedString) =>
+  Object.keys(localizedString)
+    .map((locale) => `${locale} = "${localizedString[locale]}"`)
+    .join(' and ');

package/src/utils/filters/localized-string/localized-string.spec.js

@@ -0,0 +1,26 @@
+import localizedTextTransformer from './localized-string';
+
+const simpleValue = {
+  en: 'test',
+};
+
+const multipleValue = {
+  en: 'test',
+  es: 'prueba',
+};
+
+describe('localized string query builder', () => {
+  let result;
+  let expected;
+  it('should correctly build a single value query', () => {
+    expected = 'en = "test"';
+    result = localizedTextTransformer(simpleValue);
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a multiple value query', () => {
+    expected = 'en = "test" and es = "prueba"';
+    result = localizedTextTransformer(multipleValue);
+    expect(result).toEqual(expected);
+  });
+});

package/src/utils/filters/money/index.js

@@ -0,0 +1 @@
+export { default } from './money';

package/src/utils/filters/money/money.js

@@ -0,0 +1,36 @@
+import { MoneyInput } from '@commercetools-frontend/ui-kit';
+import { FILTER_TYPES } from '../../constants';
+
+const getCentAmountClause = (value, operator, locale) =>
+  `centAmount ${operator} ${
+    MoneyInput.convertToMoneyValue(value, locale).centAmount
+  }`;
+
+export default function moneyTransformer(value, option, locale) {
+  const clauses = [];
+
+  if (option === FILTER_TYPES.range) {
+    clauses[0] = `currencyCode = "${value.from.currencyCode}"`;
+    clauses[1] = getCentAmountClause(value.from, '>=', locale);
+    clauses[2] = getCentAmountClause(value.to, '<=', locale);
+
+    return clauses.join(' and ');
+  }
+
+  clauses[0] = `currencyCode = "${value.currencyCode}"`;
+  switch (option) {
+    case FILTER_TYPES.lessThan:
+      clauses[1] = getCentAmountClause(value, '<', locale);
+      break;
+    case FILTER_TYPES.moreThan:
+      clauses[1] = getCentAmountClause(value, '>', locale);
+      break;
+    case FILTER_TYPES.equalTo:
+      clauses[1] = getCentAmountClause(value, '=', locale);
+      break;
+    default:
+      return '';
+  }
+
+  return clauses.join(' and ');
+}

package/src/utils/filters/money/money.spec.js

@@ -0,0 +1,55 @@
+import { FILTER_TYPES } from '../../constants';
+import moneyTransformer from './money';
+
+const simpleFilterValue = {
+  currencyCode: 'EUR',
+  amount: '200,00',
+};
+
+const rangeFilterValue = {
+  from: {
+    currencyCode: 'EUR',
+    amount: '200,00',
+  },
+  to: {
+    currencyCode: 'EUR',
+    amount: '400,00',
+  },
+};
+
+describe('money query builder', () => {
+  let option;
+  let result;
+  let expected;
+  it('should correctly build a single, "lessThan" query', () => {
+    option = FILTER_TYPES.lessThan;
+    result = moneyTransformer(simpleFilterValue, option);
+
+    expected = `currencyCode = "EUR" and centAmount < 20000`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "moreThan" query', () => {
+    option = FILTER_TYPES.moreThan;
+    result = moneyTransformer(simpleFilterValue, option);
+
+    expected = `currencyCode = "EUR" and centAmount > 20000`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "equalTo" query', () => {
+    option = FILTER_TYPES.equalTo;
+    result = moneyTransformer(simpleFilterValue, option);
+
+    expected = `currencyCode = "EUR" and centAmount = 20000`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "range" query', () => {
+    option = FILTER_TYPES.range;
+    result = moneyTransformer(rangeFilterValue, option);
+
+    expected = `currencyCode = "EUR" and centAmount >= 20000 and centAmount <= 40000`;
+    expect(result).toEqual(expected);
+  });
+});

package/src/utils/filters/time/index.js

@@ -0,0 +1 @@
+export { default } from './time';

package/src/utils/filters/time/time.js

@@ -0,0 +1,65 @@
+import moment from 'moment';
+import oneLine from 'common-tags/lib/oneLine';
+import { FILTER_TYPES } from '../../constants';
+import rangeIsEmpty from '../is-empty/range';
+import singleIsEmpty from '../is-empty/single';
+
+const formatTime = 'HH:mm:ss.SSS';
+
+/* TimeInput only allows HH:mm:ss and adds the seconds as 00 and
+ * the milliseconds always as 000.
+ * This function returns the same time with the
+ */
+const getEndOfSecond = (value) =>
+  moment(value, formatTime).endOf('minute').format(formatTime);
+
+const defaultFilterValidator = ({ type, value }) => {
+  if (type !== FILTER_TYPES.range && singleIsEmpty({ value })) return false;
+
+  if (type === FILTER_TYPES.range && rangeIsEmpty({ value })) return false;
+
+  return true;
+};
+
+const timeTransformer = (
+  filterKey,
+  filters,
+  filterValidator = defaultFilterValidator
+) => {
+  const queries = filters.map(({ type, value }) => {
+    if (!filterValidator({ type, value })) return '';
+
+    switch (type) {
+      case FILTER_TYPES.lessThan:
+        return `${filterKey} < "${value}"`;
+      case FILTER_TYPES.moreThan:
+        return `${filterKey} > "${value}"`;
+      case FILTER_TYPES.equalTo:
+        return oneLine`
+          (${filterKey} >= "${value}"
+          and ${filterKey} <= "${getEndOfSecond(value)}")
+          `;
+      case FILTER_TYPES.range:
+        return oneLine`
+          (${filterKey} >= "${value.from}"
+          and ${filterKey} <= "${getEndOfSecond(value.to)}")
+          `;
+      default:
+        return '';
+    }
+  });
+
+  // The separator is and `or` as they are the same filter
+  const queryString = queries.filter((q) => q !== '').join(' or ');
+
+  /* The parenthesis involing the `queryString` are needed since they are all part of the
+   * same filter so we need something to work with
+   * (
+   *  (pickUpTime >= "12:00" and pickUpTime <= "13:00") o
+   *  (pickUpTime >= "14:00" and pickUpTime <= "15:00")
+   * ) or some_more_filters
+   */
+  return queryString === '' ? null : `(${queryString})`;
+};
+
+export { timeTransformer as default, getEndOfSecond, defaultFilterValidator };

package/src/utils/filters/time/time.spec.js

@@ -0,0 +1,96 @@
+import oneLine from 'common-tags/lib/oneLine';
+import timeTransformer, { defaultFilterValidator } from './time';
+
+const filterKey = 'pickUpTime';
+
+describe('date query builder', () => {
+  it('should correctly build a single, "equalTo" query', () => {
+    const queries = [{ type: 'equalTo', value: '12:00:00.000' }];
+    const result = timeTransformer(filterKey, queries);
+
+    const expected = `((${filterKey} >= "12:00:00.000" and ${filterKey} <= "12:00:59.999"))`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "lessThan" query', () => {
+    const queries = [{ type: 'lessThan', value: '12:00:00.000' }];
+    const result = timeTransformer(filterKey, queries);
+
+    const expected = `(${filterKey} < "12:00:00.000")`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "moreThan" query', () => {
+    const queries = [{ type: 'moreThan', value: '12:00:00.000' }];
+    const result = timeTransformer(filterKey, queries);
+
+    const expected = `(${filterKey} > "12:00:00.000")`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a single, "range" query', () => {
+    const queries = [
+      {
+        type: 'range',
+        value: { from: '12:00:00.000', to: '13:00:00.000' },
+      },
+    ];
+    const result = timeTransformer(filterKey, queries);
+
+    const expected = `((${filterKey} >= "12:00:00.000" and ${filterKey} <= "13:00:59.999"))`;
+    expect(result).toEqual(expected);
+  });
+
+  it('should correctly build a mix of queries', () => {
+    const queries = [
+      { type: 'equalTo', value: '12:00:00.000' },
+      { type: 'lessThan', value: '12:00:00.000' },
+      { type: 'moreThan', value: '12:00:00.000' },
+      {
+        type: 'range',
+        value: { from: '12:00:00.000', to: '13:00:00.000' },
+      },
+    ];
+    const result = timeTransformer(filterKey, queries);
+
+    const expected = oneLine`
+      ((${filterKey} >= "12:00:00.000" and ${filterKey} <= "12:00:59.999") or
+      ${filterKey} < "12:00:00.000" or ${filterKey} > "12:00:00.000" or
+      (${filterKey} >= "12:00:00.000" and ${filterKey} <= "13:00:59.999"))
+    `;
+
+    expect(result).toEqual(expected);
+  });
+
+  it('should return null for invalid filters', () => {
+    const queries = [{ type: 'equalTo', value: 'something invalid' }];
+    const result = timeTransformer(filterKey, queries, () => false);
+
+    expect(result).toBe(null);
+  });
+});
+
+describe('defaultFilterValidator', () => {
+  it('should detect an invalid non-range filter', () => {
+    const filter = { type: 'non-range', value: '' };
+    expect(defaultFilterValidator(filter)).toBe(false);
+  });
+  it('should detect an invalid range filter', () => {
+    const filter = { type: 'range', value: '' };
+    expect(defaultFilterValidator(filter)).toBe(false);
+  });
+  it('should allow a valid non-range filter', () => {
+    const filter = { type: 'non-range', value: '2000-01-01' };
+    expect(defaultFilterValidator(filter)).toBe(true);
+  });
+  it('should allow a valid range filter', () => {
+    const filter = {
+      type: 'non-range',
+      value: {
+        from: '2003-01-01',
+        to: '2004-01-01',
+      },
+    };
+    expect(defaultFilterValidator(filter)).toBe(true);
+  });
+});