@cubejs-client/core

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

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

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

cubejs(options: CubeJSApiOptions): CubejsApi

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

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

defaultOrder(query: DeeplyReadonly<Query>): object

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

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

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

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

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

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

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

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

meta(options?: LoadMethodOptions): Promise<Meta>

meta(options?: LoadMethodOptions, callback?: LoadMethodCallback<Meta>): UnsubscribeObj

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

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

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

// Subscribe to a query's updates
const subscription = await cubejsApi.subscribe(
  {
    measures: ['Logs.count'],
    timeDimensions: [
      {
        dimension: 'Logs.time',
        granularity: 'hour',
        dateRange: 'last 1440 minutes',
      },
    ],
  },
  options,
  (error, resultSet) => {
    if (!error) {
      // handle the update
    }
  }
);
 
// Unsubscribe from a query's updates
subscription.unsubscribe();

new HttpTransport(options: TransportOptions): HttpTransport

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

new Meta(metaResponse: MetaResponse): Meta

 cubes: Cube[] 

 cubesMap: CubesMap 

 meta: MetaResponse 

defaultTimeDimensionNameFor(memberName: string): string

filterOperatorsForMember(memberName: string, memberType: MemberType | MemberType[]): FilterOperator[]

membersForQuery(query: DeeplyReadonly<Query> | null, memberType: MemberType): TCubeMeasure[] | TCubeDimension[] | TCubeMember[]

membersGroupedByCube(): any

resolveMember<T>(memberName: string, memberType: T | T[]): object | TCubeMemberByType<T>

{
  name,
  title,
  shortTitle,
  type,
  description,
  format
}

stage(): string

timeElapsed(): string

annotation(): QueryAnnotations

categories(pivotConfig?: PivotConfig): ChartPivotRow[]

chartPivot(pivotConfig?: PivotConfig): ChartPivotRow[]

// 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"]  },
  //...
]
 

// 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(): ResultSet[]

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

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

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

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

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

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

pivot(pivotConfig?: PivotConfig): PivotRow[]

// 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

rawData(): T[]

serialize(): SerializedResult

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

// 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',
    shortTitle: '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 },
      //...
    ],
  },
]

seriesNames(pivotConfig?: PivotConfig): SeriesNamesColumn[]

// 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',
    shortTitle: 'Count',
    yValues: ['Stories.count'],
  },
]

tableColumns(pivotConfig?: PivotConfig): TableColumn[]

// 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,
  },
  //...
]

// 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']
})

{
  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(pivotConfig?: PivotConfig): Array<object>

// 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(): ChartPivotRow

totalRow(pivotConfig?: PivotConfig): ChartPivotRow

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

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

rawQuery(): SqlData

sql(): string

 dimension? : string 

 member? : string 

 operator: BinaryOperator 

 values: string[] 

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

 subscribe: function 

 unsubscribe? : function 

 dimensions? : string[] 

 filters? : Filter[] 

 limit? : null | number 

 measures? : string[] 

 offset? : number 

 order? : TQueryOrderObject | TQueryOrderArray 

 renewQuery? : boolean 

 responseFormat? : "compact" | "default" 

 segments? : string[] 

 timeDimensions? : TimeDimension[] 

 timezone? : string 

 total? : boolean 

 ungrouped? : boolean 

 dimension? : string 

 member? : string 

 operator: BinaryOperator 

 values: string[] 

 dimension: string 

 granularity? : TimeDimensionGranularity 

 dimension? : string 

 member? : string 

 operator: UnaryOperator 

 values? : never 

unsubscribe(): Promise<void>

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

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

 CubeMember: TCubeMeasure | TCubeDimension | TCubeSegment 

 CubesMap: Record<string, CubeMap> 

 DateRange: string | [string, string] 

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

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

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

 Filter: BinaryFilter | UnaryFilter | LogicalOrFilter | LogicalAndFilter 

 LoadMethodCallback: function 

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

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

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

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

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

 PivotQuery: Query & object 

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

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

 QueryOrder: "asc" | "desc" 

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

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

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

 SqlQueryTuple: [string, any[], any] 

 TCubeDimension: BaseCubeMember & object 

 TCubeMeasure: BaseCubeMember & object 

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

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

 TCubeSegment: Omit<BaseCubeMember, "type"> 

 TQueryOrderArray: Array<[string, QueryOrder]> 

 TimeDimension: TimeDimensionComparison | TimeDimensionRanged 

 TimeDimensionComparison: TimeDimensionBase & TimeDimensionComparisonFields 

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

 TimeDimensionRanged: TimeDimensionBase & TimeDimensionRangedFields 

 UnaryOperator: "set" | "notSet" 

 GRANULARITIES: TGranularityMap[]