@cubejs-client/core 0.36.2 → 1.0.0

package/index.d.ts

@@ -1303,4 +1303,10 @@ declare module '@cubejs-client/core' {
     stage: string;
     timeElapsed: number;
   };
+
+  export function granularityFor(dateStr: string): string;
+
+  export function minGranularityForIntervals(i1: string, i2: string): string;
+
+  export function isPredefinedGranularity(granularity: TimeDimensionGranularity): boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubejs-client/core",
-  "version": "0.36.2",
+  "version": "1.0.0",
   "engines": {},
   "repository": {
     "type": "git",
@@ -45,5 +45,5 @@
     "eslint-plugin-node": "^5.2.1",
     "jest": "^27"
   },
-  "gitHead": "ab3771bfce10eaabafff99404250a3681be79137"
+  "gitHead": "a8f48f289ebf11ce3b0480cf3713ba060c7e0270"
 }

package/src/ResultSet.js

@@ -1,33 +1,19 @@
 import dayjs from 'dayjs';
-import quarterOfYear from 'dayjs/plugin/quarterOfYear';
-
-import en from 'dayjs/locale/en';
 import {
   groupBy, pipe, fromPairs, uniq, filter, map, dropLast, equals, reduce, minBy, maxBy, clone, mergeDeepLeft,
   pluck, mergeAll, flatten,
 } from 'ramda';
 
 import { aliasSeries } from './utils';
-
-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 });
-
-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')),
-};
-
-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?$/;
+import {
+  DateRegex,
+  dayRange,
+  internalDayjs,
+  isPredefinedGranularity,
+  LocalDateRegex,
+  TIME_SERIES,
+  timeSeriesFromCustomInterval
+} from './time';
 
 const groupByToPairs = (keyFn) => {
   const acc = new Map();
@@ -56,25 +42,6 @@ const unnest = (arr) => {
   return res;
 };
 
-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),
-});
-
 export const QUERY_TYPE = {
   REGULAR_QUERY: 'regularQuery',
   COMPARE_DATE_RANGE_QUERY: 'compareDateRangeQuery',
@@ -163,15 +130,15 @@ class ResultSet {
         if (granularity !== undefined) {
           const range = dayRange(value, value).snapTo(granularity);
           const originalTimeDimension = query.timeDimensions.find((td) => td.dimension);
-          
+
           let dateRange = [
             range.start,
             range.end
           ];
-          
+
           if (originalTimeDimension?.dateRange) {
             const [originalStart, originalEnd] = originalTimeDimension.dateRange;
-            
+
             dateRange = [
               dayjs(originalStart) > range.start ? dayjs(originalStart) : range.start,
               dayjs(originalEnd) < range.end ? dayjs(originalEnd) : range.end,
@@ -195,7 +162,7 @@ class ResultSet {
           });
         }
       });
-    
+
     if (
       timeDimensions.length === 0 &&
       query.timeDimensions.length > 0 &&
@@ -321,7 +288,7 @@ class ResultSet {
     return ResultSet.getNormalizedPivotConfig(this.loadResponse.pivotQuery, pivotConfig);
   }
 
-  timeSeries(timeDimension, resultIndex) {
+  timeSeries(timeDimension, resultIndex, annotations) {
     if (!timeDimension.granularity) {
       return null;
     }
@@ -352,12 +319,18 @@ class ResultSet {
     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
     );
   }
 
@@ -381,7 +354,10 @@ class ResultSet {
         ))
       ) {
         const series = this.loadResponses.map(
-          (loadResponse) => this.timeSeries(loadResponse.query.timeDimensions[0], resultIndex)
+          (loadResponse) => this.timeSeries(
+            loadResponse.query.timeDimensions[0],
+            resultIndex, loadResponse.annotation.timeDimensions
+          )
         );
 
         if (series[0]) {

package/src/index.js

@@ -271,22 +271,22 @@ class CubeApi {
             if (v.type === 'number') {
               return k;
             }
-            
+
             return undefined;
           }).filter(Boolean);
-          
+
           result.data = result.data.map((row) => {
             numericMembers.forEach((key) => {
               if (row[key] != null) {
                 row[key] = Number(row[key]);
               }
             });
-            
+
             return row;
           });
         });
       }
