@cubejs-client/core 0.29.23 → 0.29.29

package/index.d.ts

@@ -27,13 +27,21 @@ declare module '@cubejs-client/core' {
   };
 
   export interface ITransportResponse<R> {
-    subscribe: <CBResult>(cb: (result: R, resubscribe: () => Promise<CBResult>) => CBResult) => Promise<CBResult>;
+    subscribe: <CBResult>(
+      cb: (
+        result: R,
+        resubscribe: () => Promise<CBResult>
+      ) => CBResult
+    ) => Promise<CBResult>;
     // Optional, supported in WebSocketTransport
     unsubscribe?: () => Promise<void>;
   }
 
   export interface ITransport<R> {
-    request(method: string, params: Record<string, unknown>): ITransportResponse<R>;
+    request(
+      method: string,
+      params: Record<string, unknown>
+    ): ITransportResponse<R>;
   }
 
   /**
@@ -80,6 +88,7 @@ declare module '@cubejs-client/core' {
     pollInterval?: number;
     credentials?: 'omit' | 'same-origin' | 'include';
     parseDateMeasures?: boolean;
+    resType?: 'default' | 'compact';
   };
 
   export type LoadMethodOptions = {
@@ -790,6 +799,7 @@ declare module '@cubejs-client/core' {
     timezone?: string;
     renewQuery?: boolean;
     ungrouped?: boolean;
+    responseFormat?: 'compact' | 'default'
   }
 
   export class ProgressResult {
@@ -993,6 +1003,7 @@ declare module '@cubejs-client/core' {
      * @param query - [Query object](query-format)
      */
     load(query: Query | Query[], options?: LoadMethodOptions, callback?: LoadMethodCallback<ResultSet>): void;
