@sisense/sdk-query-client 1.21.0 → 1.23.0

package/dist/cjs/helpers/utility-types.d.ts

@@ -0,0 +1,2 @@
+export type AnyObject = Record<string, unknown>;
+export type EmptyObject = Record<string, never>;

package/dist/cjs/helpers/utility-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/index.d.ts

@@ -0,0 +1,6 @@
+import './translation/initialize-i18n.js';
+export { DimensionalQueryClient } from './query-client.js';
+export { getJaqlQueryPayload } from './jaql/get-jaql-query-payload.js';
+export * from './types.js';
+export * from './interfaces.js';
+export { type TranslationDictionary, PACKAGE_NAMESPACE as translationNamespace, } from './translation/resources/index.js';

package/dist/cjs/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translationNamespace = exports.getJaqlQueryPayload = exports.DimensionalQueryClient = void 0;
+require("./translation/initialize-i18n.js");
+var query_client_js_1 = require("./query-client.js");
+Object.defineProperty(exports, "DimensionalQueryClient", { enumerable: true, get: function () { return query_client_js_1.DimensionalQueryClient; } });
+var get_jaql_query_payload_js_1 = require("./jaql/get-jaql-query-payload.js");
+Object.defineProperty(exports, "getJaqlQueryPayload", { enumerable: true, get: function () { return get_jaql_query_payload_js_1.getJaqlQueryPayload; } });
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./interfaces.js"), exports);
+var index_js_1 = require("./translation/resources/index.js");
+Object.defineProperty(exports, "translationNamespace", { enumerable: true, get: function () { return index_js_1.PACKAGE_NAMESPACE; } });

package/dist/cjs/interfaces.d.ts

@@ -0,0 +1,10 @@
+import { ExecutingCsvQueryResult, ExecutingPivotQueryResult, ExecutingQueryResult, PivotQueryDescription, QueryDescription, QueryExecutionConfig } from './types.js';
+import { DataSource, DataSourceField, DataSourceMetadata, DataSourceSchema } 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[]>;
+    getDataSourceSchema(datasourceName: string): Promise<DataSourceSchema | undefined>;
+    getDataSourceList(): Promise<DataSourceMetadata[]>;
+}

