@commercetools-frontend/experimental-components 0.0.2 → 0.1.0

package/src/utils/encodings/encodings.spec.js

@@ -1,21 +0,0 @@
-import { stringToBase64, base64ToString } from './encodings';
-
-describe('stringToBase64', () => {
-  it('encodes string to base 64', () => {
-    expect(stringToBase64('foo')).toBe('Zm9v');
-  });
-
-  it('decodes base 64 string to string', () => {
-    expect(base64ToString('Zm9v')).toBe('foo');
-  });
-});
-
-describe('base64ToString', () => {
-  it('returns undefined when malformed string', () => {
-    expect(base64ToString('9v')).toBeUndefined();
-  });
-
-  it('returns undefined when string is not properly encoded', () => {
-    expect(base64ToString('a%AFc')).toBeUndefined();
-  });
-});

package/src/utils/encodings/index.js

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

package/src/utils/filters/README.md

@@ -1,56 +0,0 @@
-# Processing Filters
-
-This set of utilities are used to convert objects that describe filters into
-string filters suitable for graphql endpoints, REST endpoints, etc. They are
-split into 2 levels of processing
-
-## API Reference
-
-### `graphqlQueryBuilder(options)`
-
-This is the main method used to build _filters_ for graphql.
-
-#### Named arguments (options)
-
-- `config` _(Object)_: a configuration object describing the how the filter
-  should be transformed into a query
-
-```js
-const filterConfig = {
-  // The identifier of the filter
-  createdOn: {
-    // The key used in the actual query
-    key: 'createdAt',
-    // A function that builds the query string for the given filter type.
-    // It accepts 2 arguments:
-    // - key: the key defined in the config above
-    // - values: the list of values for the given filter. A value consists in `{ type, value }`
-    // Returns a string.
-    transform: (key, values) => `${key}: ${values.map(...)}`,
-  },
-  missingExternalId: {
-    key: 'externalId',
-    transform: (key/* , values */) => `${key}:missing`,
-  },
-}
-```
-
-- `filters` _(Object)_: an object with all the given filter values
-
-```js
-const filters = {
-  // The identifier of the filter
-  createdOn: [
-    { type: 'equalTo', value: '2016-07-01' },
-    { type: 'range', value: { from: '2016-01-01', to: '2016-02-01' } },
-  ],
-  missingExternalId: [{ type: 'missing', value: null }],
-};
-```
-
-## Available filter transformers
-
-- `dateTransformer`
-- `numberTransformer`
-- `missingTransformer`
-- `missingLocaleTransformer`

package/src/utils/filters/custom-fields/custom-fields.js

@@ -1,56 +0,0 @@
-import {
-  dateTransformer,
-  timeTransformer,
-  moneyTransformer,
-  localizedTextTransformer,
-} from '../../../internal-index';
-
-import { FILTER_TYPES, FIELD_TYPES } from '../../constants';
-
-const composeNumberPredicateFromFilter = (target, value, option) => {
-  switch (option) {
-    case FILTER_TYPES.lessThan:
-      return `${target} < ${value}`;
-    case FILTER_TYPES.moreThan:
-      return `${target} > ${value}`;
-    case FILTER_TYPES.equalTo:
-      return `${target} = ${value}`;
-    case FILTER_TYPES.range:
-      return `${target} >= ${value.from} and ${target} <= ${value.to}`;
-    default:
-      return '';
-  }
-};
-
-export default function (filter, locale) {
-  const customFieldsPredicates = filter.map((customFieldFilter) => {
-    const { target, type, value, option } = customFieldFilter.value;
-
-    switch (type.name) {
-      case FIELD_TYPES.Boolean:
-        return `${target} = ${value.value}`;
-      case FIELD_TYPES.String:
-        return `${target} = "${value}"`;
-      case FIELD_TYPES.LocalizedString:
-        return `${target}(${localizedTextTransformer(value)})`;
-      case FIELD_TYPES.Enum:
-      case FIELD_TYPES.LocalizedEnum:
-        return `${target} = "${value.value}"`;
-      case FIELD_TYPES.Time:
-        return timeTransformer(target, [{ type: option, value }]);
-      case FIELD_TYPES.DateTime:
-      case FIELD_TYPES.Date:
-        return dateTransformer(target, [{ type: option, value }]);
-      case FIELD_TYPES.Number:
-        return composeNumberPredicateFromFilter(target, value, option);
-      case FIELD_TYPES.Money:
-        return `${target}(${moneyTransformer(value, option, locale)})`;
-      case FIELD_TYPES.Reference:
-      case FIELD_TYPES.Set:
-      default:
-        throw new Error('Custom field type not recognized');
-    }
-  });
-
-  return `(custom(fields(${customFieldsPredicates.join(' and ')})))`;
-}

