@sisense/sdk-query-client 1.0.0 → 1.2.0

package/dist/interfaces.d.ts

@@ -1,7 +1,8 @@
-import { DataSourceField, ExecutingCsvQueryResult, ExecutingQueryResult, QueryDescription, QueryExecutionConfig } from './types.js';
+import { DataSourceField, ExecutingCsvQueryResult, ExecutingPivotQueryResult, ExecutingQueryResult, PivotQueryDescription, QueryDescription, QueryExecutionConfig } from './types.js';
 import { DataSource } from '@sisense/sdk-data';
 export interface QueryClient {
     executeQuery(params: QueryDescription, config?: QueryExecutionConfig): ExecutingQueryResult;
     executeCsvQuery(params: QueryDescription, config?: QueryExecutionConfig): ExecutingCsvQueryResult;
+    executePivotQuery(params: PivotQueryDescription, config?: QueryExecutionConfig): ExecutingPivotQueryResult;
     getDataSourceFields(dataSource: DataSource): Promise<DataSourceField[]>;
 }

package/dist/jaql/get-jaql-query-payload.d.ts

@@ -1,2 +1,10 @@
-import { JaqlQueryPayload, QueryDescription } from '../types.js';
+import { JaqlQueryPayload, QueryDescription, PivotQueryDescription } from '../types.js';
 export declare function getJaqlQueryPayload(queryDescription: QueryDescription, shouldSkipHighlightsWithoutAttributes: boolean): JaqlQueryPayload;
+/**
+ * Converts a pivot query description to a JAQL query payload.
+ *
+ * @param pivotQueryDescription
+ * @param shouldSkipHighlightsWithoutAttributes
+ * @returns jaql query payload
+ */
+export declare function getPivotJaqlQueryPayload(pivotQueryDescription: PivotQueryDescription, shouldSkipHighlightsWithoutAttributes: boolean): JaqlQueryPayload;

package/dist/jaql/get-jaql-query-payload.js

@@ -1,5 +1,10 @@
+/* eslint-disable complexity */
+/* eslint-disable max-lines */
 import { v4 as uuid } from 'uuid';
+import merge from 'ts-deepmerge';
+import { isPivotAttribute, isPivotMeasure, DEFAULT_PIVOT_GRAND_TOTALS, } from '@sisense/sdk-data';
 import { applyHighlightFilters, matchHighlightsWithAttributes } from './metadata/highlights.js';
+const JAQL_BY_CSDK = 'ComposeSDK';
 export function getJaqlQueryPayload(queryDescription, shouldSkipHighlightsWithoutAttributes) {
     const { attributes, measures, filters, filterRelations, highlights, dataSource, count, offset } = queryDescription;
     const queryPayload = Object.assign({ metadata: prepareQueryMetadata({ attributes, measures, filters, filterRelations, highlights }, shouldSkipHighlightsWithoutAttributes) }, prepareQueryOptions(dataSource, count, offset));
@@ -8,10 +13,7 @@ export function getJaqlQueryPayload(queryDescription, shouldSkipHighlightsWithou
     }
     return queryPayload;
 }