package/dist/cjs/interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,15 @@
+import { JaqlQueryPayload, QueryDescription, PivotQueryDescription, QueryOptions } from '../types.js';
+import { DataSource } from '@sisense/sdk-data';
+/**
+ * @internal
+ */
+export declare function getJaqlQueryPayload(queryDescription: QueryDescription, shouldSkipHighlightsWithoutAttributes: boolean): JaqlQueryPayload;
+export declare function prepareQueryOptions(dataSource: DataSource, count?: number, offset?: number, includeUngroup?: boolean): QueryOptions;
+/**
+ * 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/cjs/jaql/get-jaql-query-payload.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPivotJaqlQueryPayload = exports.prepareQueryOptions = exports.getJaqlQueryPayload = void 0;
+const uuid_1 = require("uuid");
+const ts_deepmerge_1 = __importDefault(require("ts-deepmerge"));
+const sdk_data_1 = require("@sisense/sdk-data");
+const highlights_js_1 = require("./metadata/highlights.js");
+const pivot_query_utils_js_1 = require("./pivot/pivot-query-utils.js");
+const JAQL_BY_CSDK = 'ComposeSDK';
+/**
+ * @internal
+ */
+function getJaqlQueryPayload(queryDescription, shouldSkipHighlightsWithoutAttributes) {
+    const { attributes, measures, filters, filterRelations, highlights, dataSource, count, offset, ungroup, } = queryDescription;
+    // "ungroup: true" will be set in JAQL when two conditions are met:
+    // (1) ungroup is set to true
+    // AND
+    // (2) the query has no measures (unaggregated query)
+    const includeUngroup = ungroup && measures.length === 0;
+    const queryPayload = Object.assign({ metadata: prepareQueryMetadata({ attributes, measures, filters, filterRelations, highlights }, shouldSkipHighlightsWithoutAttributes) }, prepareQueryOptions(dataSource, count, offset, includeUngroup));
+    if (filterRelations) {
+        return Object.assign(Object.assign({}, queryPayload), { filterRelations });
+    }
+    return queryPayload;
+}
+exports.getJaqlQueryPayload = getJaqlQueryPayload;
+function prepareFilterMetadata(attributesMetadata, filters, filterRelations, highlights, shouldSkipHighlightsWithoutAttributes) {
+    const [highlightsWithAttributes, highlightsWithoutAttributes] = (0, highlights_js_1.matchHighlightsWithAttributes)(attributesMetadata, highlights);
+    attributesMetadata.forEach((d) => (0, highlights_js_1.applyHighlightFilters)(d, highlightsWithAttributes));
+    const getFilterJaql = (f) => {
+        const jaql = f.jaql();
+        if (filterRelations) {
+            // instanceid is needed for filter relations only
+            if (Array.isArray(jaql)) {
+                return jaql.map((j) => (Object.assign(Object.assign({}, j), { instanceid: f.guid })));
+            }
+            else {
+                return Object.assign(Object.assign({}, jaql), { instanceid: f.guid });
+            }
+        }
+        return jaql;
+    };
+    const filtersMetadata = (shouldSkipHighlightsWithoutAttributes
+        ? filters.flatMap((d) => getFilterJaql(d))
+        : [...filters, ...highlightsWithoutAttributes].flatMap((d) => getFilterJaql(d))).filter((f) => {
+        return Object.keys(f.jaql.filter || {}).length !== 0;
+    });
+    if (shouldSkipHighlightsWithoutAttributes && highlightsWithoutAttributes.length > 0) {
+        console.warn(`The following highlight filters were not applied due to missing attributes: [${highlightsWithoutAttributes
+            .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, includeUngroup) {
+    return Object.assign(Object.assign(Object.assign({ datasource: (0, sdk_data_1.convertJaqlDataSource)(dataSource), by: JAQL_BY_CSDK, queryGuid: (0, uuid_1.v4)() }, (includeUngroup ? { ungroup: true } : {})), (count ? { count } : {})), (offset ? { offset } : {}));
+}
+exports.prepareQueryOptions = prepareQueryOptions;
+/**
+ * Converts a pivot query description to a JAQL query payload.
+ *
+ * @param pivotQueryDescription
+ * @param shouldSkipHighlightsWithoutAttributes
+ * @returns jaql query payload
+ */
+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;
+}
+exports.getPivotJaqlQueryPayload = getPivotJaqlQueryPayload;
+function jaqlPivotAttribute(a, panel, index, metadataStats) {
+    const isSortedRowAttribute = panel === 'rows' && (0, sdk_data_1.isPivotAttribute)(a) && a.sort && a.sort.direction !== 'sortNone';
+    const jaql = Object.assign(Object.assign({}, ((0, sdk_data_1.isPivotAttribute)(a) ? a.attribute.jaql(true) : a.jaql(true))), (isSortedRowAttribute && (0, pivot_query_utils_js_1.preparePivotRowJaqlSortOptions)(a.sort, index, metadataStats)));
+    return Object.assign(Object.assign({ jaql }, ((0, sdk_data_1.isPivotAttribute)(a) && a.includeSubTotals ? { format: { subtotal: true } } : {})), { panel, field: { index: index, id: `${panel}-${index}` } });
+}
+function jaqlPivotMeasure(m, panel, index) {
+    return Object.assign(Object.assign({}, ((0, sdk_data_1.isPivotMeasure)(m)
+        ? (0, ts_deepmerge_1.default)(m.measure.jaql(), {
+            jaql: { subtotalAgg: m.totalsCalculation },
+            format: { databars: m.dataBars || false },
+        })
+        : m.jaql())), { panel, field: { index: index, id: `${panel}-${index}` } });
+}
+/**
+ * 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;
+    const metadataStats = (0, pivot_query_utils_js_1.getPivotMetadataStats)(rowsAttributes, columnsAttributes, measures);
+    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, metadataStats));
+    fieldIndex = fieldIndex + rowsAttributes.length;
+    const columnsAttributesMetadata = columnsAttributes.map((a, index) => jaqlPivotAttribute(a, 'columns', index + fieldIndex, metadataStats));
+    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);
+    const metadata = [...attributesMetadata, ...measuresMetadata, ...filtersMetadata];
+    (0, pivot_query_utils_js_1.normalizeLastRowSorting)(metadata, metadataStats);
+    return metadata;
+}
+/**
+ * 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: (0, sdk_data_1.convertJaqlDataSource)(dataSource), by: JAQL_BY_CSDK, queryGuid: (0, uuid_1.v4)(), dashboard: JAQL_BY_CSDK, widget: JAQL_BY_CSDK, format: 'pivot' }, (count ? { count } : {})), (offset ? { offset } : {})), { grandTotals: Object.assign(Object.assign({}, sdk_data_1.DEFAULT_PIVOT_GRAND_TOTALS), grandTotals) });
+}

package/dist/cjs/jaql/metadata/highlights.d.ts

@@ -0,0 +1,4 @@
+import { Filter, MetadataItem } from '@sisense/sdk-data';
+export declare function applyHighlightFilters(metadataItem: MetadataItem, highlights: Filter[]): MetadataItem;
+export declare function matchHighlightsWithAttributes(attributesMetadata: MetadataItem[], highlights: Filter[]): Filter[][];
+export declare function getMetadataItemId(metadataItem: MetadataItem): string;

package/dist/cjs/jaql/metadata/highlights.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMetadataItemId = exports.matchHighlightsWithAttributes = exports.applyHighlightFilters = void 0;
+function applyHighlightFilters(metadataItem, highlights) {
+    const filter = highlights === null || highlights === void 0 ? void 0 : highlights.find((f) => getMetadataItemId(metadataItem) === f.attribute.id);
+    if (filter && !filter.disabled) {
+        if (filter.isScope) {
+            filter.isScope = false;
+        }
+        metadataItem.jaql.in = {
+            selected: filter.jaql(),
+        };
+    }
+    return metadataItem;
+}
+exports.applyHighlightFilters = applyHighlightFilters;
+function matchHighlightsWithAttributes(attributesMetadata, highlights) {
+    const highlightsWithAttributes = [];
+    const highlightsWithoutAttributes = [];
+    highlights.forEach((filter) => {
+        const isMatch = attributesMetadata.some((d) => getMetadataItemId(d) === filter.attribute.id);
+        if (isMatch) {
+            highlightsWithAttributes.push(filter);
+        }
+        else {
+            highlightsWithoutAttributes.push(filter);
+        }
+    });
+    return [highlightsWithAttributes, highlightsWithoutAttributes];
+}
+exports.matchHighlightsWithAttributes = matchHighlightsWithAttributes;
+function getMetadataItemId(metadataItem) {
+    const { dim, level, dateTimeLevel, bucket } = metadataItem.jaql;
+    let id = `${dim}`;
+    if (level || dateTimeLevel) {
+        id += `_${level || dateTimeLevel}`;
+    }
+    if (bucket) {
+        id += `_${bucket}`;
+    }
+    return id;
+}
+exports.getMetadataItemId = getMetadataItemId;

package/dist/cjs/jaql/metadata/index.d.ts

@@ -0,0 +1 @@
+export * from './highlights.js';

package/dist/cjs/jaql/metadata/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./highlights.js"), exports);

package/dist/cjs/jaql/pivot/pivot-query-utils.d.ts

@@ -0,0 +1,37 @@
+import type { Attribute, Measure, MetadataItem, PivotAttribute, PivotMeasure, PivotRowsSort, SortDirection } from '@sisense/sdk-data';
+/**
+ * Represents statistics about a pivot table metadata.
+ */
+export type PivotMetadataStats = {
+    rowsCount: number;
+    columnsCount: number;
+    measuresCount: number;
+};
+/**
+ * Calculates statistics about the pivot table metadata.
+ */
+export declare function getPivotMetadataStats(rowsAttributes: (Attribute | PivotAttribute)[], columnsAttributes: (Attribute | PivotAttribute)[], measures: (Measure | PivotMeasure)[]): PivotMetadataStats;
+/**
+ * Converts sort direction to JAQL sort direction.
+ */
+export declare function convertSortDirectionToJaqlSort(direction: SortDirection): "asc" | "desc" | "none";
+/**
+ * Prepares JAQL sort options for pivot table row.
+ */
+export declare function preparePivotRowJaqlSortOptions(sort: PivotRowsSort, rowIndex: number, metadataStats: PivotMetadataStats): {
+    sort: string;
+    sortDetails: {
+        dir: string;
+        field?: number | undefined;
+        measurePath?: Record<number, string | number> | undefined;
+        sortingLastDimension?: boolean | undefined;
+        initialized?: boolean | undefined;
+    };
+};
+/**
+ * Normalizes sorting for the last row of the pivot table.
+ *
+ * According to the existing pivot JAQL structure,the sorting configuration of the last row
+ * should be located inside the target measure metadata
+ */
+export declare function normalizeLastRowSorting(metadata: MetadataItem[], metadataStats: PivotMetadataStats): void;

package/dist/cjs/jaql/pivot/pivot-query-utils.js

@@ -0,0 +1,83 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeLastRowSorting = exports.preparePivotRowJaqlSortOptions = exports.convertSortDirectionToJaqlSort = exports.getPivotMetadataStats = void 0;
+/**
+ * Calculates statistics about the pivot table metadata.
+ */
+function getPivotMetadataStats(rowsAttributes, columnsAttributes, measures) {
+    return {
+        rowsCount: rowsAttributes.length,
+        columnsCount: columnsAttributes.length,
+        measuresCount: measures.length,
+    };
+}
+exports.getPivotMetadataStats = getPivotMetadataStats;
+/**
+ * Converts sort direction to JAQL sort direction.
+ */
+function convertSortDirectionToJaqlSort(direction) {
+    switch (direction) {
+        case 'sortAsc':
+            return 'asc';
+        case 'sortDesc':
+            return 'desc';
+        default:
+            return 'none';
+    }
+}
+exports.convertSortDirectionToJaqlSort = convertSortDirectionToJaqlSort;
+/**
+ * Prepares JAQL sort options for pivot table row.
+ */
+function preparePivotRowJaqlSortOptions(sort, rowIndex, metadataStats) {
+    const sortDirection = convertSortDirectionToJaqlSort(sort.direction);
+    const isLastRow = rowIndex === metadataStats.rowsCount - 1;
+    const sortDetails = {
+        dir: sortDirection,
+        initialized: true,
+        field: sort.by && 'valuesIndex' in sort.by
+            ? metadataStats.rowsCount + metadataStats.columnsCount + sort.by.valuesIndex
+            : rowIndex,
+    };
+    if (isLastRow) {
+        sortDetails.sortingLastDimension = true;
+    }
+    if (sort.by) {
+        sortDetails.measurePath = (sort.by.columnsMembersPath || []).reduce((path, columnMember, columnIndex) => (Object.assign(Object.assign({}, path), { [metadataStats.rowsCount + columnIndex]: columnMember })), {});
+    }
+    return {
+        sort: sortDirection,
+        sortDetails,
+    };
+}
+exports.preparePivotRowJaqlSortOptions = preparePivotRowJaqlSortOptions;
+/**
+ * Normalizes sorting for the last row of the pivot table.
+ *
+ * According to the existing pivot JAQL structure,the sorting configuration of the last row
+ * should be located inside the target measure metadata
+ */
+function normalizeLastRowSorting(metadata, metadataStats) {
+    const lastRowMetadata = metadata[metadataStats.rowsCount - 1];
+    const isSortedByMeasure = lastRowMetadata.jaql.sortDetails &&
+        lastRowMetadata.jaql.sortDetails.field !== metadataStats.rowsCount - 1;
+    if (isSortedByMeasure) {
+        const targetMeasureMetadata = metadata[lastRowMetadata.jaql.sortDetails.field];
+        const _a = lastRowMetadata.jaql, { sortDetails, sort } = _a, jaqlWithoutSortOptions = __rest(_a, ["sortDetails", "sort"]);
+        targetMeasureMetadata.jaql.sortDetails = sortDetails;
+        targetMeasureMetadata.jaql.sort = sort;
+        lastRowMetadata.jaql = jaqlWithoutSortOptions;
+    }
+}
+exports.normalizeLastRowSorting = normalizeLastRowSorting;

package/dist/cjs/package.json

@@ -0,0 +1,12 @@
+{
+  "main": "./index.js",
+  "module": "./index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "require": "./index.js",
+      "default": "./index.js"
+    }
+  }
+}

package/dist/cjs/query-api-dispatcher/query-api-dispatcher.d.ts

@@ -0,0 +1,39 @@
+import { DataSource, DataSourceField, DataSourceMetadata, DataSourceSchema } from '@sisense/sdk-data';
+import { HttpClient } from '@sisense/sdk-rest-client';
+import { JaqlResponse, JaqlQueryPayload, QueryGuid } from '../types.js';
+export declare class QueryApiDispatcher {
+    private httpClient;
+    constructor(httpClient: HttpClient);
+    getDataSourceFields(dataSource: DataSource, count?: number, offset?: number): Promise<DataSourceField[] | undefined>;
+    /**
+     * Returns a list of data sources.
+     * This method works with user of viewer role or above.
+     */
+    getDataSourceList(): Promise<DataSourceMetadata[] | undefined>;
+    /**
+     * Returns the schema of a data source by its name.
+     */
+    getDataSourceSchema(dataSourceName: string): Promise<DataSourceSchema | undefined>;
+    sendJaqlRequest(dataSource: DataSource, jaqlPayload: JaqlQueryPayload): {
+        responsePromise: Promise<JaqlResponse | undefined>;
+        abortHttpRequest: (reason?: string) => void;
+    };
+    sendDownloadCsvRequest(dataSource: DataSource, jaqlPayload: JaqlQueryPayload): {
+        responsePromise: Promise<ReadableStream<any> | undefined>;
+        abortHttpRequest: (reason?: string) => void;
+    };
+    /**
+     * Sends a request to cancel a JAQL query.
+     *
+     * @param guid - The guid of the query to cancel.
+     * @param dataSource - The datasource of where query sent.
+     */
+    sendCancelJaqlQueryRequest(guid: QueryGuid, dataSource: DataSource): Promise<void>;
+    /**
+     * Sends a request to cancel multiple JAQL queries.
+     *
+     * @param guids - The guids of the queries to cancel.
+     * @param dataSource - The datasource of where queries sent.
+     */
+    sendCancelMultipleJaqlQueriesRequest(guids: QueryGuid[], dataSource: DataSource): Promise<void>;
+}

package/dist/cjs/query-api-dispatcher/query-api-dispatcher.js

@@ -0,0 +1,148 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryApiDispatcher = void 0;
+const sdk_data_1 = require("@sisense/sdk-data");
+const translatable_error_js_1 = require("../translation/translatable-error.js");
+const API_DATASOURCES_BASE_PATH = 'api/datasources';
+const API_DATAMODELS_BASE_PATH = 'api/v2/datamodels';
+class QueryApiDispatcher {
+    constructor(httpClient) {
+        this.httpClient = httpClient;
+    }
+    getDataSourceFields(dataSource, count = 9999, offset = 0) {
+        const dataSourceName = (0, sdk_data_1.getDataSourceName)(dataSource);
+        const url = `${API_DATASOURCES_BASE_PATH}/${encodeURI(dataSourceName)}/fields/search`;
+        // when error is encountered, API returns only status code 400 without informative error message
+        // to remedy, catch error and throw a more informative error message
+        return this.httpClient.post(url, { offset, count }).catch(() => {
+            throw new translatable_error_js_1.TranslatableError('errors.dataSourceNotFound', {
+                dataSource: typeof dataSource === 'string' ? dataSource : dataSource.title,
+            });
+        });
+    }
+    /**
+     * Returns a list of data sources.
+     * This method works with user of viewer role or above.
+     */
+    getDataSourceList() {
+        const url = `${API_DATASOURCES_BASE_PATH}/?sharedWith=r,w`;
+        return this.httpClient.get(url);
+    }
+    /**
+     * Returns the schema of a data source by its name.
+     */
+    getDataSourceSchema(dataSourceName) {
+        const url = `${API_DATAMODELS_BASE_PATH}/schema?title=${encodeURIComponent(dataSourceName)}`;
+        return this.httpClient.get(url);
+    }
+    sendJaqlRequest(dataSource, jaqlPayload) {
+        const url = getJaqlUrl(dataSource);
+        const abortController = new AbortController();
+        return {
+            responsePromise: this.httpClient
+                .post(url, jaqlPayload, undefined, abortController.signal)
+                .then((response) => {
+                if (Array.isArray(response)) {
+                    return {
+                        values: [],
+                        metadata: [],
+                    };
+                }
+                return response;
+            }),
+            abortHttpRequest: (reason) => abortController.abort(reason),
+        };
+    }
+    sendDownloadCsvRequest(dataSource, jaqlPayload) {
+        const url = getDownloadCsvUrl(dataSource);
+        const abortController = new AbortController();
+        const params = new URLSearchParams();
+        params.append('data', encodeURIComponent(JSON.stringify(jaqlPayload)));
+        return {
+            responsePromise: this.httpClient.post(url, params, { headers: { 'Content-Type': 'application/x-www-form-urlencoded' } }, abortController.signal, { nonJSONBody: true, returnBlob: true }),
+            abortHttpRequest: (reason) => abortController.abort(reason),
+        };
+    }
+    /**
+     * Sends a request to cancel a JAQL query.
+     *
+     * @param guid - The guid of the query to cancel.
+     * @param dataSource - The datasource of where query sent.
+     */
+    sendCancelJaqlQueryRequest(guid, dataSource) {
+        return this.sendCancelMultipleJaqlQueriesRequest([guid], dataSource);
+    }
+    /**
+     * Sends a request to cancel multiple JAQL queries.
+     *
+     * @param guids - The guids of the queries to cancel.
+     * @param dataSource - The datasource of where queries sent.
+     */
+    sendCancelMultipleJaqlQueriesRequest(guids, dataSource) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const payload = {
+                queries: guids.join(';'),
+            };
+            const regularUrl = getRegularCancelQueryUrl(dataSource);
+            try {
+                yield this.httpClient.post(regularUrl, payload);
+            }
+            catch (error) {
+                if (error.status === '404') {
+                    // probably this datasource is live and requires a different URL for canceling queries
+                    const liveUrl = getLiveCancelQueryUrl(dataSource);
+                    yield this.httpClient.post(liveUrl, payload);
+                }
+                else {
+                    throw error;
+                }
+            }
+        });
+    }
+}
+exports.QueryApiDispatcher = QueryApiDispatcher;
+/**
+ * Returns the URL for canceling queries for a regular (non-live) datasource.
+ *
+ * @param dataSource - The data source of the query.
+ */
+function getRegularCancelQueryUrl(dataSource) {
+    const datasourcePath = encodeURIComponent((0, sdk_data_1.getDataSourceName)(dataSource));
+    return `${API_DATASOURCES_BASE_PATH}/localhost/${datasourcePath}/cancel_queries`;
+}
+/**
+ * Returns the URL for canceling queries for a live datasource.
+ * Live datasources require a different URL for canceling queries.
+ *
+ * @param dataSource - The data source of the query.
+ */
+function getLiveCancelQueryUrl(dataSource) {
+    const datasourcePath = encodeURIComponent((0, sdk_data_1.getDataSourceName)(dataSource));
+    return `${API_DATASOURCES_BASE_PATH}/live/${datasourcePath}/cancel_queries`;
+}
+/**
+ * Returns the URL for sending a JAQL request.
+ *
+ * @param dataSource - The data source of the query.
+ */
+function getJaqlUrl(dataSource) {
+    const dataSourcePath = encodeURIComponent((0, sdk_data_1.getDataSourceName)(dataSource));
+    return `${API_DATASOURCES_BASE_PATH}/${dataSourcePath}/jaql`;
+}
+/**
+ * Returns the URL for sending a Download CSV request.
+ *
+ * @param dataSource - The data source of the query.
+ */
+function getDownloadCsvUrl(dataSource) {
+    return `${getJaqlUrl(dataSource)}/csv`;
+}

package/dist/cjs/query-client.d.ts

@@ -0,0 +1,56 @@
+import { 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, 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<import("@sisense/sdk-data").DataSourceField[]>;
+    /**
+     * Returns the schema of a data source by its name.
+     */
+    getDataSourceSchema(datasourceName: string): Promise<import("@sisense/sdk-data").DataSourceSchema | undefined>;
+    /**
+     * Returns a list of data sources
+     */
+    getDataSourceList(): Promise<import("@sisense/sdk-data").DataSourceMetadata[]>;
+}
+/**
+ * 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): 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;