@sisense/sdk-query-client 1.20.0 → 1.22.0

package/dist/cjs/query-client.js

@@ -0,0 +1,203 @@
+"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.validatePivotQueryDescription = exports.validateQueryDescription = exports.DimensionalQueryClient = exports.QUERY_DEFAULT_LIMIT = void 0;
+const query_task_manager_js_1 = require("./query-task-manager/query-task-manager.js");
+const query_task_passport_js_1 = require("./query-task-manager/query-task-passport.js");
+const task_manager_1 = require("@sisense/task-manager");
+const query_api_dispatcher_js_1 = require("./query-api-dispatcher/query-api-dispatcher.js");
+const sdk_data_1 = require("@sisense/sdk-data");
+const translatable_error_js_1 = require("./translation/translatable-error.js");
+const sdk_pivot_client_1 = require("@sisense/sdk-pivot-client");
+/** @internal */
+exports.QUERY_DEFAULT_LIMIT = 20000;
+const UNSPECIFIED_REASON = 'Unspecified reason';
+class DimensionalQueryClient {
+    constructor(httpClient, pivotClient = new sdk_pivot_client_1.PivotClient(httpClient.url, httpClient.auth), shouldSkipHighlightsWithoutAttributes) {
+        validateHttpClient(httpClient);
+        this.queryApi = new query_api_dispatcher_js_1.QueryApiDispatcher(httpClient);
+        this.taskManager = new query_task_manager_js_1.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
+     */
+    executeQuery(queryDescription, config) {
+        const taskPassport = new query_task_passport_js_1.QueryTaskPassport('SEND_JAQL_QUERY', queryDescription, Object.assign(Object.assign({}, (config ? config : {})), { shouldSkipHighlightsWithoutAttributes: this.shouldSkipHighlightsWithoutAttributes || false }));
+        return {
+            resultPromise: new Promise((resolve, reject) => {
+                validateQueryDescription(queryDescription);
+                void this.taskManager.executeQuerySending(taskPassport).then((executionResult) => {
+                    if (executionResult.status === task_manager_1.ExecutionResultStatus.SUCCESS) {
+                        resolve(executionResult.result);
+                    }
+                    else {
+                        reject(executionResult.error);
+                    }
+                });
+            }),
+            cancel: (reason) => this.taskManager.cancel(taskPassport.taskId, reason || UNSPECIFIED_REASON),
+        };
+    }
+    executeCsvQuery(queryDescription, config) {
+        const taskPassport = new query_task_passport_js_1.QueryTaskPassport('SEND_DOWNLOAD_CSV_QUERY', queryDescription, Object.assign(Object.assign({}, (config ? config : {})), { shouldSkipHighlightsWithoutAttributes: this.shouldSkipHighlightsWithoutAttributes || false }));
+        return {
+            resultPromise: new Promise((resolve, reject) => {
+                validateQueryDescription(queryDescription);
+                void this.taskManager.executeDownloadCsvSending(taskPassport).then((executionResult) => {
+                    if (executionResult.status === task_manager_1.ExecutionResultStatus.SUCCESS) {
+                        resolve(executionResult.result);
+                    }
+                    else {
+                        reject(executionResult.error);
+                    }
+                });
+            }),
+            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) {
+        const taskPassport = new query_task_passport_js_1.PivotQueryTaskPassport('SEND_JAQL_QUERY', pivotQueryDescription, Object.assign(Object.assign({}, (config ? config : {})), { shouldSkipHighlightsWithoutAttributes: this.shouldSkipHighlightsWithoutAttributes || false }));
+        return {
+            resultPromise: new Promise((resolve, reject) => {
+                validatePivotQueryDescription(pivotQueryDescription);
+                void this.taskManager.executePivotQuerySending(taskPassport).then((executionResult) => {
+                    if (executionResult.status === task_manager_1.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) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataSourceFields = yield this.queryApi.getDataSourceFields(dataSource, count, offset);
+            return dataSourceFields || [];
+        });
+    }
+    /**
+     * Returns the schema of a data source by its name.
+     */
+    getDataSourceSchema(datasourceName) {
+        return this.queryApi.getDataSourceSchema(datasourceName);
+    }
+    /**
+     * Returns a list of data sources
+     */
+    getDataSourceList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const dataSourceList = yield this.queryApi.getDataSourceList();
+            return dataSourceList || [];
+        });
+    }
+}
+exports.DimensionalQueryClient = DimensionalQueryClient;
+/**
+ * Validates query description
+ *
+ * @param queryDescription - query description to validate
+ * @param config - query execution configuration
+ * @throws Error if query description is invalid
+ */
+function validateQueryDescription(queryDescription) {
+    const { attributes, measures, filters, highlights, count, offset } = queryDescription;
+    if (count && count < 0) {
+        throw new translatable_error_js_1.TranslatableError('errors.invalidCountNegative', { count: count.toString() });
+    }
+    if (offset && offset < 0) {
+        throw new translatable_error_js_1.TranslatableError('errors.invalidOffset', { offset: offset.toString() });
+    }
+    if (attributes.length + measures.length === 0) {
+        throw new translatable_error_js_1.TranslatableError('errors.noDimensionsOrMeasures');
+    }
+    attributes.forEach((attribute) => {
+        if (!attribute.skipValidation && !sdk_data_1.MetadataTypes.isAttribute(attribute)) {
+            const { name: attributeName } = attribute;
+            throw new translatable_error_js_1.TranslatableError('errors.invalidAttribute', { attributeName });
+        }
+    });
+    measures.forEach((measure) => {
+        if (!measure.skipValidation && !sdk_data_1.MetadataTypes.isMeasure(measure)) {
+            throw new translatable_error_js_1.TranslatableError('errors.invalidMeasure', { measureName: measure.name });
+        }
+    });
+    filters.forEach((filter) => {
+        if (!filter.skipValidation && !sdk_data_1.MetadataTypes.isFilter(filter)) {
+            throw new translatable_error_js_1.TranslatableError('errors.invalidFilter', { filterName: filter.name });
+        }
+    });
+    highlights.forEach((highlight) => {
+        if (!highlight.skipValidation && !sdk_data_1.MetadataTypes.isFilter(highlight)) {
+            throw new translatable_error_js_1.TranslatableError('errors.invalidHighlight', { highlightName: highlight.name });
+        }
+    });
+}
+exports.validateQueryDescription = validateQueryDescription;
+/**
+ * Validates pivot query description
+ *
+ * @param queryDescription - pivot query description to validate
+ * @throws Error if query description is invalid
+ */
+function validatePivotQueryDescription(queryDescription) {
+    const { rowsAttributes, columnsAttributes, measures, filters, highlights, count, offset } = queryDescription;
+    if (count && count < 0) {
+        throw new translatable_error_js_1.TranslatableError('errors.invalidCountNegative', { count: count.toString() });
+    }
+    if (offset && offset < 0) {
+        throw new translatable_error_js_1.TranslatableError('errors.invalidOffset', { offset: offset.toString() });
+    }
+    if (rowsAttributes.length + columnsAttributes.length + measures.length === 0) {
+        throw new translatable_error_js_1.TranslatableError('errors.noDimensionsOrMeasures');
+    }
+    filters.forEach((filter) => {
+        if (!filter.skipValidation && !sdk_data_1.MetadataTypes.isFilter(filter)) {
+            throw new translatable_error_js_1.TranslatableError('errors.invalidFilter', { filterName: filter.name });
+        }
+    });
+    highlights.forEach((highlight) => {
+        if (!highlight.skipValidation && !sdk_data_1.MetadataTypes.isFilter(highlight)) {
+            throw new translatable_error_js_1.TranslatableError('errors.invalidHighlight', { highlightName: highlight.name });
+        }
+    });
+}
+exports.validatePivotQueryDescription = validatePivotQueryDescription;
+/**
+ * Validates http client
+ *
+ * @param httpClient - http client to validate
+ * @throws Error if http client is invalid
+ */
+function validateHttpClient(httpClient) {
+    if (!httpClient) {
+        throw new translatable_error_js_1.TranslatableError('errors.missingHttpClient');
+    }
+    if (!httpClient.post) {
+        throw new translatable_error_js_1.TranslatableError('errors.missingPostMethod');
+    }
+}

package/dist/cjs/query-result/get-data-from-query-result.d.ts

@@ -0,0 +1,12 @@
+import { Cell, DataCell, Element, QueryResultData } from '@sisense/sdk-data';
+import { JaqlResponse } from '../types.js';
+export declare const getDataFromQueryResult: (result: JaqlResponse, metadata: Element[]) => QueryResultData;
+export declare function prepareResultAsColsAndRows(data: DataCell[][], metadata: Element[]): QueryResultData;
+/**
+ * Sets the `blur` property for each cell in a 2D array of data cells based on the `selected` property.
+ *
+ * @param rows - The 2D array of data cells representing rows and columns.
+ * @returns A new 2D array of cells with the `blur` property set.
+ */
+export declare function setCellsBlur(rows: DataCell[][]): Cell[][];
+export declare function getQueryResultValues({ values, metadata }: JaqlResponse): DataCell[][];

package/dist/cjs/query-result/get-data-from-query-result.js

@@ -0,0 +1,77 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQueryResultValues = exports.setCellsBlur = exports.prepareResultAsColsAndRows = exports.getDataFromQueryResult = void 0;
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+const numeral_1 = __importDefault(require("numeral"));
+const sdk_data_1 = require("@sisense/sdk-data");
+const getDataFromQueryResult = (result, metadata) => {
+    const values = getQueryResultValues(result);
+    return prepareResultAsColsAndRows(values, metadata);
+};
+exports.getDataFromQueryResult = getDataFromQueryResult;
+function prepareResultAsColsAndRows(data, metadata) {
+    return {
+        columns: metadata === null || metadata === void 0 ? void 0 : metadata.map((d) => ({
+            name: d.name,
+            type: (0, sdk_data_1.simpleColumnType)(d.type),
+        })),
+        rows: setCellsBlur(data),
+    };
+}
+exports.prepareResultAsColsAndRows = prepareResultAsColsAndRows;
+/**
+ * Sets the `blur` property for each cell in a 2D array of data cells based on the `selected` property.
+ *
+ * @param rows - The 2D array of data cells representing rows and columns.
+ * @returns A new 2D array of cells with the `blur` property set.
+ */
+function setCellsBlur(rows) {
+    var _a;
+    // A boolean flag indicating whether highlight is enabled on some column.
+    let isHighlightEnabledSomeColumn = false;
+    // An array indicating whether highlight is enabled per each column.
+    const highlightEnabledPerColumn = (_a = rows[0]) === null || _a === void 0 ? void 0 : _a.map((_value, index) => {
+        const isHighlightEnabled = rows.some((r) => 'selected' in r[index]);
+        if (isHighlightEnabled) {
+            isHighlightEnabledSomeColumn = true;
+        }
+        return isHighlightEnabled;
+    });
+    return rows.map((r) => {
+        // calculates a single `blur` value for a whole row based on each column (cell) configuration.
+        // true: the data value is blurred
+        // false: the data value is highlighted
+        // undefined: the data value is neutral (neither highlighted nor blurred)
+        const blur = !isHighlightEnabledSomeColumn
+            ? undefined
+            : highlightEnabledPerColumn.some((isHighlightEnabled, columnIndex) => isHighlightEnabled && !r[columnIndex].selected);
+        return r.map((d) => blur !== undefined
+            ? {
+                data: d.data,
+                text: d.text,
+                blur,
+            }
+            : { data: d.data, text: d.text });
+    });
+}
+exports.setCellsBlur = setCellsBlur;
+function getQueryResultValues({ values = [], metadata = [] }) {
+    var _a, _b, _c, _d;
+    // fixing measures query result
+    if (values[0] && !Array.isArray(values[0])) {
+        values = [values];
+    }
+    for (let i = 0; i < values.length; i++) {
+        const row = values[i];
+        for (let c = 0; c < row.length; c++) {
+            if (metadata[c].format && ((_b = (_a = metadata[c]) === null || _a === void 0 ? void 0 : _a.format) === null || _b === void 0 ? void 0 : _b.number)) {
+                row[c].text = (0, numeral_1.default)(row[c].data).format((_d = (_c = metadata[c]) === null || _c === void 0 ? void 0 : _c.format) === null || _d === void 0 ? void 0 : _d.number);
+            }
+        }
+    }
+    return values;
+}
+exports.getQueryResultValues = getQueryResultValues;

package/dist/cjs/query-result/index.d.ts

@@ -0,0 +1 @@
+export * from './get-data-from-query-result.js';

package/dist/cjs/query-result/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("./get-data-from-query-result.js"), exports);

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

@@ -0,0 +1,40 @@
+import { AbstractTaskManager } from '@sisense/task-manager';
+import { JaqlResponse } from '../types.js';
+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';
+import { EmptyObject } from '../helpers/utility-types.js';
+export declare class QueryTaskManager extends AbstractTaskManager {
+    /** Map of aborters by task id to be able to cancel sent requests */
+    private sentRequestsAbortersMap;
+    private queryApi;
+    /**
+     * 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 | undefined): asserts jaqlResponse is JaqlResponse;

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

@@ -0,0 +1,133 @@
+"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.validateJaqlResponse = exports.QueryTaskManager = void 0;
+const task_manager_1 = require("@sisense/task-manager");
+const get_jaql_query_payload_js_1 = require("../jaql/get-jaql-query-payload.js");
+const index_js_1 = require("../query-result/index.js");
+const query_client_js_1 = require("../query-client.js");
+const translatable_error_js_1 = require("../translation/translatable-error.js");
+class QueryTaskManager extends task_manager_1.AbstractTaskManager {
+    constructor(queryApi, pivotClient) {
+        super();
+        /** Map of aborters by task id to be able to cancel sent requests */
+        this.sentRequestsAbortersMap = new Map();
+        this.executeQuerySending = super.createFlow([
+            new task_manager_1.Step('PREPARE_JAQL_PAYLOAD', this.prepareJaqlPayload.bind(this), () => __awaiter(this, void 0, void 0, function* () { })),
+            new task_manager_1.Step('SEND_JAQL_QUERY', this.sendJaqlQuery.bind(this), this.cancelDataRetrievalQuery.bind(this)),
+        ]);
+        this.executeDownloadCsvSending = super.createFlow([
+            new task_manager_1.Step('PREPARE_JAQL_PAYLOAD', this.prepareJaqlPayload.bind(this), () => __awaiter(this, void 0, void 0, function* () { })),
+            new task_manager_1.Step('SEND_DOWNLOAD_CSV_QUERY', this.sendCsvQuery.bind(this), this.cancelDataRetrievalQuery.bind(this)),
+        ]);
+        this.executePivotQuerySending = super.createFlow([
+            new task_manager_1.Step('PREPARE_JAQL_PAYLOAD', this.preparePivotJaqlPayload.bind(this), () => __awaiter(this, void 0, void 0, function* () { })),
+            new task_manager_1.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* () {
+            const { queryDescription, executionConfig } = task.passport;
+            const jaqlPayload = (0, get_jaql_query_payload_js_1.getJaqlQueryPayload)(queryDescription, executionConfig.shouldSkipHighlightsWithoutAttributes);
+            const onBeforeQuery = task.passport.executionConfig.onBeforeQuery;
+            if (onBeforeQuery) {
+                return onBeforeQuery(jaqlPayload);
+            }
+            return jaqlPayload;
+        });
+    }
+    sendJaqlQuery(task, jaqlPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { queryDescription, taskId } = task.passport;
+            const { responsePromise, abortHttpRequest } = this.queryApi.sendJaqlRequest(task.passport.queryDescription.dataSource, jaqlPayload);
+            this.sentRequestsAbortersMap.set(taskId, abortHttpRequest);
+            const jaqlResponse = yield responsePromise.finally(() => {
+                this.sentRequestsAbortersMap.delete(taskId);
+            });
+            validateJaqlResponse(jaqlResponse);
+            const metadata = [...queryDescription.attributes, ...queryDescription.measures];
+            // extra columns are assumed to have been added by advanced analytics functions
+            const extraColumns = (jaqlResponse.headers || [])
+                .slice(metadata.length)
+                .map((c) => ({ name: c, type: 'number' }));
+            return (0, index_js_1.getDataFromQueryResult)(jaqlResponse, [...metadata, ...extraColumns]);
+        });
+    }
+    sendCsvQuery(task, jaqlPayload) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { taskId } = task.passport;
+            const { responsePromise, abortHttpRequest } = this.queryApi.sendDownloadCsvRequest(task.passport.queryDescription.dataSource, jaqlPayload);
+            this.sentRequestsAbortersMap.set(taskId, abortHttpRequest);
+            return responsePromise.finally(() => {
+                this.sentRequestsAbortersMap.delete(taskId);
+            });
+        });
+    }
+    cancelDataRetrievalQuery(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.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 = (0, get_jaql_query_payload_js_1.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_client_js_1.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);
+    }
+}
+exports.QueryTaskManager = QueryTaskManager;
+function validateJaqlResponse(jaqlResponse) {
+    var _a;
+    if (!jaqlResponse) {
+        throw new translatable_error_js_1.TranslatableError('errors.noJaqlResponse');
+    }
+    if (jaqlResponse.error) {
+        throw new Error(`${jaqlResponse.details} ${(_a = jaqlResponse.database) !== null && _a !== void 0 ? _a : ''} ${jaqlResponse.extraDetails ? JSON.stringify(jaqlResponse.extraDetails) : ''}`);
+    }
+}
+exports.validateJaqlResponse = validateJaqlResponse;

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