-function prepareQueryMetadata(metadataDescription, shouldSkipHighlightsWithoutAttributes) {
-    const { attributes, measures, filters, filterRelations, highlights } = metadataDescription;
-    const attributesMetadata = attributes.map((d) => d.jaql());
-    const measuresMetadata = measures.map((d) => d.jaql());
+function prepareFilterMetadata(attributesMetadata, filters, filterRelations, highlights, shouldSkipHighlightsWithoutAttributes) {
     const [highlightsWithAttributes, highlightsWithoutAttributes] = matchHighlightsWithAttributes(attributesMetadata, highlights);
     attributesMetadata.forEach((d) => applyHighlightFilters(d, highlightsWithAttributes));
     const getFilterJaql = (f) => {
@@ -30,8 +32,71 @@ function prepareQueryMetadata(metadataDescription, shouldSkipHighlightsWithoutAt
             .map((f) => f.attribute.name)
             .join(', ')}].`);
     }
+    return filtersMetadata;
+}
+function prepareQueryMetadata(metadataDescription, shouldSkipHighlightsWithoutAttributes) {
+    const { attributes, measures, filters, filterRelations, highlights } = metadataDescription;
+    const attributesMetadata = attributes.map((d) => d.jaql());
+    const measuresMetadata = measures.map((d) => d.jaql());
+    const filtersMetadata = prepareFilterMetadata(attributesMetadata, filters, filterRelations, highlights, shouldSkipHighlightsWithoutAttributes);
     return [...attributesMetadata, ...measuresMetadata, ...filtersMetadata];
 }
 function prepareQueryOptions(dataSource, count, offset) {
-    return Object.assign(Object.assign({ datasource: dataSource, by: 'ComposeSDK', queryGuid: uuid() }, (count ? { count } : {})), (offset ? { offset } : {}));
+    return Object.assign(Object.assign({ datasource: dataSource, by: JAQL_BY_CSDK, queryGuid: uuid() }, (count ? { count } : {})), (offset ? { offset } : {}));
+}
+/**
+ * Converts a pivot query description to a JAQL query payload.
+ *
+ * @param pivotQueryDescription
+ * @param shouldSkipHighlightsWithoutAttributes
+ * @returns jaql query payload
+ */
+export function getPivotJaqlQueryPayload(pivotQueryDescription, shouldSkipHighlightsWithoutAttributes) {
+    const { rowsAttributes, columnsAttributes, measures, filters, filterRelations, grandTotals, highlights, dataSource, count, offset, } = pivotQueryDescription;
+    const queryPayload = Object.assign({ metadata: preparePivotQueryMetadata({ rowsAttributes, columnsAttributes, measures, filters, highlights }, shouldSkipHighlightsWithoutAttributes) }, preparePivotQueryOptions(dataSource, grandTotals, count, offset));
+    if (filterRelations) {
+        return Object.assign(Object.assign({}, queryPayload), { filterRelations });
+    }
+    return queryPayload;
+}
+function jaqlPivotAttribute(a, panel, index) {
+    return Object.assign(Object.assign(Object.assign({}, (isPivotAttribute(a) ? a.attribute.jaql() : a.jaql())), (isPivotAttribute(a) && a.includeSubTotals ? { format: { subtotal: true } } : {})), { panel, field: { index: index, id: `${panel}-${index}` } });
+}
+function jaqlPivotMeasure(m, panel, index) {
+    return Object.assign(Object.assign({}, (isPivotMeasure(m)
+        ? merge(m.measure.jaql(), { jaql: { subtotalAgg: m.totalsCalculation } })
+        : m.jaql())), { panel, field: { index: index, id: `${panel}-${index}` }, format: { databars: false } });
+}
+/**
+ * Prepares the metadata part of the JAQL payload for a pivot query.
+ *
+ * @param pivotMetadataDescription
+ * @param shouldSkipHighlightsWithoutAttributes
+ * @returns array of metadata items of the JAQL payload
+ */
+function preparePivotQueryMetadata(pivotMetadataDescription, shouldSkipHighlightsWithoutAttributes) {
+    const { rowsAttributes, columnsAttributes, measures, filters, filterRelations, highlights } = pivotMetadataDescription;
+    let fieldIndex = 0; // used as a global counter to build field.index in Jaql MetadataItem
+    const rowsAttributesMetadata = rowsAttributes.map((a, index) => jaqlPivotAttribute(a, 'rows', index + fieldIndex));
+    fieldIndex = fieldIndex + rowsAttributes.length;
+    const columnsAttributesMetadata = columnsAttributes.map((a, index) => jaqlPivotAttribute(a, 'columns', index + fieldIndex));
+    fieldIndex = fieldIndex + columnsAttributes.length;
+    const attributesMetadata = [
+        ...rowsAttributesMetadata,
+        ...columnsAttributesMetadata,
+    ];
+    const measuresMetadata = measures.map((m, index) => jaqlPivotMeasure(m, 'measures', index + fieldIndex));
+    const filtersMetadata = prepareFilterMetadata(attributesMetadata, filters, filterRelations, highlights, shouldSkipHighlightsWithoutAttributes);
+    return [...attributesMetadata, ...measuresMetadata, ...filtersMetadata];
+}
+/**
+ * Prepares the options part of the JAQL payload for a pivot query.
+ *
+ * @param dataSource
+ * @param grandTotals
+ * @param count
+ * @param offset
+ */
+function preparePivotQueryOptions(dataSource, grandTotals, count, offset) {
+    return Object.assign(Object.assign(Object.assign({ datasource: dataSource, by: JAQL_BY_CSDK, queryGuid: uuid(), dashboard: JAQL_BY_CSDK, widget: JAQL_BY_CSDK, format: 'pivot' }, (count ? { count } : {})), (offset ? { offset } : {})), { grandTotals: Object.assign(Object.assign({}, DEFAULT_PIVOT_GRAND_TOTALS), grandTotals) });
 }

package/dist/query-client.d.ts

@@ -1,31 +1,50 @@
-import { DataSourceField, ExecutingCsvQueryResult, ExecutingQueryResult, QueryDescription, QueryExecutionConfig } from './types.js';
+import { DataSourceField, ExecutingCsvQueryResult, ExecutingPivotQueryResult, ExecutingQueryResult, PivotQueryDescription, QueryDescription, QueryExecutionConfig } from './types.js';
 import { QueryClient } from './interfaces.js';
 import { DataSource } from '@sisense/sdk-data';
 import { HttpClient } from '@sisense/sdk-rest-client';
+import { PivotClient } from '@sisense/sdk-pivot-client';
 /** @internal */
 export declare const QUERY_DEFAULT_LIMIT = 20000;
 export declare class DimensionalQueryClient implements QueryClient {
     private taskManager;
     private queryApi;
     private shouldSkipHighlightsWithoutAttributes;
-    constructor(httpClient: HttpClient, shouldSkipHighlightsWithoutAttributes?: boolean);
+    constructor(httpClient: HttpClient, pivotClient?: PivotClient, shouldSkipHighlightsWithoutAttributes?: boolean);
     /**
      * Executes query
      *
      * @param queryDescription - all options that describe query
+     * @param config - query execution configuration
      * @returns promise that resolves to query result data and cancel function that can be used to cancel sent query
      * @throws Error if query description is invalid
      */
     executeQuery(queryDescription: QueryDescription, config?: QueryExecutionConfig): ExecutingQueryResult;
     executeCsvQuery(queryDescription: QueryDescription, config?: QueryExecutionConfig): ExecutingCsvQueryResult;
+    /**
+     * Executes pivot query
+     *
+     * @param pivotQueryDescription - all options that describe the pivot query
+     * @param config - query execution configuration
+     * @returns promise that resolves to pivot query result data and cancel function that can be used to cancel sent query
+     * @throws Error if query description is invalid
+     */
+    executePivotQuery(pivotQueryDescription: PivotQueryDescription, config?: QueryExecutionConfig): ExecutingPivotQueryResult;
     getDataSourceFields(dataSource: DataSource, count?: number, offset?: number): Promise<DataSourceField[]>;
 }
 /**
  * Validates query description
  *
  * @param queryDescription - query description to validate
+ * @param config - query execution configuration
  * @throws Error if query description is invalid
  */
 export declare function validateQueryDescription(queryDescription: QueryDescription, config?: {
     ignoreQueryLimit?: boolean;
 }): void;
+/**
+ * Validates pivot query description
+ *
+ * @param queryDescription - pivot query description to validate
+ * @throws Error if query description is invalid
+ */
+export declare function validatePivotQueryDescription(queryDescription: PivotQueryDescription): void;

package/dist/query-client.js

@@ -8,24 +8,27 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { QueryTaskManager } from './query-task-manager/query-task-manager.js';
-import { QueryTaskPassport } from './query-task-manager/query-task-passport.js';
+import { PivotQueryTaskPassport, QueryTaskPassport, } from './query-task-manager/query-task-passport.js';
 import { ExecutionResultStatus } from '@sisense/task-manager';
 import { QueryApiDispatcher } from './query-api-dispatcher/query-api-dispatcher.js';
 import { MetadataTypes } from '@sisense/sdk-data';
 import { TranslatableError } from './translation/translatable-error.js';
+import { PivotClient } from '@sisense/sdk-pivot-client';
 /** @internal */
 export const QUERY_DEFAULT_LIMIT = 20000;
+const UNSPECIFIED_REASON = 'Unspecified reason';
 export class DimensionalQueryClient {
-    constructor(httpClient, shouldSkipHighlightsWithoutAttributes) {
+    constructor(httpClient, pivotClient = new PivotClient(httpClient), shouldSkipHighlightsWithoutAttributes) {
         validateHttpClient(httpClient);
         this.queryApi = new QueryApiDispatcher(httpClient);
-        this.taskManager = new QueryTaskManager(this.queryApi);
+        this.taskManager = new QueryTaskManager(this.queryApi, pivotClient);
         this.shouldSkipHighlightsWithoutAttributes = shouldSkipHighlightsWithoutAttributes !== null && shouldSkipHighlightsWithoutAttributes !== void 0 ? shouldSkipHighlightsWithoutAttributes : false;
     }
     /**
      * Executes query
      *
      * @param queryDescription - all options that describe query
+     * @param config - query execution configuration
      * @returns promise that resolves to query result data and cancel function that can be used to cancel sent query
      * @throws Error if query description is invalid
      */
@@ -43,7 +46,7 @@ export class DimensionalQueryClient {
                     }
                 });
             }),
-            cancel: (reason) => this.taskManager.cancel(taskPassport.taskId, reason || 'Unspecified reason'),
+            cancel: (reason) => this.taskManager.cancel(taskPassport.taskId, reason || UNSPECIFIED_REASON),
         };
     }
     executeCsvQuery(queryDescription, config) {
@@ -60,7 +63,32 @@ export class DimensionalQueryClient {
                     }
                 });
             }),
-            cancel: (reason) => this.taskManager.cancel(taskPassport.taskId, reason || 'Unspecified reason'),
+            cancel: (reason) => this.taskManager.cancel(taskPassport.taskId, reason || UNSPECIFIED_REASON),
+        };
+    }
+    /**
+     * Executes pivot query
+     *
+     * @param pivotQueryDescription - all options that describe the pivot query
+     * @param config - query execution configuration
+     * @returns promise that resolves to pivot query result data and cancel function that can be used to cancel sent query
+     * @throws Error if query description is invalid
+     */
+    executePivotQuery(pivotQueryDescription, config) {
+        validatePivotQueryDescription(pivotQueryDescription);
+        const taskPassport = new PivotQueryTaskPassport('SEND_JAQL_QUERY', pivotQueryDescription, Object.assign(Object.assign({}, (config ? config : {})), { shouldSkipHighlightsWithoutAttributes: this.shouldSkipHighlightsWithoutAttributes || false }));
+        return {
+            resultPromise: new Promise((resolve, reject) => {
+                void this.taskManager.executePivotQuerySending(taskPassport).then((executionResult) => {
+                    if (executionResult.status === ExecutionResultStatus.SUCCESS) {
+                        resolve(executionResult.result);
+                    }
+                    else {
+                        reject(executionResult.error);
+                    }
+                });
+            }),
+            cancel: (reason) => this.taskManager.cancel(taskPassport.taskId, reason || UNSPECIFIED_REASON),
         };
     }
     getDataSourceFields(dataSource, count = 9999, offset = 0) {
@@ -73,6 +101,7 @@ export class DimensionalQueryClient {
  * Validates query description
  *
  * @param queryDescription - query description to validate
+ * @param config - query execution configuration
  * @throws Error if query description is invalid
  */
 export function validateQueryDescription(queryDescription, config) {
@@ -113,6 +142,40 @@ export function validateQueryDescription(queryDescription, config) {
         }
     });
 }
+/**
+ * Validates pivot query description
+ *
+ * @param queryDescription - pivot query description to validate
+ * @throws Error if query description is invalid
+ */
+export function validatePivotQueryDescription(queryDescription) {
+    const { rowsAttributes, columnsAttributes, measures, filters, highlights, count, offset } = queryDescription;
+    if (count && count < 0) {
+        throw new TranslatableError('errors.invalidCountNegative', { count: count.toString() });
+    }
+    if (count && count > QUERY_DEFAULT_LIMIT) {
+        throw new TranslatableError('errors.invalidCountLimit', {
+            count: count.toString(),
+            limit: QUERY_DEFAULT_LIMIT.toString(),
+        });
+    }
+    if (offset && offset < 0) {
+        throw new TranslatableError('errors.invalidOffset', { offset: offset.toString() });
+    }
+    if (rowsAttributes.length + columnsAttributes.length + measures.length === 0) {
+        throw new TranslatableError('errors.noDimensionsOrMeasures');
+    }
+    filters.forEach((filter) => {
+        if (!filter.skipValidation && !MetadataTypes.isFilter(filter)) {
+            throw new TranslatableError('errors.invalidFilter', { filterName: filter.name });
+        }
+    });
+    highlights.forEach((highlight) => {
+        if (!highlight.skipValidation && !MetadataTypes.isFilter(highlight)) {
+            throw new TranslatableError('errors.invalidHighlight', { highlightName: highlight.name });
+        }
+    });
+}
 /**
  * Validates http client
  *

package/dist/query-task-manager/query-task-manager.d.ts

@@ -1,18 +1,39 @@
 import { AbstractTaskManager } from '@sisense/task-manager';
 import { EmptyObject, JaqlResponse } from '../types.js';
-import { QueryTaskPassport } from './query-task-passport.js';
-import { QueryResultData } from '@sisense/sdk-data';
+import { PivotQueryTaskPassport, QueryTaskPassport } from './query-task-passport.js';
+import { QueryResultData, PivotQueryResultData } from '@sisense/sdk-data';
 import { QueryApiDispatcher } from '../query-api-dispatcher/query-api-dispatcher.js';
+import { PivotClient } from '@sisense/sdk-pivot-client';
 export declare class QueryTaskManager extends AbstractTaskManager {
     /** Map of aborters by task id to be able to cancel sent requests */
     private sentRequestsAbortersMap;
     private queryApi;
-    constructor(queryApi: QueryApiDispatcher);
+    /**
+     * Client for handling pivot data
+     */
+    private pivotClient;
+    constructor(queryApi: QueryApiDispatcher, pivotClient: PivotClient);
     private prepareJaqlPayload;
     private sendJaqlQuery;
     private sendCsvQuery;
     private cancelDataRetrievalQuery;
+    /**
+     * Prepares the JAQL payload for the pivot query
+     *
+     * @param task
+     * @returns JAQL payload
+     */
+    private preparePivotJaqlPayload;
+    /**
+     * Executes the pivot query and returns the result
+     *
+     * @param task
+     * @param jaqlPayload
+     */
+    private sendPivotJaqlQuery;
+    private cancelPivotJaqlQuery;
     executeQuerySending: (passport: QueryTaskPassport) => Promise<import("@sisense/task-manager").TaskExecutionResult<QueryResultData, EmptyObject>>;
     executeDownloadCsvSending: (passport: QueryTaskPassport) => Promise<import("@sisense/task-manager").TaskExecutionResult<Blob, EmptyObject>>;
+    executePivotQuerySending: (passport: PivotQueryTaskPassport) => Promise<import("@sisense/task-manager").TaskExecutionResult<PivotQueryResultData, EmptyObject>>;
 }
 export declare function validateJaqlResponse(jaqlResponse: JaqlResponse): boolean;

package/dist/query-task-manager/query-task-manager.js

@@ -8,10 +8,11 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import { AbstractTaskManager, Step } from '@sisense/task-manager';
-import { getJaqlQueryPayload } from '../jaql/get-jaql-query-payload.js';
+import { getJaqlQueryPayload, getPivotJaqlQueryPayload } from '../jaql/get-jaql-query-payload.js';
 import { getDataFromQueryResult } from '../query-result/index.js';
+import { QUERY_DEFAULT_LIMIT } from '../query-client.js';
 export class QueryTaskManager extends AbstractTaskManager {
-    constructor(queryApi) {
+    constructor(queryApi, pivotClient) {
         super();
         /** Map of aborters by task id to be able to cancel sent requests */
         this.sentRequestsAbortersMap = new Map();
@@ -23,7 +24,12 @@ export class QueryTaskManager extends AbstractTaskManager {
             new Step('PREPARE_JAQL_PAYLOAD', this.prepareJaqlPayload.bind(this), () => __awaiter(this, void 0, void 0, function* () { })),
             new Step('SEND_DOWNLOAD_CSV_QUERY', this.sendCsvQuery.bind(this), this.cancelDataRetrievalQuery.bind(this)),
         ]);
+        this.executePivotQuerySending = super.createFlow([
+            new Step('PREPARE_JAQL_PAYLOAD', this.preparePivotJaqlPayload.bind(this), () => __awaiter(this, void 0, void 0, function* () { })),
+            new Step('SEND_JAQL_QUERY', this.sendPivotJaqlQuery.bind(this), this.cancelPivotJaqlQuery.bind(this)),
+        ]);
         this.queryApi = queryApi;
+        this.pivotClient = pivotClient;
     }
     prepareJaqlPayload(task) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -72,6 +78,43 @@ export class QueryTaskManager extends AbstractTaskManager {
         }
         return this.queryApi.sendCancelJaqlQueryRequest(taskId, task.passport.queryDescription.dataSource);
     }
+    /**
+     * Prepares the JAQL payload for the pivot query
+     *
+     * @param task
+     * @returns JAQL payload
+     */
+    preparePivotJaqlPayload(task) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { pivotQueryDescription, executionConfig } = task.passport;
+            const jaqlPayload = getPivotJaqlQueryPayload(pivotQueryDescription, executionConfig.shouldSkipHighlightsWithoutAttributes);
+            const onBeforeQuery = task.passport.executionConfig.onBeforeQuery;
+            if (onBeforeQuery) {
+                return onBeforeQuery(jaqlPayload);
+            }
+            return jaqlPayload;
+        });
+    }
+    /**
+     * Executes the pivot query and returns the result
+     *
+     * @param task
+     * @param jaqlPayload
+     */
+    sendPivotJaqlQuery(task, jaqlPayload) {
+        var _a;
+        const { pivotQueryDescription } = task.passport;
+        return this.pivotClient.queryData(jaqlPayload, true, (_a = pivotQueryDescription.count) !== null && _a !== void 0 ? _a : QUERY_DEFAULT_LIMIT, false);
+    }
+    cancelPivotJaqlQuery(task) {
+        const taskId = task.passport.taskId;
+        const abortInitialRequest = this.sentRequestsAbortersMap.get(taskId);
+        if (abortInitialRequest) {
+            abortInitialRequest();
+            this.sentRequestsAbortersMap.delete(taskId);
+        }
+        return this.queryApi.sendCancelJaqlQueryRequest(taskId, task.passport.pivotQueryDescription.dataSource);
+    }
 }
 export function validateJaqlResponse(jaqlResponse) {
     var _a;

package/dist/query-task-manager/query-task-passport.d.ts

@@ -1,5 +1,5 @@
 import { TaskPassport } from '@sisense/task-manager';
-import { QueryDescription, QueryExecutionConfigInternal } from '../types.js';
+import { PivotQueryDescription, QueryDescription, QueryExecutionConfigInternal } from '../types.js';
 type TaskType = 'SEND_JAQL_QUERY' | 'SEND_DOWNLOAD_CSV_QUERY';
 export declare class QueryTaskPassport extends TaskPassport {
     queryDescription: QueryDescription;
@@ -7,4 +7,10 @@ export declare class QueryTaskPassport extends TaskPassport {
     type: TaskType;
     constructor(type: TaskType, queryDescription: QueryDescription, executionConfig: QueryExecutionConfigInternal);
 }
+export declare class PivotQueryTaskPassport extends TaskPassport {
+    pivotQueryDescription: PivotQueryDescription;
+    executionConfig: QueryExecutionConfigInternal;
+    type: TaskType;
+    constructor(type: TaskType, pivotQueryDescription: PivotQueryDescription, executionConfig: QueryExecutionConfigInternal);
+}
 export {};

package/dist/query-task-manager/query-task-passport.js

@@ -7,3 +7,11 @@ export class QueryTaskPassport extends TaskPassport {
         this.executionConfig = executionConfig;
     }
 }
+export class PivotQueryTaskPassport extends TaskPassport {
+    constructor(type, pivotQueryDescription, executionConfig) {
+        super();
+        this.pivotQueryDescription = pivotQueryDescription;
+        this.type = type;
+        this.executionConfig = executionConfig;
+    }
+}

package/dist/types.d.ts

@@ -1,4 +1,4 @@
-import { Filter, Measure, Attribute, Cell, QueryResultData, DataSource, FilterRelation } from '@sisense/sdk-data';
+import { Filter, Measure, Attribute, Cell, QueryResultData, DataSource, FilterRelation, PivotAttribute, PivotMeasure, PivotQueryResultData, PivotGrandTotals } from '@sisense/sdk-data';
 /**
  * All the properties that fully describe a query you want to send.
  */
@@ -12,6 +12,21 @@ export type QueryDescription = {
     count?: number;
     offset?: number;
 };
+/**
+ * All the properties that fully describe a pivot query you want to send.
+ */
+export type PivotQueryDescription = {
+    dataSource: DataSource;
+    rowsAttributes: (Attribute | PivotAttribute)[];
+    columnsAttributes: (Attribute | PivotAttribute)[];
+    measures: (Measure | PivotMeasure)[];
+    grandTotals: PivotGrandTotals;
+    filters: Filter[];
+    highlights: Filter[];
+    filterRelations?: FilterRelation;
+    count?: number;
+    offset?: number;
+};
 /**
  * Additional configuration for query execution.
  */
@@ -28,6 +43,14 @@ export type QueryOptions = {
     datasource: string;
     by: string;
     queryGuid: string;
+    dashboard?: string;
+    widget?: string;
+    format?: string;
+    grandTotals?: {
+        title?: string;
+        columns?: boolean;
+        rows?: boolean;
+    };
 };
 export type ExecutingQueryResult = {
     resultPromise: Promise<QueryResultData>;
@@ -37,6 +60,10 @@ export type ExecutingCsvQueryResult = {
     resultPromise: Promise<Blob>;
     cancel: (reason?: string) => Promise<void>;
 };
+export type ExecutingPivotQueryResult = {
+    resultPromise: Promise<PivotQueryResultData>;
+    cancel: (reason?: string) => Promise<void>;
+};
 export type MetadataItem = {
     instanceid?: string;
     measure?: MetadataItemJaql;
@@ -48,6 +75,22 @@ export type MetadataItem = {
             [level: string]: string | undefined;
         };
         number?: string;
+        subtotal?: boolean;
+        width?: number;
+        databars?: boolean;
+        color?: {
+            type: string;
+            color?: string;
+            conditions?: Array<{
+                color: string;
+                operator: string;
+                expression: string | Record<string, any>;
+            }>;
+        };
+    };
+    field?: {
+        id?: string;
+        index?: number;
     };
     filter?: MetadataItem;
     exclude?: MetadataItem;

package/package.json

@@ -11,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.0.0",
+  "version": "1.2.0",
   "type": "module",
   "exports": "./dist/index.js",
   "main": "./dist/index.js",
@@ -20,11 +20,13 @@
   "author": "Sisense",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@sisense/sdk-common": "^1.0.0",
-    "@sisense/sdk-data": "^1.0.0",
-    "@sisense/sdk-rest-client": "^1.0.0",
+    "@sisense/sdk-common": "^1.2.0",
+    "@sisense/sdk-data": "^1.2.0",
+    "@sisense/sdk-pivot-client": "^1.2.0",
+    "@sisense/sdk-rest-client": "^1.2.0",
     "@sisense/task-manager": "^0.1.0",
     "numeral": "^2.0.6",
+    "ts-deepmerge": "6.0.2",
     "uuid": "^9.0.0"
   },
   "scripts": {