@cubejs-client/core

Vanilla JavaScript Cube.js client.

cubejs

cubejs(apiToken: string | () => Promise<string>, options: CubeJSApiOptions): CubejsApi

Creates an instance of the CubejsApi. The API entry point.

import cubejs from '@cubejs-client/core';
const cubejsApi = cubejs(
  'CUBEJS-API-TOKEN',
  { apiUrl: 'http://localhost:4000/cubejs-api/v1' }
);

You can also pass an async function or a promise that will resolve to the API token

import cubejs from '@cubejs-client/core';
const cubejsApi = cubejs(
  async () => await Auth.getJwtToken(),
  { apiUrl: 'http://localhost:4000/cubejs-api/v1' }
);

Parameters:

Name	Type	Description
`apiToken`	`string \| () => Promise<string>`
`options`	`CubeJSApiOptions`

cubejs(options: CubeJSApiOptions): CubejsApi

areQueriesEqual

areQueriesEqual(query1: DeeplyReadonly<Query> | null, query2: DeeplyReadonly<Query> | null): boolean

defaultHeuristics

defaultHeuristics(newState: TDefaultHeuristicsState, oldQuery: Query, options: TDefaultHeuristicsOptions): TDefaultHeuristicsResponse

defaultOrder

defaultOrder(query: DeeplyReadonly<Query>): object

movePivotItem

movePivotItem(pivotConfig: PivotConfig, sourceIndex: number, destinationIndex: number, sourceAxis: TSourceAxis, destinationAxis: TSourceAxis): PivotConfig

validateQuery

validateQuery(query: DeeplyReadonly<Query> | null | undefined): Query

CubejsApi

Main class for accessing Cube.js API

dryRun

dryRun(query: DeeplyReadonly<Query | Query[]>, options?: LoadMethodOptions): Promise<DryRunResponse>

dryRun(query: DeeplyReadonly<Query | Query[]>, options: LoadMethodOptions, callback?: LoadMethodCallback<DryRunResponse>): UnsubscribeObj

Get query related meta without query execution

load

load<QueryType>(query: QueryType, options?: LoadMethodOptions): Promise<ResultSet<QueryRecordType<QueryType>>>

Type parameters:

QueryType: DeeplyReadonly<Query | Query[]>

load<QueryType>(query: QueryType, options?: LoadMethodOptions, callback?: LoadMethodCallback<ResultSet<QueryRecordType<QueryType>>>): UnsubscribeObj

Fetch data for the passed query.

import cubejs from '@cubejs-client/core';
import Chart from 'chart.js';
import chartjsConfig from './toChartjsData';

const cubejsApi = cubejs('CUBEJS_TOKEN');

const resultSet = await cubejsApi.load({
 measures: ['Stories.count'],
 timeDimensions: [{
   dimension: 'Stories.time',
   dateRange: ['2015-01-01', '2015-12-31'],
   granularity: 'month'
  }]
});

const context = document.getElementById('myChart');
new Chart(context, chartjsConfig(resultSet));

Type parameters:

QueryType: DeeplyReadonly<Query | Query[]>

Parameters:

Name	Type	Description
`query`	`QueryType`
`options?`	`LoadMethodOptions`
`callback?`	`LoadMethodCallback<ResultSet<QueryRecordType<QueryType>>>`

load<QueryType>(query: QueryType, options?: LoadMethodOptions, callback?: LoadMethodCallback<ResultSet>, responseFormat?: string): Promise<ResultSet<QueryRecordType<QueryType>>>

Type parameters:

QueryType: DeeplyReadonly<Query | Query[]>

sql

sql(query: DeeplyReadonly<Query | Query[]>, options?: LoadMethodOptions): Promise<SqlQuery>

sql(query: DeeplyReadonly<Query | Query[]>, options?: LoadMethodOptions, callback?: LoadMethodCallback<SqlQuery>): UnsubscribeObj

Get generated SQL string for the given query.

Parameters:

Name	Type	Description
`query`	`DeeplyReadonly<Query \| Query[]>`
`options?`	`LoadMethodOptions`
`callback?`	`LoadMethodCallback<SqlQuery>`

