@cubejs-client/core 0.29.53 → 0.30.4

package/index.d.ts

@@ -808,6 +808,36 @@ declare module '@cubejs-client/core' {
     total?: boolean;
   }
 
+  export type QueryRecordType<T extends DeeplyReadonly<Query | Query[]>> =
+    T extends DeeplyReadonly<Query[]> ? QueryArrayRecordType<T> :
+    T extends DeeplyReadonly<Query> ? SingleQueryRecordType<T> :
+    never;
+
+  type QueryArrayRecordType<T extends DeeplyReadonly<Query[]>> =
+    T extends readonly [infer First, ...infer Rest]
+      ? SingleQueryRecordType<First> | QueryArrayRecordType<Rest>
+      : never;
+
+  // If we can't infer any members at all, then return any.
+  type SingleQueryRecordType<T extends DeeplyReadonly<Query>> = ExtractMembers<T> extends never
+    ? any
+    : { [K in string & ExtractMembers<T>]: string | number | boolean | null };
+
+  type ExtractMembers<T extends DeeplyReadonly<Query>> =
+    | ( T extends { dimensions: readonly (infer Names)[]; } ? Names : never )
+    | ( T extends { measures: readonly (infer Names)[]; } ? Names : never )
+    | ( T extends { timeDimensions: (infer U); } ? ExtractTimeMembers<U> : never );
+
+  type ExtractTimeMembers<T> =
+    T extends readonly [infer First, ...infer Rest]
+      ? ExtractTimeMember<First> | ExtractTimeMembers<Rest>
+      : never;
+
+  type ExtractTimeMember<T> =
+    T extends { dimension: infer Dimension, granularity: infer Granularity }
+      ? Dimension | `${Dimension & string}.${Granularity & string}`
+      : never;
+
   export class ProgressResult {
     stage(): string;
     timeElapsed(): string;
@@ -983,7 +1013,10 @@ declare module '@cubejs-client/core' {
    * @order 2
    */
   export class CubejsApi {
-    load(query: DeeplyReadonly<Query | Query[]>, options?: LoadMethodOptions): Promise<ResultSet>;
+    load<QueryType extends DeeplyReadonly<Query | Query[]>>(
+      query: QueryType,
+      options?: LoadMethodOptions,
+    ): Promise<ResultSet<QueryRecordType<QueryType>>>;
     /**
      * Fetch data for the passed `query`.
      *
@@ -1008,13 +1041,18 @@ declare module '@cubejs-client/core' {
      * ```
      * @param query - [Query object](query-format)
      */
-    load(query: DeeplyReadonly<Query | Query[]>, options?: LoadMethodOptions, callback?: LoadMethodCallback<ResultSet>): void;
-    load(
-      query: DeeplyReadonly<Query | Query[]>,
+    load<QueryType extends DeeplyReadonly<Query | Query[]>>(
+      query: QueryType,
+      options?: LoadMethodOptions,
+      callback?: LoadMethodCallback<ResultSet<QueryRecordType<QueryType>>>,
+    ): void;
+
+    load<QueryType extends DeeplyReadonly<Query | Query[]>>(
+      query: QueryType,
       options?: LoadMethodOptions,
       callback?: LoadMethodCallback<ResultSet>,
       responseFormat?: string
-    ): Promise<ResultSet>;
+    ): Promise<ResultSet<QueryRecordType<QueryType>>>;
 
     /**
      * Allows you to fetch data and receive updates over time. See [Real-Time Data Fetch](real-time-data-fetch)
@@ -1040,7 +1078,11 @@ declare module '@cubejs-client/core' {
      * );
      * ```
      */
-    subscribe(query: DeeplyReadonly<Query | Query[]>, options: LoadMethodOptions | null, callback: LoadMethodCallback<ResultSet>): void;
+    subscribe<QueryType extends DeeplyReadonly<Query | Query[]>>(
+      query: QueryType,
+      options: LoadMethodOptions | null,
+      callback: LoadMethodCallback<ResultSet<QueryRecordType<QueryType>>>,
+    ): void;
 
     sql(query: DeeplyReadonly<Query | Query[]>, options?: LoadMethodOptions): Promise<SqlQuery>;
     /**
@@ -1171,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.29.53",
+  "version": "0.30.4",
   "engines": {},
   "repository": {
     "type": "git",
@@ -46,5 +46,5 @@
     "eslint-plugin-node": "^5.2.1",
     "jest": "^26.0.1"
   },
-  "gitHead": "b2815b43b973199420267695877b57eb6d744978"
+  "gitHead": "b7df8f6a3cfe104e639e0f7607868afa193ed0a3"
 }

package/src/index.js

@@ -368,15 +368,4 @@ 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 * 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];