-      
+
       if (response.results[0].query.responseFormat &&
         response.results[0].query.responseFormat === ResultType.COMPACT) {
         response.results.forEach((result, j) => {
@@ -302,7 +302,7 @@ class CubeApi {
         });
       }
     }
-    
+
     return new ResultSet(response, {
       parseDateMeasures: this.parseDateMeasures
     });
@@ -388,3 +388,4 @@ export default (apiToken, options) => new CubeApi(apiToken, options);
 
 export { CubeApi, HttpTransport, ResultSet, RequestError, Meta };
 export * from './utils';
+export * from './time';

package/src/tests/ResultSet.test.js

@@ -102,6 +102,303 @@ describe('ResultSet', () => {
       ];
       expect(resultSet.timeSeries(timeDimension)).toEqual(output);
     });
+
+    test('it generates array of dates - custom interval - 1 year, origin - 2020-01-01', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2023-12-31'],
+        granularity: 'one_year',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2021-01-01T00:00:00.000',
+        '2022-01-01T00:00:00.000',
+        '2023-01-01T00:00:00.000'
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.one_year': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '1 year',
+            title: '1 year',
+            interval: '1 year',
+            origin: '2020-01-01',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 1 year, origin - 2025-03-01', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2022-12-31'],
+        granularity: 'one_year',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2020-03-01T00:00:00.000',
+        '2021-03-01T00:00:00.000',
+        '2022-03-01T00:00:00.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.one_year': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '1 year',
+            title: '1 year',
+            interval: '1 year',
+            origin: '2025-03-01',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 1 year, offset - 2 months', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2022-12-31'],
+        granularity: 'one_year',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2020-03-01T00:00:00.000',
+        '2021-03-01T00:00:00.000',
+        '2022-03-01T00:00:00.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.one_year': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '1 year',
+            title: '1 year',
+            interval: '1 year',
+            offset: '2 months',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 2 months, origin - 2019-01-01', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2021-12-31'],
+        granularity: 'two_months',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2021-01-01T00:00:00.000',
+        '2021-03-01T00:00:00.000',
+        '2021-05-01T00:00:00.000',
+        '2021-07-01T00:00:00.000',
+        '2021-09-01T00:00:00.000',
+        '2021-11-01T00:00:00.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.two_months': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '2 months',
+            title: '2 months',
+            interval: '2 months',
+            origin: '2019-01-01',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 2 months, no offset', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2021-12-31'],
+        granularity: 'two_months',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2021-01-01T00:00:00.000',
+        '2021-03-01T00:00:00.000',
+        '2021-05-01T00:00:00.000',
+        '2021-07-01T00:00:00.000',
+        '2021-09-01T00:00:00.000',
+        '2021-11-01T00:00:00.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.two_months': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '2 months',
+            title: '2 months',
+            interval: '2 months',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 2 months, origin - 2019-03-15', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2021-12-31'],
+        granularity: 'two_months',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2020-11-15T00:00:00.000',
+        '2021-01-15T00:00:00.000',
+        '2021-03-15T00:00:00.000',
+        '2021-05-15T00:00:00.000',
+        '2021-07-15T00:00:00.000',
+        '2021-09-15T00:00:00.000',
+        '2021-11-15T00:00:00.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.two_months': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '2 months',
+            title: '2 months',
+            interval: '2 months',
+            origin: '2019-03-15',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 1 months 2 weeks 3 days, origin - 2021-01-25', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2021-12-31'],
+        granularity: 'one_mo_two_we_three_d',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2020-12-08T00:00:00.000',
+        '2021-01-25T00:00:00.000',
+        '2021-03-14T00:00:00.000',
+        '2021-05-01T00:00:00.000',
+        '2021-06-18T00:00:00.000',
+        '2021-08-04T00:00:00.000',
+        '2021-09-21T00:00:00.000',
+        '2021-11-07T00:00:00.000',
+        '2021-12-24T00:00:00.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.one_mo_two_we_three_d': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '1 months 2 weeks 3 days',
+            title: '1 months 2 weeks 3 days',
+            interval: '1 months 2 weeks 3 days',
+            origin: '2021-01-25',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 3 weeks, origin - 2020-12-15', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2021-03-01'],
+        granularity: 'three_weeks',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2020-12-15T00:00:00.000',
+        '2021-01-05T00:00:00.000',
+        '2021-01-26T00:00:00.000',
+        '2021-02-16T00:00:00.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.three_weeks': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '3 weeks',
+            title: '3 weeks',
+            interval: '3 weeks',
+            origin: '2020-12-15',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds, origin - 2021-01-01', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-01-01', '2021-12-31'],
+        granularity: 'two_mo_3w_4d_5h_6m_7s',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2021-01-01T00:00:00.000',
+        '2021-03-26T05:06:07.000',
+        '2021-06-20T10:12:14.000',
+        '2021-09-14T15:18:21.000',
+        '2021-12-09T20:24:28.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.two_mo_3w_4d_5h_6m_7s': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: 'two_mo_3w_4d_5h_6m_7s',
+            title: 'two_mo_3w_4d_5h_6m_7s',
+            interval: '2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds',
+            origin: '2021-01-01',
+          },
+        },
+      })).toEqual(output);
+    });
+
+    test('it generates array of dates - custom interval - 10 minutes 15 seconds, origin - 2021-02-01 09:59:45', () => {
+      const resultSet = new ResultSet({});
+      const timeDimension = {
+        dateRange: ['2021-02-01 10:00:00', '2021-02-01 12:00:00'],
+        granularity: 'ten_min_fifteen_sec',
+        dimension: 'Events.time'
+      };
+      const output = [
+        '2021-02-01T09:59:45.000',
+        '2021-02-01T10:10:00.000',
+        '2021-02-01T10:20:15.000',
+        '2021-02-01T10:30:30.000',
+        '2021-02-01T10:40:45.000',
+        '2021-02-01T10:51:00.000',
+        '2021-02-01T11:01:15.000',
+        '2021-02-01T11:11:30.000',
+        '2021-02-01T11:21:45.000',
+        '2021-02-01T11:32:00.000',
+        '2021-02-01T11:42:15.000',
+        '2021-02-01T11:52:30.000',
+      ];
+      expect(resultSet.timeSeries(timeDimension, 1, {
+        'Events.time.ten_min_fifteen_sec': {
+          title: 'Time Dimension',
+          shortTitle: 'TD',
+          type: 'time',
+          granularity: {
+            name: '10 minutes 15 seconds',
+            title: '10 minutes 15 seconds',
+            interval: '10 minutes 15 seconds',
+            origin: '2021-02-01 09:59:45',
+          },
+        },
+      })).toEqual(output);
+    });
   });
 
   describe('chartPivot', () => {
@@ -145,7 +442,7 @@ describe('ResultSet', () => {
       expect(resultSet.chartPivot()).toEqual([
         {
           x: 'Name 1',
-          
+
           'Foo.count': 'Some string',
           xValues: [
             'Name 1'
@@ -194,7 +491,7 @@ describe('ResultSet', () => {
       expect(resultSet.chartPivot()).toEqual([
         {
           x: 'Name 1',
-          
+
           'Foo.count': 0,
           xValues: [
             'Name 1'
@@ -291,7 +588,7 @@ describe('ResultSet', () => {
       expect(resultSet.chartPivot()).toEqual([
         {
           x: 'Name 1',
-          
+
           'Foo.count': 10,
           xValues: [
             'Name 1'
@@ -343,7 +640,7 @@ describe('ResultSet', () => {
       expect(resultSet.chartPivot()).toEqual([
         {
           x: 'Name 1',
-          
+
           'Foo.latestRun': new Date('2020-03-11T18:06:09.403Z'),
           xValues: [
             'Name 1'

package/src/tests/granularity.test.js

@@ -1,3 +1,5 @@
+/* globals describe,test,expect */
+
 import 'jest';
 import dayjs from 'dayjs';
 import ko from 'dayjs/locale/ko';

package/src/tests/utils.test.js

@@ -1,7 +1,7 @@
 import 'jest';
 
-import { TIME_SERIES, dayRange } from '../ResultSet';
 import { defaultOrder } from '../utils';
+import { dayRange, TIME_SERIES } from '../time';
 
 describe('utils', () => {
   test('default order', () => {