subscribe<QueryType>(query: QueryType, options: LoadMethodOptions | null, callback: LoadMethodCallback<ResultSet<QueryRecordType<QueryType>>>): UnsubscribeObj

Allows you to fetch data and receive updates over time. See Real-Time Data Fetch

cubejsApi.subscribe(
  {
    measures: ['Logs.count'],
    timeDimensions: [
      {
        dimension: 'Logs.time',
        granularity: 'hour',
        dateRange: 'last 1440 minutes',
      },
    ],
  },
  options,
  (error, resultSet) => {
    if (!error) {
      // handle the update
    }
  }
);

Type parameters:

QueryType: DeeplyReadonly<Query | Query[]>

HttpTransport

Default transport implementation.

constructor

new HttpTransport(options: TransportOptions): HttpTransport

request

request(method: string, params: any): ITransportResponse<ResultSet>

Name	Type	Description
`query`	`DeeplyReadonly<Query> \| null`
`memberType`	`MemberType`

Name	Type	Description
`memberName`	`string`
`memberType`	`T \| T[]`

timeElapsed

timeElapsed(): string

ResultSet

Provides a convenient interface for data manipulation.

annotation

annotation(): QueryAnnotations

chartPivot

chartPivot(pivotConfig?: PivotConfig): ChartPivotRow[]

Returns normalized query result data in the following format.

You can find the examples of using the pivotConfig here

// For the query
{
  measures: ['Stories.count'],
  timeDimensions: [{
    dimension: 'Stories.time',
    dateRange: ['2015-01-01', '2015-12-31'],
    granularity: 'month'
  }]
}

// ResultSet.chartPivot() will return
[
  { "x":"2015-01-01T00:00:00", "Stories.count": 27120, "xValues": ["2015-01-01T00:00:00"] },
  { "x":"2015-02-01T00:00:00", "Stories.count": 25861, "xValues": ["2015-02-01T00:00:00"]  },
  { "x":"2015-03-01T00:00:00", "Stories.count": 29661, "xValues": ["2015-03-01T00:00:00"]  },
  //...
]

When using chartPivot() or seriesNames(), you can pass aliasSeries in the pivotConfig to give each series a unique prefix. This is useful for blending queries which use the same measure multiple times.

// For the queries
{
  measures: ['Stories.count'],
  timeDimensions: [
    {
      dimension: 'Stories.time',
      dateRange: ['2015-01-01', '2015-12-31'],
      granularity: 'month',
    },
  ],
},
{
  measures: ['Stories.count'],
  timeDimensions: [
    {
      dimension: 'Stories.time',
      dateRange: ['2015-01-01', '2015-12-31'],
      granularity: 'month',
    },
  ],
  filters: [
    {
      member: 'Stores.read',
      operator: 'equals',
      value: ['true'],
    },
  ],
},

// ResultSet.chartPivot({ aliasSeries: ['one', 'two'] }) will return
[
  {
    x: '2015-01-01T00:00:00',
    'one,Stories.count': 27120,
    'two,Stories.count': 8933,
    xValues: ['2015-01-01T00:00:00'],
  },
  {
    x: '2015-02-01T00:00:00',
    'one,Stories.count': 25861,
    'two,Stories.count': 8344,
    xValues: ['2015-02-01T00:00:00'],
  },
  {
    x: '2015-03-01T00:00:00',
    'one,Stories.count': 29661,
    'two,Stories.count': 9023,
    xValues: ['2015-03-01T00:00:00'],
  },
  //...
];

decompose

decompose(): ResultSet[]

Can be used when you need access to the methods that can't be used with some query types (eg compareDateRangeQuery or blendingQuery)

resultSet.decompose().forEach((currentResultSet) => {
  console.log(currentResultSet.rawData());
});

drillDown

drillDown(drillDownLocator: DrillDownLocator, pivotConfig?: PivotConfig): Query | null

Returns a measure drill down query.

Provided you have a measure with the defined drillMemebers on the Orders cube

measures: {
  count: {
    type: `count`,
    drillMembers: [Orders.status, Users.city, count],
  },
  // ...
}

