@cubejs-client/core 0.30.0 → 0.30.46

package/index.d.ts

@@ -815,7 +815,7 @@ declare module '@cubejs-client/core' {
 
   type QueryArrayRecordType<T extends DeeplyReadonly<Query[]>> =
     T extends readonly [infer First, ...infer Rest]
-      ? SingleQueryRecordType<First> | QueryArrayRecordType<Rest>
+      ? SingleQueryRecordType<First> | QueryArrayRecordType<Rest & DeeplyReadonly<Query[]>>
       : never;
 
   // If we can't infer any members at all, then return any.
@@ -1213,6 +1213,8 @@ declare module '@cubejs-client/core' {
   export function getQueryMembers(query: DeeplyReadonly<Query>): string[];
 
   export function areQueriesEqual(query1: DeeplyReadonly<Query> | null, query2: DeeplyReadonly<Query> | null): boolean;
+  
+  export function validateQuery(query: DeeplyReadonly<Query> | null | undefined): Query;
 
   export type ProgressResponse = {
     stage: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cubejs-client/core",
-  "version": "0.30.0",
+  "version": "0.30.46",
   "engines": {},
   "repository": {
     "type": "git",
@@ -46,5 +46,5 @@
     "eslint-plugin-node": "^5.2.1",
     "jest": "^26.0.1"
   },
-  "gitHead": "bc4774e0945cdf0141e344657406115e8a4597f7"
+  "gitHead": "c29f3e26e595a96f140c55049131b764e852876e"
 }

package/src/index.js

@@ -367,16 +367,5 @@ class CubejsApi {
 
 export default (apiToken, options) => new CubejsApi(apiToken, options);
 
-export { CubejsApi, HttpTransport, ResultSet };
-export {
-  areQueriesEqual,
-  defaultHeuristics,
-  movePivotItem,
-  isQueryPresent,
-  moveItemInArray,
-  defaultOrder,
-  flattenFilters,
-  getQueryMembers,
-  getOrderMembersFromOrder,
-  GRANULARITIES
-} from './utils';
+export { CubejsApi, HttpTransport, ResultSet, RequestError };
+export * from './utils';

package/src/utils.js

@@ -1,4 +1,4 @@
-import { indexBy, prop, clone, equals } from 'ramda';
+import { indexBy, prop, clone, equals, fromPairs, toPairs } from 'ramda';
 
 export const DEFAULT_GRANULARITY = 'day';
 
@@ -14,10 +14,52 @@ export const GRANULARITIES = [
   { name: 'year', title: 'Year' },
 ];
 
+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)
+    equals(
+      Object.entries((query1 && query1.order) || {}),
+      Object.entries((query2 && query2.order) || {})
+    ) && equals(query1, query2)
   );
 }
 