@@ -0,0 +1,16 @@
+import { TaskPassport } from '@sisense/task-manager';
+import { PivotQueryDescription, QueryDescription, QueryExecutionConfigInternal } from '../types.js';
+type TaskType = 'SEND_JAQL_QUERY' | 'SEND_DOWNLOAD_CSV_QUERY';
+export declare class QueryTaskPassport extends TaskPassport {
+    queryDescription: QueryDescription;
+    executionConfig: QueryExecutionConfigInternal;
+    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/cjs/query-task-manager/query-task-passport.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PivotQueryTaskPassport = exports.QueryTaskPassport = void 0;
+const task_manager_1 = require("@sisense/task-manager");
+class QueryTaskPassport extends task_manager_1.TaskPassport {
+    constructor(type, queryDescription, executionConfig) {
+        super();
+        this.queryDescription = queryDescription;
+        this.type = type;
+        this.executionConfig = executionConfig;
+    }
+}
+exports.QueryTaskPassport = QueryTaskPassport;
+class PivotQueryTaskPassport extends task_manager_1.TaskPassport {
+    constructor(type, pivotQueryDescription, executionConfig) {
+        super();
+        this.pivotQueryDescription = pivotQueryDescription;
+        this.type = type;
+        this.executionConfig = executionConfig;
+    }
+}
+exports.PivotQueryTaskPassport = PivotQueryTaskPassport;

package/dist/cjs/translation/initialize-i18n.d.ts

@@ -0,0 +1,2 @@
+export declare function initializeI18n(): import("@sisense/sdk-common").I18NextInitResult;
+export declare const i18nextInstance: import("i18next").i18n;

package/dist/cjs/translation/initialize-i18n.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.i18nextInstance = exports.initializeI18n = void 0;
+const sdk_common_1 = require("@sisense/sdk-common");
+const index_js_1 = require("./resources/index.js");
+function initializeI18n() {
+    return (0, sdk_common_1.initI18next)({
+        resource: index_js_1.resources,
+        language: 'en',
+        namespace: index_js_1.PACKAGE_NAMESPACE,
+    });
+}
+exports.initializeI18n = initializeI18n;
+exports.i18nextInstance = initializeI18n().i18nextInstance;

package/dist/cjs/translation/resources/en.d.ts

@@ -0,0 +1,16 @@
+export declare const translation: {
+    errors: {
+        invalidAttribute: string;
+        noDimensionsOrMeasures: string;
+        invalidMeasure: string;
+        invalidFilter: string;
+        invalidHighlight: string;
+        invalidCountNegative: string;
+        invalidOffset: string;
+        missingHttpClient: string;
+        missingPostMethod: string;
+        noJaqlResponse: string;
+        dataSourceNotFound: string;
+    };
+};
+export type TranslationDictionary = typeof translation;

package/dist/cjs/translation/resources/en.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translation = void 0;
+exports.translation = {
+    errors: {
+        invalidAttribute: 'Invalid attribute {{attributeName}}. Hint: attributes for query should be extracted from the data model generated by the CLI tool.',
+        noDimensionsOrMeasures: 'Neither dimensions nor measures found. Query should have at least one dimension or measure.',
+        invalidMeasure: 'Invalid measure "{{measureName}}". Hint: measures for the query can be constructed using the "measureFactory" functions.',
+        invalidFilter: 'Invalid filter "{{filterName}}". Hint: filters for the query can be constructed using the "filterFactory" functions.',
+        invalidHighlight: 'Invalid highlight "{{highlightName}}". Hint: highlights for the query can be constructed using the "filterFactory" functions.',
+        invalidCountNegative: 'Invalid count "{{count}}". Count should be non-negative.',
+        invalidOffset: 'Invalid offset "{{offset}}". Offset should be non-negative.',
+        missingHttpClient: 'Query requires httpClient to work properly.',
+        missingPostMethod: 'httpClient must provide "post" method.',
+        noJaqlResponse: 'No jaql response received from the server',
+        dataSourceNotFound: 'Failed to get fields for data source "{{dataSource}}". Please make sure the data source exists and is accessible.',
+    },
+};

package/dist/cjs/translation/resources/index.d.ts

@@ -0,0 +1,35 @@
+import { TranslationDictionary } from './en.js';
+export type { TranslationDictionary };
+export declare const PACKAGE_NAMESPACE: "sdkQueryClient";
+export declare const resources: {
+    en: {
+        errors: {
+            invalidAttribute: string;
+            noDimensionsOrMeasures: string;
+            invalidMeasure: string;
+            invalidFilter: string;
+            invalidHighlight: string;
+            invalidCountNegative: string;
+            invalidOffset: string;
+            missingHttpClient: string;
+            missingPostMethod: string;
+            noJaqlResponse: string;
+            dataSourceNotFound: string;
+        };
+    };
+    uk: {
+        errors: {
+            invalidAttribute: string;
+            noDimensionsOrMeasures: string;
+            invalidMeasure: string;
+            invalidFilter: string;
+            invalidHighlight: string;
+            invalidCountNegative: string;
+            invalidOffset: string;
+            missingHttpClient: string;
+            missingPostMethod: string;
+            noJaqlResponse: string;
+            dataSourceNotFound: string;
+        };
+    };
+};

package/dist/cjs/translation/resources/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resources = exports.PACKAGE_NAMESPACE = void 0;
+const en_js_1 = require("./en.js");
+const uk_js_1 = require("./uk.js");
+exports.PACKAGE_NAMESPACE = 'sdkQueryClient';
+exports.resources = {
+    en: en_js_1.translation,
+    uk: uk_js_1.translation,
+};

package/dist/cjs/translation/resources/uk.d.ts

@@ -0,0 +1,2 @@
+import { TranslationDictionary } from './index.js';
+export declare const translation: TranslationDictionary;

package/dist/cjs/translation/resources/uk.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translation = void 0;
+exports.translation = {
+    errors: {
+        invalidAttribute: 'Недійсний атрибут {{attributeName}}. Підказка: атрибути для запиту повинні бути витягнуті з моделі даних, створеної за допомогою CLI-інструменту.',
+        noDimensionsOrMeasures: 'Не знайдено ні вимірів, ні показників. Запит повинен мати щонайменше один вимір або показник.',
+        invalidMeasure: 'Недійсний показник "{{measureName}}". Підказка: показники для запиту можна створити за допомогою функцій "measureFactory".',
+        invalidFilter: 'Недійсний фільтр "{{filterName}}". Підказка: фільтри для запиту можна створити за допомогою функцій "filterFactory".',
+        invalidHighlight: 'Недійсне виділення "{{highlightName}}". Підказка: виділення для запиту можна створити за допомогою функцій "filterFactory".',
+        invalidCountNegative: 'Недійсний count "{{count}}". Count повинен бути не від\'ємним.',
+        invalidOffset: 'Недійсний offset "{{offset}}". Offset повинен бути не від\'ємним.',
+        missingHttpClient: 'Для запиту потрібен httpClient, щоб працювати належним чином.',
+        missingPostMethod: 'httpClient повинен мати метод "post".',
+        noJaqlResponse: 'Відповіді, що містить jaql, від сервера не отримано',
+        dataSourceNotFound: 'Не вдалося отримати поля для джерела даних "{{dataSource}}". Переконайтесь що джерело існує і доступне.',
+    },
+};