package/src/utils/filters/custom-fields/custom-fields.spec.js

@@ -1,328 +0,0 @@
-import moment from 'moment';
-import customFieldsTransformer from './custom-fields';
-import { FILTER_TYPES, FIELD_TYPES } from '../../constants';
-
-const queryDateFormat = 'YYYY-MM-DDTHH:mm:ss.SSS';
-const dateFormat = 'YYYY-MM-DDTHH:mm:ss.SSS';
-const dateTimeFormat = 'YYYY-MM-DDTHH:mm:ss.SSS';
-const timeFormat = 'HH:mm:ss.SSS';
-
-const testTime = moment();
-const todayDate = moment(testTime).format(dateFormat);
-const tomorrowDate = moment(testTime).add(1, 'days').format(dateFormat);
-const todayDateTime = moment(testTime).format(dateTimeFormat);
-const tomorrowDateTime = moment(testTime).add(1, 'days').format(dateTimeFormat);
-const nowTime = moment(testTime).startOf('minute').format(timeFormat);
-const laterTime = moment(testTime)
-  .add(1, 'hour')
-  .startOf('minute')
-  .format(timeFormat);
-
-const customFieldDefinitions = {
-  BooleanField: {
-    target: 'booleanField',
-    value: { value: 'true' },
-    type: { name: FIELD_TYPES.Boolean },
-  },
-  StringField: {
-    target: 'stringField',
-    value: 'someText',
-    type: { name: FIELD_TYPES.String },
-  },
-  LocalizedStringField: {
-    target: 'localizedStringField',
-    value: { en: 'someText' },
-    type: { name: FIELD_TYPES.LocalizedString },
-  },
-  EnumField: {
-    target: 'enumField',
-    value: { value: 'someEnumKey' },
-    type: { name: FIELD_TYPES.Enum },
-  },
-  LocalizedEnumField: {
-    target: 'localizedEnumField',
-    value: { value: 'someLocalizedEnumKey' },
-    type: { name: FIELD_TYPES.LocalizedEnum },
-  },
-  NumberField: {
-    target: 'numberField',
-    value: 1000,
-    type: { name: FIELD_TYPES.Number },
-    option: FILTER_TYPES.lessThan,
-  },
-  NumberFieldRange: {
-    target: 'numberField',
-    value: { from: 1000, to: 2000 },
-    type: { name: FIELD_TYPES.Number },
-    option: FILTER_TYPES.range,
-  },
-  DateField: {
-    target: 'dateField',
-    value: todayDate,
-    type: { name: FIELD_TYPES.Date },
-    option: FILTER_TYPES.lessThan,
-  },
-  DateFieldRange: {
-    target: 'dateField',
-    value: {
-      from: todayDate,
-      to: tomorrowDate,
-    },
-    type: { name: FIELD_TYPES.Date },
-    option: FILTER_TYPES.range,
-  },
-  DateTimeField: {
-    target: 'dateTimeField',
-    value: todayDateTime,
-    type: { name: FIELD_TYPES.DateTime },
-    option: FILTER_TYPES.lessThan,
-  },
-  DateTimeFieldRange: {
-    target: 'dateTimeField',
-    value: {
-      from: todayDateTime,
-      to: tomorrowDateTime,
-    },
-    type: { name: FIELD_TYPES.DateTime },
-    option: FILTER_TYPES.range,
-  },
-  TimeField: {
-    target: 'timeField',
-    value: nowTime,
-    type: { name: FIELD_TYPES.Time },
-    option: FILTER_TYPES.lessThan,
-  },
-  TimeFieldRange: {
-    target: 'timeField',
-    value: {
-      from: nowTime,
-      to: laterTime,
-    },
-    type: { name: FIELD_TYPES.Time },
-    option: FILTER_TYPES.range,
-  },
-  MoneyField: {
-    target: 'moneyField',
-    value: { currencyCode: 'EUR', amount: '10' },
-    type: { name: FIELD_TYPES.Money },
-    option: FILTER_TYPES.lessThan,
-  },
-  MoneyFieldRange: {
-    target: 'moneyField',
-    value: {
-      from: { currencyCode: 'EUR', amount: '10' },
-      to: { currencyCode: 'EUR', amount: '20' },
-    },
-    type: { name: FIELD_TYPES.Money },
-    option: FILTER_TYPES.range,
-  },
-};
-
-describe('customFieldsTransformer', () => {
-  let result;
-  let expected;
-
-  describe('Boolean', () => {
-    const { BooleanField } = customFieldDefinitions;
-    beforeEach(() => {
-      result = customFieldsTransformer([{ value: BooleanField }]);
-      expected = '(custom(fields(booleanField = true)))';
-    });
-    it('should return a boolean predicate', () => {
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('String', () => {
-    const { StringField } = customFieldDefinitions;
-    beforeEach(() => {
-      result = customFieldsTransformer([{ value: StringField }]);
-      expected = `(custom(fields(stringField = "someText")))`;
-    });
-
-    it('should return a string predicate', () => {
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('LocalizedString', () => {
-    const { LocalizedStringField } = customFieldDefinitions;
-    beforeEach(() => {
-      result = customFieldsTransformer([{ value: LocalizedStringField }]);
-      expected = `(custom(fields(localizedStringField(en = "someText"))))`;
-    });
-
-    it('should return a localized string predicate', () => {
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('Enum', () => {
-    const { EnumField } = customFieldDefinitions;
-    beforeEach(() => {
-      result = customFieldsTransformer([{ value: EnumField }]);
-      expected = `(custom(fields(enumField = "someEnumKey")))`;
-    });
-
-    it('should return an enum predicate', () => {
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('LocalizedEnum', () => {
-    const { LocalizedEnumField } = customFieldDefinitions;
-    beforeEach(() => {
-      result = customFieldsTransformer([{ value: LocalizedEnumField }]);
-      expected = `(custom(fields(localizedEnumField = "someLocalizedEnumKey")))`;
-    });
-
-    it('should return a localized enum predicate', () => {
-      expect(result).toEqual(expected);
-    });
-  });
-
-  describe('Time', () => {
-    describe('single filter', () => {
-      const { TimeField } = customFieldDefinitions;
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: TimeField }]);
-        expected = `(custom(fields((timeField < "${nowTime}"))))`;
-      });
-
-      it('should return a time single predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('range filter', () => {
-      const { TimeFieldRange } = customFieldDefinitions;
-      const from = moment(testTime).startOf('minute').format(timeFormat);
-      const to = moment(testTime)
-        .add(1, 'hours')
-        .endOf('minute')
-        .format(timeFormat);
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: TimeFieldRange }]);
-        expected = `(custom(fields(((timeField >= "${from}" and timeField <= "${to}")))))`;
-      });
-
-      it('should return a time range predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-  });
-
-  describe('Date', () => {
-    describe('single filter', () => {
-      const { DateField } = customFieldDefinitions;
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: DateField }]);
-        expected = `(custom(fields((dateField < "${todayDate}"))))`;
-      });
-
-      it('should return a date single predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('range filter', () => {
-      const { DateFieldRange } = customFieldDefinitions;
-      const from = moment(testTime).format(queryDateFormat);
-      const to = moment(testTime)
-        .add(1, 'day')
-
-        .format(queryDateFormat);
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: DateFieldRange }]);
-        expected = `(custom(fields(((dateField >= "${from}" and dateField <= "${to}")))))`;
-      });
-
-      it('should return a date range predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-  });
-
-  describe('DateTime', () => {
-    describe('single filter', () => {
-      const { DateTimeField } = customFieldDefinitions;
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: DateTimeField }]);
-        expected = `(custom(fields((dateTimeField < "${todayDateTime}"))))`;
-      });
-
-      it('should return a datetime single predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('range filter', () => {
-      const { DateTimeFieldRange } = customFieldDefinitions;
-      const from = moment(testTime).format(queryDateFormat);
-      const to = moment(testTime)
-        .add(1, 'day')
-
-        .format(queryDateFormat);
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: DateTimeFieldRange }]);
-        expected = `(custom(fields(((dateTimeField >= "${from}" and dateTimeField <= "${to}")))))`;
-      });
-
-      it('should return a datetime range predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-  });
-
-  describe('Number', () => {
-    describe('single filter', () => {
-      const { NumberField } = customFieldDefinitions;
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: NumberField }]);
-        expected = `(custom(fields(numberField < 1000)))`;
-      });
-
-      it('should return a number single predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('range filter', () => {
-      const { NumberFieldRange } = customFieldDefinitions;
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: NumberFieldRange }]);
-        expected = `(custom(fields(numberField >= 1000 and numberField <= 2000)))`;
-      });
-
-      it('should return a number range predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-  });
-
-  describe('Money', () => {
-    describe('single filter', () => {
-      const { MoneyField } = customFieldDefinitions;
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: MoneyField }]);
-        expected = `(custom(fields(moneyField(currencyCode = "EUR" and centAmount < 1000))))`;
-      });
-
-      it('should return a money single predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-
-    describe('range filter', () => {
-      const { MoneyFieldRange } = customFieldDefinitions;
-      beforeEach(() => {
-        result = customFieldsTransformer([{ value: MoneyFieldRange }]);
-        expected = `(custom(fields(moneyField(currencyCode = "EUR" and centAmount >= 1000 and centAmount <= 2000))))`;
-      });
-
-      it('should return a money range predicate', () => {
-        expect(result).toEqual(expected);
-      });
-    });
-  });
-});