+    load(query: Query | Query[], options?: LoadMethodOptions, callback?: LoadMethodCallback<ResultSet>, responseFormat?: string):  Promise<ResultSet>;
 
     /**
      * Allows you to fetch data and receive updates over time. See [Real-Time Data Fetch](real-time-data-fetch)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubejs-client/core",
-  "version": "0.29.23",
+  "version": "0.29.29",
   "engines": {},
   "repository": {
     "type": "git",
@@ -13,6 +13,7 @@
   "types": "index.d.ts",
   "author": "Cube Dev, Inc.",
   "dependencies": {
+    "@babel/plugin-transform-runtime": "^7.17.0",
     "@babel/runtime": "^7.1.2",
     "core-js": "^3.6.5",
     "cross-fetch": "^3.0.2",
@@ -45,5 +46,5 @@
     "eslint-plugin-node": "^5.2.1",
     "jest": "^26.0.1"
   },
-  "gitHead": "da516571691c103ecbd035c3319653766622b083"
+  "gitHead": "23638ee42cceb8fc80e821486ab30825e2b9a483"
 }

package/src/index.js

@@ -10,6 +10,14 @@ let mutexCounter = 0;
 
 const MUTEX_ERROR = 'Mutex has been changed';
 
+/**
+ * Query result dataset formats enum.
+ */
+const ResultType = {
+  DEFAULT: 'default',
+  COMPACT: 'compact'
+};
+
 function mutexPromise(promise) {
   return new Promise(async (resolve, reject) => {
     try {
@@ -53,7 +61,10 @@ class CubejsApi {
   }
 
   request(method, params) {
-    return this.transport.request(method, { baseRequestId: uuidv4(), ...params });
+    return this.transport.request(method, {
+      baseRequestId: uuidv4(),
+      ...params
+    });
   }
 
   loadMethod(request, toResult, options, callback) {
@@ -70,7 +81,9 @@ class CubejsApi {
       options.mutexObj[mutexKey] = mutexValue;
     }
 
-    const requestPromise = this.updateTransportAuthorization().then(() => request());
+    const requestPromise = this
+      .updateTransportAuthorization()
+      .then(() => request());
 
     let skipAuthorizationUpdate = true;
     let unsubscribed = false;
@@ -78,7 +91,10 @@ class CubejsApi {
     const checkMutex = async () => {
       const requestInstance = await requestPromise;
 
-      if (options.mutexObj && options.mutexObj[mutexKey] !== mutexValue) {
+      if (
+        options.mutexObj &&
+        options.mutexObj[mutexKey] !== mutexValue
+      ) {
         unsubscribed = true;
         if (requestInstance.unsubscribe) {
           await requestInstance.unsubscribe();
@@ -213,18 +229,113 @@ class CubejsApi {
     }
   }
 
-  load(query, options, callback) {
+  /**
+   * Add system properties to a query object.
+   * @param {Query} query
+   * @param {string} responseFormat
+   * @returns {void}
+   * @private
+   */
+  patchQueryInternal(query, responseFormat) {
+    if (
+      responseFormat === ResultType.COMPACT &&
+      query.responseFormat !== ResultType.COMPACT
+    ) {
+      query.responseFormat = ResultType.COMPACT;
+    }
+  }
+
+  /**
+   * Process result fetched from the gateway#load method according
+   * to the network protocol.
+   * @param {*} response
+   * @returns ResultSet
+   * @private
+   */
+  loadResponseInternal(response) {
+    if (
+      response.results.length &&
+      response.results[0].query.responseFormat &&
+      response.results[0].query.responseFormat === ResultType.COMPACT
+    ) {
+      response.results.forEach((result, j) => {
+        const data = [];
+        result.data.dataset.forEach((r) => {
+          const row = {};
+          result.data.members.forEach((m, i) => {
+            row[m] = r[i];
+          });
+          data.push(row);
+        });
+        response.results[j].data = data;
+      });
+    }
+    return new ResultSet(response, {
+      parseDateMeasures: this.parseDateMeasures
+    });
+  }
+
+  /**
+   * Fetch data for the passed `query`. Operates with the
+   * `ApiGateway#load` method to fetch the data.
+   * @param {Query | Query[]} query
+   * @param {LoadMethodOptions | undefined} options
+   * @param {LoadMethodCallback<ResultSet> | undefined} callback
+   * @param {string} responseFormat
+   * @returns {undefined | Promise<ResultSet>}
+   */
+  load(query, options, callback, responseFormat = ResultType.DEFAULT) {
+    if (responseFormat === ResultType.COMPACT) {
+      if (Array.isArray(query)) {
+        query.forEach((q) => {
+          this.patchQueryInternal(q, ResultType.COMPACT);
+        });
+      } else {
+        this.patchQueryInternal(query, ResultType.COMPACT);
+      }
+    }
     return this.loadMethod(
       () => this.request('load', {
         query,
-        queryType: 'multi'
+        queryType: 'multi',
       }),
-      (response) => new ResultSet(response, { parseDateMeasures: this.parseDateMeasures }),
+      this.loadResponseInternal.bind(this),
       options,
       callback
     );
   }
 
+  /**
+   * Allows you to fetch data and receive updates over time. Operates
+   * with the `ApiGateway#load` method to fetch the data.
+   * @link real-time-data-fetch
+   * @param {Query | Query[]} query
+   * @param {LoadMethodOptions | null} options
+   * @param {LoadMethodCallback<ResultSet> | undefined} callback
+   * @param {string} responseFormat
+   * @returns {void}
+   */
+  subscribe(query, options, callback, responseFormat = ResultType.DEFAULT) {
+    if (responseFormat === ResultType.COMPACT) {
+      if (Array.isArray(query)) {
+        query.forEach((q) => {
+          this.patchQueryInternal(q, ResultType.COMPACT);
+        });
+      } else {
+        this.patchQueryInternal(query, ResultType.COMPACT);
+      }
+    }
+    return this.loadMethod(
+      () => this.request('subscribe', {
+        query,
+        queryType: 'multi',
+      }),
+      this.loadResponseInternal.bind(this),
+      { ...options, subscribe: true },
+      callback
+    );
+  }
+
   sql(query, options, callback) {
     return this.loadMethod(
       () => this.request('sql', { query }),
@@ -251,18 +362,6 @@ class CubejsApi {
       callback
     );
   }
-
-  subscribe(query, options, callback) {
-    return this.loadMethod(
-      () => this.request('subscribe', {
-        query,
-        queryType: 'multi'
-      }),
-      (body) => new ResultSet(body, { parseDateMeasures: this.parseDateMeasures }),
-      { ...options, subscribe: true },
-      callback
-    );
-  }
 }
 
 export default (apiToken, options) => new CubejsApi(apiToken, options);

package/src/index.test.js

@@ -0,0 +1,454 @@
+/**
+ * @license Apache-2.0
+ * @copyright Cube Dev, Inc.
+ * @fileoverview CubejsApi class unit tests.
+ */
+
+/* globals describe,test,expect,beforeEach,jest */
+
+import ResultSet from './ResultSet';
+import { CubejsApi } from './index';
+
+jest.mock('./ResultSet');
+beforeEach(() => {
+  ResultSet.mockClear();
+});
+
+const mockData = {
+  regular_1: {
+    result_default: [
+      {
+        'ECommerceRecordsUs2021.city': 'Missouri City',
+        'ECommerceRecordsUs2021.avg_discount': '0.80000000000000000000'
+      },
+      {
+        'ECommerceRecordsUs2021.city': 'Abilene',
+        'ECommerceRecordsUs2021.avg_discount': '0.80000000000000000000'
+      }
+    ],
+    result_compact: {
+      members: ['ECommerceRecordsUs2021.city', 'ECommerceRecordsUs2021.avg_discount'],
+      dataset: [['Missouri City', '0.80000000000000000000'], ['Abilene', '0.80000000000000000000']],
+    }
+  },
+  regular_2: {
+    result_default: [
+      {
+        'ECommerceRecordsUs2021.postalCode': '95823',
+        'ECommerceRecordsUs2021.avg_profit': '646.1258666666666667'
+      },
+      {
+        'ECommerceRecordsUs2021.postalCode': '64055',
+        'ECommerceRecordsUs2021.avg_profit': '487.8315000000000000'
+      }
+    ],
+    result_compact: {
+      members: [
+        'ECommerceRecordsUs2021.postalCode',
+        'ECommerceRecordsUs2021.avg_profit',
+      ],
+      dataset: [
+        ['95823', '646.1258666666666667'],
+        ['64055', '487.8315000000000000']
+      ],
+    }
+  },
+  compare: [{
+    result_default: [
+      {
+        'ECommerceRecordsUs2021.orderDate.day': '2020-01-01T00:00:00.000',
+        'ECommerceRecordsUs2021.orderDate': '2020-01-01T00:00:00.000',
+        'ECommerceRecordsUs2021.count': '10',
+        compareDateRange: '2020-01-01T00:00:00.000 - 2020-01-31T23:59:59.999'
+      },
+      {
+        'ECommerceRecordsUs2021.orderDate.day': '2020-01-02T00:00:00.000',
+        'ECommerceRecordsUs2021.orderDate': '2020-01-02T00:00:00.000',
+        'ECommerceRecordsUs2021.count': '8',
+        compareDateRange: '2020-01-01T00:00:00.000 - 2020-01-31T23:59:59.999'
+      }
+    ],
+    result_compact: {
+      members: [
+        'ECommerceRecordsUs2021.orderDate.day',
+        'ECommerceRecordsUs2021.orderDate',
+        'ECommerceRecordsUs2021.count',
+        'compareDateRange',
+      ],
+      dataset: [
+        [
+          '2020-01-01T00:00:00.000',
+          '2020-01-01T00:00:00.000',
+          '10',
+          '2020-01-01T00:00:00.000 - 2020-01-31T23:59:59.999',
+        ],
+        [
+          '2020-01-02T00:00:00.000',
+          '2020-01-02T00:00:00.000',
+          '8',
+          '2020-01-01T00:00:00.000 - 2020-01-31T23:59:59.999'
+        ],
+      ],
+    },
+  }, {
+    result_default: [
+      {
+        'ECommerceRecordsUs2021.orderDate.day': '2020-03-02T00:00:00.000',
+        'ECommerceRecordsUs2021.orderDate': '2020-03-02T00:00:00.000',
+        'ECommerceRecordsUs2021.count': '11',
+        compareDateRange: '2020-03-01T00:00:00.000 - 2020-03-31T23:59:59.999'
+      },
+      {
+        'ECommerceRecordsUs2021.orderDate.day': '2020-03-03T00:00:00.000',
+        'ECommerceRecordsUs2021.orderDate': '2020-03-03T00:00:00.000',
+        'ECommerceRecordsUs2021.count': '7',
+        compareDateRange: '2020-03-01T00:00:00.000 - 2020-03-31T23:59:59.999'
+      }
+    ],
+    result_compact: {
+      members: [
+        'ECommerceRecordsUs2021.orderDate.day',
+        'ECommerceRecordsUs2021.orderDate',
+        'ECommerceRecordsUs2021.count',
+        'compareDateRange',
+      ],
+      dataset: [
+        [
+          '2020-03-02T00:00:00.000',
+          '2020-03-02T00:00:00.000',
+          '11',
+          '2020-03-01T00:00:00.000 - 2020-03-31T23:59:59.999',
+        ],
+        [
+          '2020-03-03T00:00:00.000',
+          '2020-03-03T00:00:00.000',
+          '7',
+          '2020-03-01T00:00:00.000 - 2020-03-31T23:59:59.999'
+        ],
+      ],
+    },
+  }],
+  blending: [{
+    result_default: [
+      {
+        'ECommerceRecordsUs2021.orderDate.month': '2020-01-01T00:00:00.000',
+        'ECommerceRecordsUs2021.orderDate': '2020-01-01T00:00:00.000',
+        'ECommerceRecordsUs2021.avg_discount': '0.15638297872340425532',
+        'time.month': '2020-01-01T00:00:00.000'
+      },
+      {
+        'ECommerceRecordsUs2021.orderDate.month': '2020-02-01T00:00:00.000',
+        'ECommerceRecordsUs2021.orderDate': '2020-02-01T00:00:00.000',
+        'ECommerceRecordsUs2021.avg_discount': '0.17573529411764705882',
+        'time.month': '2020-02-01T00:00:00.000'
+      }
+    ],
+    result_compact: {
+      members: [
+        'ECommerceRecordsUs2021.orderDate.month',
+        'ECommerceRecordsUs2021.orderDate',
+        'ECommerceRecordsUs2021.avg_discount',
+        'time.month',
+      ],
+      dataset: [
+        [
+          '2020-01-01T00:00:00.000',
+          '2020-01-01T00:00:00.000',
+          '0.15638297872340425532',
+          '2020-01-01T00:00:00.000',
+        ],
+        [
+          '2020-02-01T00:00:00.000',
+          '2020-02-01T00:00:00.000',
+          '0.17573529411764705882',
+          '2020-02-01T00:00:00.000',
+        ],
+      ],
+    },
+  }, {
+    result_default: [{
+      'ECommerceRecordsUs2021.orderDate.month': '2020-01-01T00:00:00.000',
+      'ECommerceRecordsUs2021.orderDate': '2020-01-01T00:00:00.000',
+      'ECommerceRecordsUs2021.avg_discount': '0.28571428571428571429',
+      'time.month': '2020-01-01T00:00:00.000'
+    },
+    {
+      'ECommerceRecordsUs2021.orderDate.month': '2020-02-01T00:00:00.000',
+      'ECommerceRecordsUs2021.orderDate': '2020-02-01T00:00:00.000',
+      'ECommerceRecordsUs2021.avg_discount': '0.21777777777777777778',
+      'time.month': '2020-02-01T00:00:00.000'
+    }],
+    result_compact: {
+      members: [
+        'ECommerceRecordsUs2021.orderDate.month',
+        'ECommerceRecordsUs2021.orderDate',
+        'ECommerceRecordsUs2021.avg_discount',
+        'time.month',
+      ],
+      dataset: [
+        [
+          '2020-01-01T00:00:00.000',
+          '2020-01-01T00:00:00.000',
+          '0.28571428571428571429',
+          '2020-01-01T00:00:00.000',
+        ],
+        [
+          '2020-02-01T00:00:00.000',
+          '2020-02-01T00:00:00.000',
+          '0.21777777777777777778',
+          '2020-02-01T00:00:00.000',
+        ],
+      ],
+    },
+  }],
+};
+
+describe('CubejsApi', () => {
+  test('CubejsApi#loadResponseInternal should work with the "default" resType for regular query', () => {
+    const api = new CubejsApi(undefined, {
+      apiUrl: 'http://localhost:4000/cubejs-api/v1',
+    });
+    const income = {
+      results: [{
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.regular_1.result_default
+          )
+        )
+      }],
+    };
+    const outcome = {
+      results: [{
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.regular_1.result_default
+          )
+        )
+      }],
+    };
+    api.loadResponseInternal(income);
+    expect(ResultSet).toHaveBeenCalled();
+    expect(ResultSet).toHaveBeenCalledTimes(1);
+    expect(ResultSet).toHaveBeenCalledWith(outcome, {
+      parseDateMeasures: undefined
+    });
+  });
+
+  test('CubejsApi#loadResponseInternal should work with the "default" resType for compare date range query', () => {
+    const api = new CubejsApi(undefined, {
+      apiUrl: 'http://localhost:4000/cubejs-api/v1',
+    });
+    const income = {
+      results: [{
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[0].result_default
+          )
+        )
+      }, {
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[1].result_default
+          )
+        )
+      }],
+    };
+    const outcome = {
+      results: [{
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[0].result_default
+          )
+        )
+      }, {
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[1].result_default
+          )
+        )
+      }],
+    };
+    api.loadResponseInternal(income);
+    expect(ResultSet).toHaveBeenCalled();
+    expect(ResultSet).toHaveBeenCalledTimes(1);
+    expect(ResultSet).toHaveBeenCalledWith(outcome, {
+      parseDateMeasures: undefined
+    });
+  });
+
+  test('CubejsApi#loadResponseInternal should work with the "default" resType for blending query', () => {
+    const api = new CubejsApi(undefined, {
+      apiUrl: 'http://localhost:4000/cubejs-api/v1',
+    });
+    const income = {
+      results: [{
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[0].result_default
+          )
+        )
+      }, {
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[1].result_default
+          )
+        )
+      }],
+    };
+    const outcome = {
+      results: [{
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[0].result_default
+          )
+        )
+      }, {
+        query: {},
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[1].result_default
+          )
+        )
+      }],
+    };
+    api.loadResponseInternal(income);
+    expect(ResultSet).toHaveBeenCalled();
+    expect(ResultSet).toHaveBeenCalledTimes(1);
+    expect(ResultSet).toHaveBeenCalledWith(outcome, {
+      parseDateMeasures: undefined
+    });
+  });
+
+  test('CubejsApi#loadResponseInternal should work with the "compact" resType for regular query', () => {
+    const api = new CubejsApi(undefined, {
+      apiUrl: 'http://localhost:4000/cubejs-api/v1',
+    });
+    const income = {
+      results: [{
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.regular_1.result_compact
+          )
+        )
+      }],
+    };
+    const outcome = {
+      results: [{
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.regular_1.result_default
+          )
+        )
+      }],
+    };
+    api.loadResponseInternal(income);
+    expect(ResultSet).toHaveBeenCalled();
+    expect(ResultSet).toHaveBeenCalledTimes(1);
+    expect(ResultSet).toHaveBeenCalledWith(outcome, {
+      parseDateMeasures: undefined
+    });
+  });
+
+  test('CubejsApi#loadResponseInternal should work with the "compact" resType for compare date range query', () => {
+    const api = new CubejsApi(undefined, {
+      apiUrl: 'http://localhost:4000/cubejs-api/v1',
+    });
+    const income = {
+      results: [{
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[0].result_compact
+          )
+        )
+      }, {
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[1].result_compact
+          )
+        )
+      }],
+    };
+    const outcome = {
+      results: [{
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[0].result_default
+          )
+        )
+      }, {
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.compare[1].result_default
+          )
+        )
+      }],
+    };
+    api.loadResponseInternal(income);
+    expect(ResultSet).toHaveBeenCalled();
+    expect(ResultSet).toHaveBeenCalledTimes(1);
+    expect(ResultSet).toHaveBeenCalledWith(outcome, {
+      parseDateMeasures: undefined
+    });
+  });
+
+  test('CubejsApi#loadResponseInternal should work with the "compact" resType for blending query', () => {
+    const api = new CubejsApi(undefined, {
+      apiUrl: 'http://localhost:4000/cubejs-api/v1',
+    });
+    const income = {
+      results: [{
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[0].result_compact
+          )
+        )
+      }, {
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[1].result_compact
+          )
+        )
+      }],
+    };
+    const outcome = {
+      results: [{
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[0].result_default
+          )
+        )
+      }, {
+        query: { responseFormat: 'compact' },
+        data: JSON.parse(
+          JSON.stringify(
+            mockData.blending[1].result_default
+          )
+        )
+      }],
+    };
+    api.loadResponseInternal(income);
+    expect(ResultSet).toHaveBeenCalled();
+    expect(ResultSet).toHaveBeenCalledTimes(1);
+    expect(ResultSet).toHaveBeenCalledWith(outcome, {
+      parseDateMeasures: undefined
+    });
+  });
+});