@@ -28,7 +70,10 @@ export function defaultOrder(query) {
     return {
       [granularity.dimension]: 'asc',
     };
-  } else if ((query.measures || []).length > 0 && (query.dimensions || []).length > 0) {
+  } else if (
+    (query.measures || []).length > 0 &&
+    (query.dimensions || []).length > 0
+  ) {
     return {
       [query.measures[0]]: 'desc',
     };
@@ -65,7 +110,8 @@ export function defaultHeuristics(newState, oldQuery = {}, options) {
       (oldQuery.timeDimensions || []).length === 1 &&
       (newQuery.timeDimensions || []).length === 1 &&
       newQuery.timeDimensions[0].granularity &&
-      oldQuery.timeDimensions[0].granularity !== newQuery.timeDimensions[0].granularity
+      oldQuery.timeDimensions[0].granularity !==
+        newQuery.timeDimensions[0].granularity
     ) {
       state = {
         ...state,
@@ -74,13 +120,16 @@ export function defaultHeuristics(newState, oldQuery = {}, options) {
     }
 
     if (
-      ((oldQuery.measures || []).length === 0 && (newQuery.measures || []).length > 0) ||
+      ((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]);
+      const defaultTimeDimension = meta.defaultTimeDimensionNameFor(
+        newQuery.measures[0]
+      );
       newQuery = {
         ...newQuery,
         timeDimensions: defaultTimeDimension
@@ -103,10 +152,16 @@ export function defaultHeuristics(newState, oldQuery = {}, options) {
       };
     }
 
-    if ((oldQuery.dimensions || []).length === 0 && (newQuery.dimensions || []).length > 0) {
+    if (
+      (oldQuery.dimensions || []).length === 0 &&
+      (newQuery.dimensions || []).length > 0
+    ) {
       newQuery = {
         ...newQuery,
-        timeDimensions: (newQuery.timeDimensions || []).map((td) => ({ ...td, granularity: undefined })),
+        timeDimensions: (newQuery.timeDimensions || []).map((td) => ({
+          ...td,
+          granularity: undefined,
+        })),
       };
 
       return {
@@ -118,7 +173,10 @@ export function defaultHeuristics(newState, oldQuery = {}, options) {
       };
     }
 
-    if ((oldQuery.dimensions || []).length > 0 && (newQuery.dimensions || []).length === 0) {
+    if (
+      (oldQuery.dimensions || []).length > 0 &&
+      (newQuery.dimensions || []).length === 0
+    ) {
       newQuery = {
         ...newQuery,
         timeDimensions: (newQuery.timeDimensions || []).map((td) => ({
@@ -137,7 +195,8 @@ export function defaultHeuristics(newState, oldQuery = {}, options) {
     }
 
     if (
-      ((oldQuery.dimensions || []).length > 0 || (oldQuery.measures || []).length > 0) &&
+      ((oldQuery.dimensions || []).length > 0 ||
+        (oldQuery.measures || []).length > 0) &&
       (newQuery.dimensions || []).length === 0 &&
       (newQuery.measures || []).length === 0
     ) {
@@ -177,7 +236,9 @@ export function defaultHeuristics(newState, oldQuery = {}, options) {
     }
 
     if (
-      (newChartType === 'pie' || newChartType === 'table' || newChartType === 'number') &&
+      (newChartType === 'pie' ||
+        newChartType === 'table' ||
+        newChartType === 'number') &&
       (oldQuery.timeDimensions || []).length === 1 &&
       oldQuery.timeDimensions[0].granularity
     ) {
@@ -209,7 +270,13 @@ export function isQueryPresent(query) {
   );
 }
 
-export function movePivotItem(pivotConfig, sourceIndex, destinationIndex, sourceAxis, destinationAxis) {
+export function movePivotItem(
+  pivotConfig,
+  sourceIndex,
+  destinationIndex,
+  sourceAxis,
+  destinationAxis
+) {
   const nextPivotConfig = {
     ...pivotConfig,
     x: [...pivotConfig.x],
@@ -220,7 +287,10 @@ export function movePivotItem(pivotConfig, sourceIndex, destinationIndex, source
 
   if (id === 'measures') {
     destinationIndex = lastIndex + 1;
-  } else if (destinationIndex >= lastIndex && nextPivotConfig[destinationAxis][lastIndex] === 'measures') {
+  } else if (
+    destinationIndex >= lastIndex &&
+    nextPivotConfig[destinationAxis][lastIndex] === 'measures'
+  ) {
     destinationIndex = lastIndex - 1;
   }
 
@@ -290,7 +360,11 @@ export function getOrderMembersFromOrder(orderMembers, order) {
 export function aliasSeries(values, index, pivotConfig, duplicateMeasures) {
   const nonNullValues = values.filter((value) => value != null);
 
-  if (pivotConfig && pivotConfig.aliasSeries && pivotConfig.aliasSeries[index]) {
+  if (
+    pivotConfig &&
+    pivotConfig.aliasSeries &&
+    pivotConfig.aliasSeries[index]
+  ) {
     return [pivotConfig.aliasSeries[index], ...nonNullValues];
   } else if (duplicateMeasures.has(nonNullValues[0])) {
     return [index, ...nonNullValues];