@cubejs-client/core 0.36.0 → 0.36.4

package/dist/cubejs-client-core.esm.js

@@ -1,12 +1,16 @@
 import { v4 } from 'uuid';
 import dayjs from 'dayjs';
+import { fromPairs, toPairs, equals, clone, indexBy, prop, mergeDeepLeft, pipe, map, filter, reduce, minBy, maxBy, flatten, pluck, mergeAll, uniq, dropLast, groupBy, unnest as unnest$1 } from 'ramda';
 import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import duration from 'dayjs/plugin/duration';
+import isoWeek from 'dayjs/plugin/isoWeek';
 import en from 'dayjs/locale/en';
-import { fromPairs, toPairs, equals, clone, indexBy, prop, mergeDeepLeft, pipe, map, filter, reduce, minBy, maxBy, flatten, pluck, mergeAll, uniq, dropLast, groupBy, unnest as unnest$1 } from 'ramda';
 import fetch from 'cross-fetch';
 import 'url-search-params-polyfill';
 
-const DEFAULT_GRANULARITY = 'day';
+dayjs.extend(quarterOfYear);
+dayjs.extend(duration);
+dayjs.extend(isoWeek);
 const GRANULARITIES = [{
   name: undefined,
   title: 'w/o grouping'
@@ -35,6 +39,219 @@ const GRANULARITIES = [{
   name: 'year',
   title: 'Year'
 }];
+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.
+const internalDayjs = (...args) => dayjs(...args).locale({
+  ...en,
+  weekStart: 1
+});
+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'))
+};
+const isPredefinedGranularity = granularity => !!TIME_SERIES[granularity];
+const DateRegex = /^\d\d\d\d-\d\d-\d\d$/;
+const LocalDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z?$/;
+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.
+ */
+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}
+ */
+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}
+ */
+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
+ */
+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}
+ */
+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'];
+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;
+};
+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';
+};
+
 function removeEmptyQueryFields(_query) {
   const query = _query || {};
   return fromPairs(toPairs(query).map(([key, value]) => {
@@ -291,26 +508,6 @@ function aliasSeries(values, index, pivotConfig, duplicateMeasures) {
   return nonNullValues;
 }
 
-dayjs.extend(quarterOfYear);
-
-// 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.
-const internalDayjs = (...args) => dayjs(...args).locale({
-  ...en,
-  weekStart: 1
-});
-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'))
-};
-const DateRegex = /^\d\d\d\d-\d\d-\d\d$/;
-const LocalDateRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}.\d{3}Z?$/;
 const groupByToPairs = keyFn => {
   const acc = new Map();
   return data => {
@@ -331,21 +528,6 @@ const unnest = arr => {
   });
   return res;
 };
-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)
-});
 const QUERY_TYPE = {
   REGULAR_QUERY: 'regularQuery',
   COMPARE_DATE_RANGE_QUERY: 'compareDateRangeQuery',
@@ -544,7 +726,7 @@ class ResultSet {
   normalizePivotConfig(pivotConfig) {
     return ResultSet.getNormalizedPivotConfig(this.loadResponse.pivotQuery, pivotConfig);
   }
-  timeSeries(timeDimension, resultIndex) {
+  timeSeries(timeDimension, resultIndex, annotations) {
     if (!timeDimension.granularity) {
       return null;
     }
@@ -562,10 +744,13 @@ class ResultSet {
     const padToDay = timeDimension.dateRange ? timeDimension.dateRange.find(d => d.match(DateRegex)) : !['hour', 'minute', 'second'].includes(timeDimension.granularity);
     const [start, end] = dateRange;
     const range = dayRange(start, end);
-    if (!TIME_SERIES[timeDimension.granularity]) {
-      throw new Error(`Unsupported time granularity: ${timeDimension.granularity}`);
+    if (isPredefinedGranularity(timeDimension.granularity)) {
+      return TIME_SERIES[timeDimension.granularity](padToDay ? range.snapTo('d') : range);
+    }
+    if (!annotations[`${timeDimension.dimension}.${timeDimension.granularity}`]) {
+      throw new Error(`Granularity "${timeDimension.granularity}" not found in time dimension "${timeDimension.dimension}"`);
     }
-    return TIME_SERIES[timeDimension.granularity](padToDay ? range.snapTo('d') : range);
+    return timeSeriesFromCustomInterval(start, end, annotations[`${timeDimension.dimension}.${timeDimension.granularity}`].granularity);
   }
   pivot(pivotConfig) {
     pivotConfig = this.normalizePivotConfig(pivotConfig);
@@ -578,7 +763,7 @@ class ResultSet {
       }) => this.axisValuesString(xValues));
       const measureValue = (row, measure) => row[measure] || 0;
       if (pivotConfig.fillMissingDates && pivotConfig.x.length === 1 && equals(pivotConfig.x, (query.timeDimensions || []).filter(td => Boolean(td.granularity)).map(td => ResultSet.timeDimensionMember(td)))) {
-        const series = this.loadResponses.map(loadResponse => this.timeSeries(loadResponse.query.timeDimensions[0], resultIndex));
+        const series = this.loadResponses.map(loadResponse => this.timeSeries(loadResponse.query.timeDimensions[0], resultIndex, loadResponse.annotation.timeDimensions));
         if (series[0]) {
           groupByXAxis = rows => {
             const byXValues = groupBy(({
@@ -1445,5 +1630,5 @@ class CubeApi {
 var index = ((apiToken, options) => new CubeApi(apiToken, options));
 
 export default index;
-export { CubeApi, DEFAULT_GRANULARITY, GRANULARITIES, HttpTransport, Meta, RequestError, ResultSet, aliasSeries, areQueriesEqual, defaultHeuristics, defaultOrder, flattenFilters, getOrderMembersFromOrder, getQueryMembers, isQueryPresent, moveItemInArray, movePivotItem, removeEmptyQueryFields, validateQuery };
+export { CubeApi, DEFAULT_GRANULARITY, DateRegex, GRANULARITIES, HttpTransport, LocalDateRegex, Meta, RequestError, ResultSet, TIME_SERIES, addInterval, aliasSeries, areQueriesEqual, dayRange, defaultHeuristics, defaultOrder, diffTimeUnitForInterval, flattenFilters, getOrderMembersFromOrder, getQueryMembers, granularityFor, internalDayjs, isPredefinedGranularity, isQueryPresent, minGranularityForIntervals, moveItemInArray, movePivotItem, parseSqlInterval, removeEmptyQueryFields, subtractInterval, timeSeriesFromCustomInterval, validateQuery };
 //# sourceMappingURL=cubejs-client-core.esm.js.map