@cubejs-client/core 0.29.23 → 0.29.42

package/index.d.ts

@@ -8,7 +8,6 @@
  */
 
 declare module '@cubejs-client/core' {
-
   export type TransportOptions = {
     /**
      * [jwt auth token](security)
@@ -80,6 +79,7 @@ declare module '@cubejs-client/core' {
     pollInterval?: number;
     credentials?: 'omit' | 'same-origin' | 'include';
     parseDateMeasures?: boolean;
+    resType?: 'default' | 'compact';
   };
 
   export type LoadMethodOptions = {
@@ -131,6 +131,12 @@ declare module '@cubejs-client/core' {
 
   type QueryType = 'regularQuery' | 'compareDateRangeQuery' | 'blendingQuery';
 
+  type LeafMeasure = {
+    measure: string;
+    additive: boolean;
+    type: 'count' | 'countDistinct' | 'sum' | 'min' | 'max' | 'number' | 'countDistinctApprox'
+  };
+
   export type TransformedQuery = {
     allFiltersWithinSelectedDimensions: boolean;
     granularityHierarchies: Record<string, string[]>;
@@ -142,6 +148,7 @@ declare module '@cubejs-client/core' {
     measures: string[];
     sortedDimensions: string[];
     sortedTimeDimensions: [[string, string]];
+    measureToLeafMeasures?: Record<string, LeafMeasure[]>;
   };
 
   export type PreAggregationType = 'rollup' | 'rollupJoin' | 'originalSql';
@@ -159,7 +166,7 @@ declare module '@cubejs-client/core' {
     external: boolean | null;
     dbType: string;
     extDbType: string;
-    requestId?: string,
+    requestId?: string;
     usedPreAggregations?: Record<string, UsedPreAggregation>;
     transformedQuery?: TransformedQuery;
   };
@@ -790,6 +797,7 @@ declare module '@cubejs-client/core' {
     timezone?: string;
     renewQuery?: boolean;
     ungrouped?: boolean;
+    responseFormat?: 'compact' | 'default';
   }
 
   export class ProgressResult {
@@ -993,6 +1001,12 @@ 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.42",
   "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": "d05b5199da6e06f4d8baaed1baddb56cf1538637"
 }

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);