Then you can use the drillDown method to see the rows that contribute to that metric

resultSet.drillDown(
  {
    xValues,
    yValues,
  },
  // you should pass the `pivotConfig` if you have used it for axes manipulation
  pivotConfig
)

the result will be a query with the required filters applied and the dimensions/measures filled out

{
  measures: ['Orders.count'],
  dimensions: ['Orders.status', 'Users.city'],
  filters: [
    // dimension and measure filters
  ],
  timeDimensions: [
    //...
  ]
}

In case when you want to add order or limit to the query, you can simply spread it

// An example for React
const drillDownResponse = useCubeQuery(
   {
     ...drillDownQuery,
     limit: 30,
     order: {
       'Orders.ts': 'desc'
     }
   },
   {
     skip: !drillDownQuery
   }
 );

pivot

pivot(pivotConfig?: PivotConfig): PivotRow[]

Base method for pivoting ResultSet data. Most of the times shouldn't be used directly and chartPivot or tablePivot should be used instead.

You can find the examples of using the pivotConfig here

// For query
{
  measures: ['Stories.count'],
  timeDimensions: [{
    dimension: 'Stories.time',
    dateRange: ['2015-01-01', '2015-03-31'],
    granularity: 'month'
  }]
}

// ResultSet.pivot({ x: ['Stories.time'], y: ['measures'] }) will return
[
  {
    xValues: ["2015-01-01T00:00:00"],
    yValuesArray: [
      [['Stories.count'], 27120]
    ]
  },
  {
    xValues: ["2015-02-01T00:00:00"],
    yValuesArray: [
      [['Stories.count'], 25861]
    ]
  },
  {
    xValues: ["2015-03-01T00:00:00"],
    yValuesArray: [
      [['Stories.count'], 29661]
    ]
  }
]

query

query(): Query

rawData

rawData(): T[]

serialize

serialize(): SerializedResult

Can be used to stash the ResultSet in a storage and restored later with deserialize

series

series<SeriesItem>(pivotConfig?: PivotConfig): Series<SeriesItem>[]

Returns an array of series with key, title and series data.

// For the query
{
  measures: ['Stories.count'],
  timeDimensions: [{
    dimension: 'Stories.time',
    dateRange: ['2015-01-01', '2015-12-31'],
    granularity: 'month'
  }]
}

// ResultSet.series() will return
[
  {
    key: 'Stories.count',
    title: 'Stories Count',
    series: [
      { x: '2015-01-01T00:00:00', value: 27120 },
      { x: '2015-02-01T00:00:00', value: 25861 },
      { x: '2015-03-01T00:00:00', value: 29661 },
      //...
    ],
  },
]

Type parameters:

SeriesItem

seriesNames

seriesNames(pivotConfig?: PivotConfig): SeriesNamesColumn[]

Returns an array of series objects, containing key and title parameters.

// For query
{
  measures: ['Stories.count'],
  timeDimensions: [{
    dimension: 'Stories.time',
    dateRange: ['2015-01-01', '2015-12-31'],
    granularity: 'month'
  }]
}

// ResultSet.seriesNames() will return
[
  {
    key: 'Stories.count',
    title: 'Stories Count',
    yValues: ['Stories.count'],
  },
]

tableColumns

tableColumns(pivotConfig?: PivotConfig): TableColumn[]

Returns an array of column definitions for tablePivot.

For example:

// For the query
{
  measures: ['Stories.count'],
  timeDimensions: [{
    dimension: 'Stories.time',
    dateRange: ['2015-01-01', '2015-12-31'],
    granularity: 'month'
  }]
}

// ResultSet.tableColumns() will return
[
  {
    key: 'Stories.time',
    dataIndex: 'Stories.time',
    title: 'Stories Time',
    shortTitle: 'Time',
    type: 'time',
    format: undefined,
  },
  {
    key: 'Stories.count',
    dataIndex: 'Stories.count',
    title: 'Stories Count',
    shortTitle: 'Count',
    type: 'count',
    format: undefined,
  },
  //...
]