package/src/utils/filters/custom-fields/index.js

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

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

@@ -1,114 +0,0 @@
-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 dateFormatDayStart = 'YYYY-MM-DDT00:00:00.000';
-const dateFormatDayEnd = 'YYYY-MM-DDT23:59:59.999';
-
-export const getDateTimeInUTC = (date, timezone, format) => {
-  const dateFormat = 'YYYY-MM-DDTHH:mm:ss.SSS';
-  const momentDate = moment(date);
-  // check if the date is date only or datetime
-  const noTimeSpecified =
-    momentDate.hours() === 0 &&
-    momentDate.minutes() === 0 &&
-    momentDate.seconds() === 0;
-  // if it's a date then convert it to UTC datetime based on timezone
-  if (noTimeSpecified) {
-    const offset = moment(date).tz(timezone)?.utcOffset() || 0;
-    const formattedDate = momentDate.format(format);
-    const formattedDateWithOffset = moment(formattedDate)
-      .add(offset, 'minutes')
-      .format(dateFormat);
-    // console.log(formattedDateWithOffset);
-    return formattedDateWithOffset;
-  }
-  // if it's a datetime we assume that it's already in UTC
-  // and just return it
-  return date;
-};
-
-export default function dateTransformer(
-  filterKey,
-  filters,
-  filterValidator = defaultFilterValidator
-) {
-  const queries = filters.map(({ type, value, timezone }) => {
-    if (!filterValidator({ type, value })) return '';
-
-    switch (type) {
-      case FILTER_TYPES.lessThan:
-        return `${filterKey} < "${getDateTimeInUTC(
-          value,
-          timezone,
-          dateFormatDayStart
-        )}"`;
-      case FILTER_TYPES.moreThan:
-        return `${filterKey} > "${getDateTimeInUTC(
-          value,
-          timezone,
-          dateFormatDayEnd
-        )}"`;
-      case FILTER_TYPES.equalTo:
-        return oneLine`
-            (${filterKey} >= "${getDateTimeInUTC(
-          value,
-          timezone,
-          dateFormatDayStart
-        )}"
-            and ${filterKey} <= "${getDateTimeInUTC(
-          value,
-          timezone,
-          dateFormatDayEnd
-        )}")
-          `;
-      case FILTER_TYPES.range:
-        return oneLine`
-            (${filterKey} >= "${getDateTimeInUTC(
-          value.from,
-          timezone,
-          dateFormatDayStart
-        )}"
-            and ${filterKey} <= "${getDateTimeInUTC(
-          value.to,
-          timezone,
-          dateFormatDayEnd
-        )}")
-          `;
-      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
-   * (
-   *  (createdAt >= "2018-04-25T00:00:00.000+02:00" and createdAt <= "2018-04-25T23:59:59.999+02:00") o
-   *  (createdAt >= "2018-02-15T00:00:00.000+01:00" and createdAt <= "2018-02-15T23:59:59.999+01:00")
-   * ) or some_more_filters
-   */
-  return queryString === '' ? null : `(${queryString})`;
-}
-
-export function defaultFilterValidator({ type, value }) {
-  if (
-    type !== 'range' &&
-    (singleIsEmpty({ value }) || !moment(value).isValid())
-  )
-    return false;
-
-  if (
-    type === 'range' &&
-    (rangeIsEmpty({ value }) ||
-      !moment(value.from).isValid() ||
-      !moment(value.to).isValid())
-  )
-    return false;
-
-  return true;
-}