@cubejs-client/core 1.3.14 → 1.3.16

package/src/tests/utils.test.js

@@ -1,35 +0,0 @@
-import 'jest';
-
-import { defaultOrder } from '../utils';
-import { dayRange, TIME_SERIES } from '../time';
-
-describe('utils', () => {
-  test('default order', () => {
-    const query = {
-      measures: ['Orders.count'],
-      timeDimensions: [
-        {
-          dimension: 'Orders.createdAt',
-          granularity: 'day',
-        },
-      ],
-    };
-    expect(defaultOrder(query)).toStrictEqual({
-      'Orders.createdAt': 'asc',
-    });
-  });
-
-  test('time series', () => {
-    const range = dayRange('2021-01-01 00:00:00.000', '2021-01-07 00:00:00.000');
-
-    expect(TIME_SERIES.day(range)).toStrictEqual([
-      '2021-01-01T00:00:00.000',
-      '2021-01-02T00:00:00.000',
-      '2021-01-03T00:00:00.000',
-      '2021-01-04T00:00:00.000',
-      '2021-01-05T00:00:00.000',
-      '2021-01-06T00:00:00.000',
-      '2021-01-07T00:00:00.000',
-    ]);
-  });
-});

package/src/time.js

@@ -1,296 +0,0 @@
-import dayjs from 'dayjs';
-import quarterOfYear from 'dayjs/plugin/quarterOfYear';
-import duration from 'dayjs/plugin/duration';
-import isoWeek from 'dayjs/plugin/isoWeek';
-import en from 'dayjs/locale/en';
-
-dayjs.extend(quarterOfYear);
-dayjs.extend(duration);
-dayjs.extend(isoWeek);
-
-export const GRANULARITIES = [
-  { name: undefined, title: 'w/o grouping' },
-  { name: 'second', title: 'Second' },
-  { name: 'minute', title: 'Minute' },
-  { name: 'hour', title: 'Hour' },
-  { name: 'day', title: 'Day' },
-  { name: 'week', title: 'Week' },
-  { name: 'month', title: 'Month' },
-  { name: 'quarter', title: 'Quarter' },
-  { name: 'year', title: 'Year' },
-];
-
-export const DEFAULT_GRANULARITY = 'day';
-
-// When granularity is week, weekStart Value must be 1. However, since the client can change it globally
-// (https://day.js.org/docs/en/i18n/changing-locale) So the function below has been added.
-export const internalDayjs = (...args) => dayjs(...args).locale({ ...en, weekStart: 1 });
-
-export const TIME_SERIES = {
-  day: (range) => range.by('d').map(d => d.format('YYYY-MM-DDT00:00:00.000')),
-  month: (range) => range.snapTo('month').by('M').map(d => d.format('YYYY-MM-01T00:00:00.000')),
-  year: (range) => range.snapTo('year').by('y').map(d => d.format('YYYY-01-01T00:00:00.000')),
-  hour: (range) => range.by('h').map(d => d.format('YYYY-MM-DDTHH:00:00.000')),
-  minute: (range) => range.by('m').map(d => d.format('YYYY-MM-DDTHH:mm:00.000')),
-  second: (range) => range.by('s').map(d => d.format('YYYY-MM-DDTHH:mm:ss.000')),
-  week: (range) => range.snapTo('week').by('w').map(d => d.startOf('week').format('YYYY-MM-DDT00:00:00.000')),
-  quarter: (range) => range.snapTo('quarter').by('quarter').map(d => d.startOf('quarter').format(
-    'YYYY-MM-DDT00:00:00.000'
-  )),
-};
-
-export const isPredefinedGranularity = (granularity) => !!TIME_SERIES[granularity];
-
-export const DateRegex = /^\d\d\d\d-\d\d-\d\d$/;
-export const LocalDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z?$/;
-
-export const dayRange = (from, to) => ({
-  by: (value) => {
-    const results = [];
-
-    let start = internalDayjs(from);
-    const end = internalDayjs(to);
-
-    while (start.isBefore(end) || start.isSame(end)) {
-      results.push(start);
-      start = start.add(1, value);
-    }
-
-    return results;
-  },
-  snapTo: (value) => dayRange(internalDayjs(from).startOf(value), internalDayjs(to).endOf(value)),
-  start: internalDayjs(from),
-  end: internalDayjs(to),
-});
-
-/**
- * Parse PostgreSQL-like interval string into object
- * E.g. '2 years 15 months 100 weeks 99 hours 15 seconds'
- * Negative units are also supported
- * E.g. '-2 months 5 days -10 hours'
- *
- * TODO: It's copy/paste of parseSqlInterval from @cubejs-backend/shared [time.ts]
- * It's not referenced to omit imports of moment.js staff.
- * Probably one day we should choose one implementation and reuse it in other places.
- */
-export function parseSqlInterval(intervalStr) {
-  const interval = {};
-  const parts = intervalStr.split(/\s+/);
-
-  for (let i = 0; i < parts.length; i += 2) {
-    const value = parseInt(parts[i], 10);
-    const unit = parts[i + 1];
-
-    // Remove ending 's' (e.g., 'days' -> 'day')
-    const singularUnit = unit.endsWith('s') ? unit.slice(0, -1) : unit;
-    interval[singularUnit] = value;
-  }
-
-  return interval;
-}
-
-/**
- * Adds interval to provided date.
- * TODO: It's copy/paste of addInterval from @cubejs-backend/shared [time.ts]
- * but operates with dayjs instead of moment.js
- * @param {dayjs} date
- * @param interval
- * @returns {dayjs}
- */
-export function addInterval(date, interval) {
-  let res = date.clone();
-
-  Object.entries(interval).forEach(([key, value]) => {
-    res = res.add(value, key);
-  });
-
-  return res;
-}
-
-/**
- * Adds interval to provided date.
- * TODO: It's copy/paste of subtractInterval from @cubejs-backend/shared [time.ts]
- * but operates with dayjs instead of moment.js
- * @param {dayjs} date
- * @param interval
- * @returns {dayjs}
- */
-export function subtractInterval(date, interval) {
-  let res = date.clone();
-
-  Object.entries(interval).forEach(([key, value]) => {
-    res = res.subtract(value, key);
-  });
-
-  return res;
-}
-
-/**
- * Returns the closest date prior to date parameter aligned with the origin point
- * TODO: It's copy/paste of alignToOrigin from @cubejs-backend/shared [time.ts]
- * but operates with dayjs instead of moment.js
- */
-function alignToOrigin(startDate, interval, origin) {
-  let alignedDate = startDate.clone();
-  let intervalOp;
-  let isIntervalNegative = false;
-
-  let offsetDate = addInterval(origin, interval);
-
-  // The easiest way to check the interval sign
-  if (offsetDate.isBefore(origin)) {
-    isIntervalNegative = true;
-  }
-
-  offsetDate = origin.clone();
-
-  if (startDate.isBefore(origin)) {
-    intervalOp = isIntervalNegative ? addInterval : subtractInterval;
-
-    while (offsetDate.isAfter(startDate)) {
-      offsetDate = intervalOp(offsetDate, interval);
-    }
-    alignedDate = offsetDate;
-  } else {
-    intervalOp = isIntervalNegative ? subtractInterval : addInterval;
-
-    while (offsetDate.isBefore(startDate)) {
-      alignedDate = offsetDate.clone();
-      offsetDate = intervalOp(offsetDate, interval);
-    }
-
-    if (offsetDate.isSame(startDate)) {
-      alignedDate = offsetDate;
-    }
-  }
-
-  return alignedDate;
-}
-
-/**
- * Returns the time series points for the custom interval
- * TODO: It's almost a copy/paste of timeSeriesFromCustomInterval from
- * @cubejs-backend/shared [time.ts] but operates with dayjs instead of moment.js
- */
-export const timeSeriesFromCustomInterval = (from, to, granularity) => {
-  const intervalParsed = parseSqlInterval(granularity.interval);
-  const start = internalDayjs(from);
-  const end = internalDayjs(to);
-  let origin = granularity.origin ? internalDayjs(granularity.origin) : internalDayjs().startOf('year');
-  if (granularity.offset) {
-    origin = addInterval(origin, parseSqlInterval(granularity.offset));
-  }
-  let alignedStart = alignToOrigin(start, intervalParsed, origin);
-
-  const dates = [];
-
-  while (alignedStart.isBefore(end) || alignedStart.isSame(end)) {
-    dates.push(alignedStart.format('YYYY-MM-DDTHH:mm:ss.000'));
-    alignedStart = addInterval(alignedStart, intervalParsed);
-  }
-
-  return dates;
-};
-
-/**
- * Returns the lowest time unit for the interval
- * @protected
- * @param {string} interval
- * @returns {string}
- */
-export const diffTimeUnitForInterval = (interval) => {
-  if (/second/i.test(interval)) {
-    return 'second';
-  } else if (/minute/i.test(interval)) {
-    return 'minute';
-  } else if (/hour/i.test(interval)) {
-    return 'hour';
-  } else if (/day/i.test(interval)) {
-    return 'day';
-  } else if (/week/i.test(interval)) {
-    return 'day';
-  } else if (/month/i.test(interval)) {
-    return 'month';
-  } else if (/quarter/i.test(interval)) {
-    return 'month';
-  } else /* if (/year/i.test(interval)) */ {
-    return 'year';
-  }
-};
-
-const granularityOrder = ['year', 'quarter', 'month', 'week', 'day', 'hour', 'minute', 'second'];
-
-export const minGranularityForIntervals = (i1, i2) => {
-  const g1 = diffTimeUnitForInterval(i1);
-  const g2 = diffTimeUnitForInterval(i2);
-  const g1pos = granularityOrder.indexOf(g1);
-  const g2pos = granularityOrder.indexOf(g2);
-
-  if (g1pos > g2pos) {
-    return g1;
-  }
-
-  return g2;
-};
-
-export const granularityFor = (dateStr) => {
-  const dayjsDate = internalDayjs(dateStr);
-  const month = dayjsDate.month();
-  const date = dayjsDate.date();
-  const hours = dayjsDate.hour();
-  const minutes = dayjsDate.minute();
-  const seconds = dayjsDate.second();
-  const milliseconds = dayjsDate.millisecond();
-  const weekDay = dayjsDate.isoWeekday();
-
-  if (
-    month === 0 &&
-    date === 1 &&
-    hours === 0 &&
-    minutes === 0 &&
-    seconds === 0 &&
-    milliseconds === 0
-  ) {
-    return 'year';
-  } else if (
-    date === 1 &&
-    hours === 0 &&
-    minutes === 0 &&
-    seconds === 0 &&
-    milliseconds === 0
-  ) {
-    return 'month';
-  } else if (
-    weekDay === 1 &&
-    hours === 0 &&
-    minutes === 0 &&
-    seconds === 0 &&
-    milliseconds === 0
-  ) {
-    return 'week';
-  } else if (
-    hours === 0 &&
-    minutes === 0 &&
-    seconds === 0 &&
-    milliseconds === 0
-  ) {
-    return 'day';
-  } else if (
-    minutes === 0 &&
-    seconds === 0 &&
-    milliseconds === 0
-  ) {
-    return 'hour';
-  } else if (
-    seconds === 0 &&
-    milliseconds === 0
-  ) {
-    return 'minute';
-  } else if (
-    milliseconds === 0
-  ) {
-    return 'second';
-  }
-
-  return 'second'; // TODO return 'millisecond';
-};