In case we want to pivot the table axes

// Let's take this query as an example
{
  measures: ['Orders.count'],
  dimensions: ['Users.country', 'Users.gender']
}

// and put the dimensions on `y` axis
resultSet.tableColumns({
  x: [],
  y: ['Users.country', 'Users.gender', 'measures']
})

then tableColumns will group the table head and return

{
  key: 'Germany',
  type: 'string',
  title: 'Users Country Germany',
  shortTitle: 'Germany',
  meta: undefined,
  format: undefined,
  children: [
    {
      key: 'male',
      type: 'string',
      title: 'Users Gender male',
      shortTitle: 'male',
      meta: undefined,
      format: undefined,
      children: [
        {
          // ...
          dataIndex: 'Germany.male.Orders.count',
          shortTitle: 'Count',
        },
      ],
    },
    {
      // ...
      shortTitle: 'female',
      children: [
        {
          // ...
          dataIndex: 'Germany.female.Orders.count',
          shortTitle: 'Count',
        },
      ],
    },
  ],
},
// ...

tablePivot

tablePivot(pivotConfig?: PivotConfig): Array<object>

Returns normalized query result data prepared for visualization in the table format.

You can find the examples of using the pivotConfig here

For example:

// For the query
{
  measures: ['Stories.count'],
  timeDimensions: [{
    dimension: 'Stories.time',
    dateRange: ['2015-01-01', '2015-12-31'],
    granularity: 'month'
  }]
}

// ResultSet.tablePivot() will return
[
  { "Stories.time": "2015-01-01T00:00:00", "Stories.count": 27120 },
  { "Stories.time": "2015-02-01T00:00:00", "Stories.count": 25861 },
  { "Stories.time": "2015-03-01T00:00:00", "Stories.count": 29661 },
  //...
]

tableRow

tableRow(): ChartPivotRow

totalRow

totalRow(pivotConfig?: PivotConfig): ChartPivotRow

deserialize

static deserialize<TData>(data: Object, options?: Object): ResultSet<TData>

import { ResultSet } from '@cubejs-client/core';

const resultSet = await cubejsApi.load(query);
// You can store the result somewhere
const tmp = resultSet.serialize();

// and restore it later
const resultSet = ResultSet.deserialize(tmp);

Type parameters:

TData

Parameters:

Name	Type	Description
`data`	`Object`
`options?`	`Object`

getNormalizedPivotConfig

static getNormalizedPivotConfig(query: PivotQuery, pivotConfig?: Partial<PivotConfig>): PivotConfig

SqlQuery

rawQuery

rawQuery(): SqlData

sql

sql(): string

BinaryFilter

dimension

 dimension? : string

deprecated Use member instead.

member

 member? : string

operator

 operator: BinaryOperator

values

 values: string[]

ITransport

request

request(method: string, params: Record<string, unknown>): ITransportResponse<R>

ITransportResponse

 subscribe: function

unsubscribe

 unsubscribe? : function

Query

dimensions

 dimensions? : string[]

filters

 filters? : Filter[]

limit

 limit? : null | number

measures

 measures? : string[]

offset

 offset? : number

order

 order? : TQueryOrderObject | TQueryOrderArray

renewQuery

 renewQuery? : boolean

responseFormat

 responseFormat? : "compact" | "default"

segments

 segments? : string[]

timeDimensions

 timeDimensions? : TimeDimension[]

timezone

 timezone? : string

total

 total? : boolean

ungrouped

 ungrouped? : boolean

TFlatFilter

dimension

 dimension? : string

deprecated Use member instead.

member

 member? : string

operator

 operator: BinaryOperator

values

 values: string[]

TimeDimensionBase

dimension

 dimension: string

granularity

 granularity? : TimeDimensionGranularity

UnaryFilter

dimension

 dimension? : string

deprecated Use member instead.

member

 member? : string

operator

 operator: UnaryOperator

values

 values? : never

UnsubscribeObj

unsubscribe

unsubscribe(): Promise<void>

Allows to stop requests in-flight in long polling or web socket subscribe loops. It doesn't cancel any submitted requests to the underlying databases.