package/src/utils.js

@@ -1,368 +0,0 @@
-import { clone, equals, fromPairs, indexBy, prop, toPairs } from 'ramda';
-import { DEFAULT_GRANULARITY } from './time';
-
-export function removeEmptyQueryFields(_query) {
-  const query = _query || {};
-
-  return fromPairs(
-    toPairs(query)
-      .map(([key, value]) => {
-        if (
-          ['measures', 'dimensions', 'segments', 'timeDimensions', 'filters'].includes(key)
-        ) {
-          if (Array.isArray(value) && value.length === 0) {
-            return null;
-          }
-        }
-
-        if (key === 'order' && value) {
-          if (Array.isArray(value) && !value.length) {
-            return null;
-          } else if (!Object.keys(value).length) {
-            return null;
-          }
-        }
-
-        return [key, value];
-      })
-      .filter(Boolean)
-  );
-}
-
-export function validateQuery(_query) {
-  const query = _query || {};
-
-  return removeEmptyQueryFields({
-    ...query,
-    filters: (query.filters || []).filter((f) => f.operator),
-    timeDimensions: (query.timeDimensions || []).filter(
-      (td) => !(!td.dateRange && !td.granularity)
-    ),
-  });
-}
-
-export function areQueriesEqual(query1 = {}, query2 = {}) {
-  return (
-    equals(
-      Object.entries((query1 && query1.order) || {}),
-      Object.entries((query2 && query2.order) || {})
-    ) && equals(query1, query2)
-  );
-}
-
-export function defaultOrder(query) {
-  const granularity = (query.timeDimensions || []).find((d) => d.granularity);
-
-  if (granularity) {
-    return {
-      [granularity.dimension]: 'asc',
-    };
-  } else if (
-    (query.measures || []).length > 0 &&
-    (query.dimensions || []).length > 0
-  ) {
-    return {
-      [query.measures[0]]: 'desc',
-    };
-  } else if ((query.dimensions || []).length > 0) {
-    return {
-      [query.dimensions[0]]: 'asc',
-    };
-  }
-
-  return {};
-}
-
-export function defaultHeuristics(newState, oldQuery = {}, options) {
-  const { query, ...props } = clone(newState);
-  const { meta, sessionGranularity } = options;
-  const granularity = sessionGranularity || DEFAULT_GRANULARITY;
-
-  let state = {
-    query,
-    ...props,
-  };
-
-  let newQuery = null;
-  if (!areQueriesEqual(query, oldQuery)) {
-    newQuery = query;
-  }
-
-  if (Array.isArray(newQuery) || Array.isArray(oldQuery)) {
-    return newState;
-  }
-
-  if (newQuery) {
-    if (
-      (oldQuery.timeDimensions || []).length === 1 &&
-      (newQuery.timeDimensions || []).length === 1 &&
-      newQuery.timeDimensions[0].granularity &&
-      oldQuery.timeDimensions[0].granularity !==
-        newQuery.timeDimensions[0].granularity
-    ) {
-      state = {
-        ...state,
-        sessionGranularity: newQuery.timeDimensions[0].granularity,
-      };
-    }
-
-    if (
-      ((oldQuery.measures || []).length === 0 &&
-        (newQuery.measures || []).length > 0) ||
-      ((oldQuery.measures || []).length === 1 &&
-        (newQuery.measures || []).length === 1 &&
-        oldQuery.measures[0] !== newQuery.measures[0])
-    ) {
-      const [td] = newQuery.timeDimensions || [];
-      const defaultTimeDimension = meta.defaultTimeDimensionNameFor(
-        newQuery.measures[0]
-      );
-      newQuery = {
-        ...newQuery,
-        timeDimensions: defaultTimeDimension
-          ? [
-            {
-              dimension: defaultTimeDimension,
-              granularity: (td && td.granularity) || granularity,
-              dateRange: td && td.dateRange,
-            },
-          ]
-          : [],
-      };
-
-      return {
-        ...state,
-        pivotConfig: null,
-        shouldApplyHeuristicOrder: true,
-        query: newQuery,
-        chartType: defaultTimeDimension ? 'line' : 'number',
-      };
-    }
-
-    if (
-      (oldQuery.dimensions || []).length === 0 &&
-      (newQuery.dimensions || []).length > 0
-    ) {
-      newQuery = {
-        ...newQuery,
-        timeDimensions: (newQuery.timeDimensions || []).map((td) => ({
-          ...td,
-          granularity: undefined,
-        })),
-      };
-
-      return {
-        ...state,
-        pivotConfig: null,
-        shouldApplyHeuristicOrder: true,
-        query: newQuery,
-        chartType: 'table',
-      };
-    }
-
-    if (
-      (oldQuery.dimensions || []).length > 0 &&
-      (newQuery.dimensions || []).length === 0
-    ) {
-      newQuery = {
-        ...newQuery,
-        timeDimensions: (newQuery.timeDimensions || []).map((td) => ({
-          ...td,
-          granularity: td.granularity || granularity,
-        })),
-      };
-
-      return {
-        ...state,
-        pivotConfig: null,
-        shouldApplyHeuristicOrder: true,
-        query: newQuery,
-        chartType: (newQuery.timeDimensions || []).length ? 'line' : 'number',
-      };
-    }
-
-    if (
-      ((oldQuery.dimensions || []).length > 0 ||
-        (oldQuery.measures || []).length > 0) &&
-      (newQuery.dimensions || []).length === 0 &&
-      (newQuery.measures || []).length === 0
-    ) {
-      newQuery = {
-        ...newQuery,
-        timeDimensions: [],
-        filters: [],
-      };
-
-      return {
-        ...state,
-        pivotConfig: null,
-        shouldApplyHeuristicOrder: true,
-        query: newQuery,
-        sessionGranularity: null,
-      };
-    }
-    return state;
-  }
-
-  if (state.chartType) {
-    const newChartType = state.chartType;
-    if (
-      (newChartType === 'line' || newChartType === 'area') &&
-      (oldQuery.timeDimensions || []).length === 1 &&
-      !oldQuery.timeDimensions[0].granularity
-    ) {
-      const [td] = oldQuery.timeDimensions;
-      return {
-        ...state,
-        pivotConfig: null,
-        query: {
-          ...oldQuery,
-          timeDimensions: [{ ...td, granularity }],
-        },
-      };
-    }
-
-    if (
-      (newChartType === 'pie' ||
-        newChartType === 'table' ||
-        newChartType === 'number') &&
-      (oldQuery.timeDimensions || []).length === 1 &&
-      oldQuery.timeDimensions[0].granularity
-    ) {
-      const [td] = oldQuery.timeDimensions;
-      return {
-        ...state,
-        pivotConfig: null,
-        shouldApplyHeuristicOrder: true,
-        query: {
-          ...oldQuery,
-          timeDimensions: [{ ...td, granularity: undefined }],
-        },
-      };
-    }
-  }
-
-  return state;
-}
-
-export function isQueryPresent(query) {
-  if (!query) {
-    return false;
-  }
-
-  return (Array.isArray(query) ? query : [query]).every(
-    (q) => (q.measures && q.measures.length) ||
-      (q.dimensions && q.dimensions.length) ||
-      (q.timeDimensions && q.timeDimensions.length)
-  );
-}
-
-export function movePivotItem(
-  pivotConfig,
-  sourceIndex,
-  destinationIndex,
-  sourceAxis,
-  destinationAxis
-) {
-  const nextPivotConfig = {
-    ...pivotConfig,
-    x: [...pivotConfig.x],
-    y: [...pivotConfig.y],
-  };
-  const id = pivotConfig[sourceAxis][sourceIndex];
-  const lastIndex = nextPivotConfig[destinationAxis].length - 1;
-
-  if (id === 'measures') {
-    destinationIndex = lastIndex + 1;
-  } else if (
-    sourceAxis === destinationAxis &&
-    destinationIndex >= lastIndex &&
-    nextPivotConfig[destinationAxis][lastIndex] === 'measures'
-  ) {
-    destinationIndex = lastIndex - 1;
-  } else if (
-    sourceAxis !== destinationAxis &&
-    destinationIndex > lastIndex &&
-    nextPivotConfig[destinationAxis][lastIndex] === 'measures'
-  ) {
-    destinationIndex = lastIndex;
-  }
-
-  nextPivotConfig[sourceAxis].splice(sourceIndex, 1);
-  nextPivotConfig[destinationAxis].splice(destinationIndex, 0, id);
-
-  return nextPivotConfig;
-}
-
-export function moveItemInArray(list, sourceIndex, destinationIndex) {
-  const result = [...list];
-  const [removed] = result.splice(sourceIndex, 1);
-  result.splice(destinationIndex, 0, removed);
-
-  return result;
-}
-
-export function flattenFilters(filters = []) {
-  return filters.reduce((memo, filter) => {
-    if (filter.or || filter.and) {
-      return [...memo, ...flattenFilters(filter.or || filter.and)];
-    }
-
-    return [...memo, filter];
-  }, []);
-}
-
-export function getQueryMembers(query = {}) {
-  const keys = ['measures', 'dimensions', 'segments'];
-  const members = new Set();
-
-  keys.forEach((key) => (query[key] || []).forEach((member) => members.add(member)));
-  (query.timeDimensions || []).forEach((td) => members.add(td.dimension));
-
-  flattenFilters(query.filters).forEach((filter) => members.add(filter.dimension || filter.member));
-
-  return [...members];
-}
-
-export function getOrderMembersFromOrder(orderMembers, order) {
-  const ids = new Set();
-  const indexedOrderMembers = indexBy(prop('id'), orderMembers);
-  const entries = Array.isArray(order) ? order : Object.entries(order || {});
-  const nextOrderMembers = [];
-
-  entries.forEach(([memberId, currentOrder]) => {
-    if (currentOrder !== 'none' && indexedOrderMembers[memberId]) {
-      ids.add(memberId);
-      nextOrderMembers.push({
-        ...indexedOrderMembers[memberId],
-        order: currentOrder,
-      });
-    }
-  });
-  orderMembers.forEach((member) => {
-    if (!ids.has(member.id)) {
-      nextOrderMembers.push({
-        ...member,
-        order: member.order || 'none',
-      });
-    }
-  });
-
-  return nextOrderMembers;
-}
-
-export function aliasSeries(values, index, pivotConfig, duplicateMeasures) {
-  const nonNullValues = values.filter((value) => value != null);
-
-  if (
-    pivotConfig &&
-    pivotConfig.aliasSeries &&
-    pivotConfig.aliasSeries[index]
-  ) {
-    return [pivotConfig.aliasSeries[index], ...nonNullValues];
-  } else if (duplicateMeasures.has(nonNullValues[0])) {
-    return [index, ...nonNullValues];
-  }
-
-  return nonNullValues;
-}