Types

Annotation

Name	Type
`format?`	`"currency" \| "percent" \| "number"`
`shortTitle`	`string`
`title`	`string`
`type`	`string`

BaseCubeMember

Name	Type
`isVisible?`	`boolean`
`meta?`	`any`
`name`	`string`
`shortTitle`	`string`
`title`	`string`
`type`	`TCubeMemberType`

BinaryOperator

 BinaryOperator: "equals" | "notEquals" | "contains" | "notContains" | "startsWith" | "notStartsWith" | "endsWith" | "notEndsWith" | "gt" | "gte" | "lt" | "lte" | "inDateRange" | "notInDateRange" | "beforeDate" | "afterDate"

ChartPivotRow

Name	Type
`x`	`string`
`xValues`	`string[]`

ChartType

 ChartType: "line" | "bar" | "table" | "area" | "number" | "pie"

Column

Name	Type
`key`	`string`
`series`	`[]`
`title`	`string`

Cube

Name	Type
`dimensions`	`TCubeDimension[]`
`measures`	`TCubeMeasure[]`
`name`	`string`
`segments`	`TCubeSegment[]`
`title`	`string`

CubeJSApiOptions

Name	Type	Description
`apiUrl`	`string`	URL of your Cube.js Backend. By default, in the development environment it is `http://localhost:4000/cubejs-api/v1`
`credentials?`	`"omit" \| "same-origin" \| "include"`
`headers?`	`Record<string, string>`
`parseDateMeasures?`	`boolean`
`pollInterval?`	`number`
`resType?`	`"default" \| "compact"`
`transport?`	`ITransport<any>`	Transport implementation to use. [HttpTransport](#http-transport) will be used by default.

CubeMember

 CubeMember: TCubeMeasure | TCubeDimension | TCubeSegment

DateRange

 DateRange: string | [string, string]

DeeplyReadonly

DrillDownLocator

Name	Type
`xValues`	`string[]`
`yValues?`	`string[]`

DryRunResponse

Name	Type
`normalizedQueries`	`Query[]`
`pivotQuery`	`PivotQuery`
`queryOrder`	`Array<object>`
`queryType`	`QueryType`
`transformedQueries`	`TransformedQuery[]`

ExtractMembers

 ExtractMembers: T extends object ? Names : never | T extends object ? Names : never | T extends object ? ExtractTimeMembers<U> : never

ExtractTimeMember

 ExtractTimeMember: T extends object ? Dimension | `${Dimension & string}.${Granularity & string}` : never

ExtractTimeMembers

 ExtractTimeMembers: T extends readonly [infer First] ? ExtractTimeMember<First> | ExtractTimeMembers<Rest> : never

Filter

 Filter: BinaryFilter | UnaryFilter | LogicalOrFilter | LogicalAndFilter

FilterOperator

Name	Type
`name`	`string`
`title`	`string`

LeafMeasure

Name	Type
`additive`	`boolean`
`measure`	`string`
`type`	`"count" \| "countDistinct" \| "sum" \| "min" \| "max" \| "number" \| "countDistinctApprox"`

LoadMethodCallback

 LoadMethodCallback: function

LoadMethodOptions

Name	Type	Description
`progressCallback?`
`cubejsApi?`	`CubejsApi`	A Cube.js API instance. If not provided will be taken from `CubeProvider`
`mutexKey?`	`string`	Key to store the current request's MUTEX inside the `mutexObj`. MUTEX object is used to reject orphaned queries results when new queries are sent. For example: if two queries are sent with the same `mutexKey` only the last one will return results.
`mutexObj?`	`Object`	Object to store MUTEX
`subscribe?`	`boolean`	Pass `true` to use continuous fetch behavior.

LoadResponse

Name	Type
`pivotQuery`	`PivotQuery`
`queryType`	`QueryType`
`results`	`LoadResponseResult<T>[]`

LoadResponseResult

Name	Type
`annotation`	`QueryAnnotations`
`data`	`T[]`
`dbType`	`string`
`extDbType`	`string`
`external`	`boolean \| null`
`lastRefreshTime`	`string`
`query`	`Query`
`requestId?`	`string`
`total?`	`number`
`transformedQuery?`	`TransformedQuery`
`usedPreAggregations?`	`Record<string, UsedPreAggregation>`

LogicalAndFilter

Name	Type
`and`	`Filter[]`

LogicalOrFilter

Name	Type
`or`	`Filter[]`

MemberType

 MemberType: "measures" | "dimensions" | "segments"

MetaResponse

Name	Type
`cubes`	`Cube[]`

PivotConfig

Configuration object that contains information about pivot axes and other options.

Let's apply pivotConfig and see how it affects the axes

// Example query
{
  measures: ['Orders.count'],
  dimensions: ['Users.country', 'Users.gender']
}

If we put the Users.gender dimension on y axis

resultSet.tablePivot({
  x: ['Users.country'],
  y: ['Users.gender', 'measures']
})

The resulting table will look the following way

Users Country	male, Orders.count	female, Orders.count
Australia	3	27
Germany	10	12
US	5	7

Now let's put the Users.country dimension on y axis instead

resultSet.tablePivot({
  x: ['Users.gender'],
  y: ['Users.country', 'measures'],
});

in this case the Users.country values will be laid out on y or columns axis

Users Gender	Australia, Orders.count	Germany, Orders.count	US, Orders.count
male	3	10	5
female	27	12	7

It's also possible to put the measures on x axis. But in either case it should always be the last item of the array.

resultSet.tablePivot({
  x: ['Users.gender', 'measures'],
  y: ['Users.country'],
});

Users Gender	measures	Australia	Germany	US
male	Orders.count	3	10	5
female	Orders.count	27	12	7

Name	Type	Description
`aliasSeries?`	`string[]`	Give each series a prefix alias. Should have one entry for each query:measure. See [chartPivot](#result-set-chart-pivot)
`fillMissingDates?`	`boolean \| null`	If `true` missing dates on the time dimensions will be filled with `0` for all measures.Note: the `fillMissingDates` option set to `true` will override any order applied to the query
`x?`	`string[]`	Dimensions to put on x or rows axis.
`y?`	`string[]`	Dimensions to put on y or columns axis.

PivotQuery

 PivotQuery: Query & object

PivotRow

Name	Type
`xValues`	`Array<string \| number>`
`yValuesArray`	`Array<[string[], number]>`

PreAggregationType

 PreAggregationType: "rollup" | "rollupJoin" | "rollupLambda" | "originalSql"

ProgressResponse

Name	Type
`stage`	`string`
`timeElapsed`	`number`

QueryAnnotations

Name	Type
`dimensions`	`Record<string, Annotation>`
`measures`	`Record<string, Annotation>`
`timeDimensions`	`Record<string, Annotation>`

QueryArrayRecordType

 QueryArrayRecordType: T extends readonly [infer First] ? SingleQueryRecordType<First> | QueryArrayRecordType<Rest & DeeplyReadonly<Query[]>> : never

QueryOrder

 QueryOrder: "asc" | "desc"

QueryRecordType

 QueryRecordType: T extends DeeplyReadonly<Query[]> ? QueryArrayRecordType<T> : T extends DeeplyReadonly<Query> ? SingleQueryRecordType<T> : never

QueryType

 QueryType: "regularQuery" | "compareDateRangeQuery" | "blendingQuery"

SerializedResult

Name	Type
`loadResponse`	`LoadResponse<T>`

Series

Name	Type
`key`	`string`
`series`	`T[]`
`title`	`string`

SeriesNamesColumn

Name	Type
`key`	`string`
`title`	`string`
`yValues`	`string[]`

SingleQueryRecordType

 SingleQueryRecordType: ExtractMembers<T> extends never ? any : object

SqlData

Name	Type
`aliasNameToMember`	`Record<string, string>`
`cacheKeyQueries`	`SqlQueryTuple[]`
`dataSource`	`boolean`
`external`	`boolean`
`preAggregations`	`any[]`
`rollupMatchResults`	`any[]`
`sql`	`SqlQueryTuple`

SqlQueryTuple

 SqlQueryTuple: [string, any[], any]

TCubeDimension

 TCubeDimension: BaseCubeMember & object

TCubeMeasure

 TCubeMeasure: BaseCubeMember & object

TCubeMember

Name	Type
`isVisible?`	`boolean`
`meta?`	`any`
`name`	`string`
`shortTitle`	`string`
`title`	`string`
`type`	`TCubeMemberType`

TCubeMemberByType

 TCubeMemberByType: T extends "measures" ? TCubeMeasure : T extends "dimensions" ? TCubeDimension : T extends "segments" ? TCubeSegment : never

TCubeMemberType

 TCubeMemberType: "time" | "number" | "string" | "boolean"

TCubeSegment

 TCubeSegment: Omit<BaseCubeMember, "type">

TDefaultHeuristicsOptions

Name	Type
`meta`	`Meta`
`sessionGranularity?`	`TimeDimensionGranularity`

TDefaultHeuristicsResponse

Name	Type
`chartType?`	`ChartType`
`pivotConfig`	`PivotConfig \| null`
`query`	`Query`
`shouldApplyHeuristicOrder`	`boolean`

TDefaultHeuristicsState

Name	Type
`chartType?`	`ChartType`
`query`	`Query`

TDryRunResponse

deprecated use DryRunResponse

Name	Type
`normalizedQueries`	`Query[]`
`pivotQuery`	`PivotQuery`
`queryOrder`	`Array<object>`
`queryType`	`QueryType`
`transformedQueries`	`TransformedQuery[]`

TGranularityMap

Name	Type
`name`	`TimeDimensionGranularity \| undefined`
`title`	`string`

TOrderMember

Name	Type
`id`	`string`
`order`	`QueryOrder \| "none"`
`title`	`string`

TQueryOrderArray

 TQueryOrderArray: Array<[string, QueryOrder]>

TQueryOrderObject

TableColumn

Name	Type
`children?`	`TableColumn[]`
`dataIndex`	`string`
`format?`	`any`
`key`	`string`
`meta`	`any`
`shortTitle`	`string`
`title`	`string`
`type`	`string \| number`

TimeDimension

 TimeDimension: TimeDimensionComparison | TimeDimensionRanged

TimeDimensionComparison

 TimeDimensionComparison: TimeDimensionBase & TimeDimensionComparisonFields

TimeDimensionComparisonFields

Name	Type
`compareDateRange`	`Array<DateRange>`
`dateRange?`	`never`

TimeDimensionGranularity

 TimeDimensionGranularity: "second" | "minute" | "hour" | "day" | "week" | "month" | "quarter" | "year"

TimeDimensionRanged

 TimeDimensionRanged: TimeDimensionBase & TimeDimensionRangedFields

TimeDimensionRangedFields

Name	Type
`dateRange?`	`DateRange`

TransformedQuery

Name	Type
`allFiltersWithinSelectedDimensions`	`boolean`
`granularityHierarchies`	`Record<string, string[]>`
`hasMultipliedMeasures`	`boolean`
`hasNoTimeDimensionsWithoutGranularity`	`boolean`
`isAdditive`	`boolean`
`leafMeasureAdditive`	`boolean`
`leafMeasures`	`string[]`
`measureToLeafMeasures?`	`Record<string, LeafMeasure[]>`
`measures`	`string[]`
`sortedDimensions`	`string[]`
`sortedTimeDimensions`	`[[string, string]]`

TransportOptions

Name	Type	Description
`apiUrl`	`string`	path to `/cubejs-api/v1`
`authorization`	`string`	[jwt auth token](security)
`credentials?`	`"omit" \| "same-origin" \| "include"`
`headers?`	`Record<string, string>`	custom headers
`method?`	`"GET" \| "PUT" \| "POST" \| "PATCH"`

UnaryOperator

 UnaryOperator: "set" | "notSet"

UsedPreAggregation

Name	Type
`targetTableName`	`string`
`type`	`PreAggregationType`

GRANULARITIES

 GRANULARITIES: TGranularityMap[]

Did you find this page useful?