@sisense/sdk-pivot-query-client 2.17.0

package/dist/cjs/builders/pivot-data-builder.d.ts

@@ -0,0 +1,34 @@
+import { PivotQueryResultData } from '@sisense/sdk-data';
+import { InitPageData } from '../data-handling/types.js';
+import { DataLoadServiceI, JaqlRequest, SocketI } from '../data-load/types.js';
+export declare class PivotDataBuilder {
+    /**
+     * DataLoadServiceI instance
+     */
+    private dataLoadService?;
+    /**
+     * SocketI instance
+     */
+    private readonly socket;
+    /**
+     * @param socket - socket instance
+     */
+    constructor(socket: SocketI);
+    destroy(): void;
+    prepareRequest(jaql: JaqlRequest): Promise<JaqlRequest>;
+    prepareLoadService(jaql?: JaqlRequest, useCache?: boolean): DataLoadServiceI;
+    prepareDataService(dataLoadService: DataLoadServiceI): {
+        loadData: (jaql?: JaqlRequest, pageSize?: number, isPaginated?: boolean) => Promise<InitPageData>;
+    };
+    loadInitData(jaql: JaqlRequest, isPaginated?: boolean, elementsPerPage?: number, useCache?: boolean): Promise<PivotQueryResultData>;
+    private buildColumnsHelper;
+    /**
+     * Transforms Pivot Grid to Columns of Table structure
+     *
+     * @param columnType - type of column
+     * @param grid - pivot grid
+     * @returns An array of columns
+     */
+    private transformGridToColumns;
+    private transformTreeStructuresToResultData;
+}

package/dist/cjs/builders/pivot-data-builder.js

@@ -0,0 +1,186 @@
+"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.PivotDataBuilder = void 0;
+const sdk_data_1 = require("@sisense/sdk-data");
+const DataService_js_1 = require("../data-handling/DataService.js");
+const index_js_1 = require("../data-load/index.js");
+class PivotDataBuilder {
+    /**
+     * @param socket - socket instance
+     */
+    constructor(socket) {
+        this.socket = socket;
+    }
+    destroy() { }
+    prepareRequest(jaql) {
+        return Promise.resolve(jaql);
+    }
+    prepareLoadService(jaql, useCache = false) {
+        if (this.dataLoadService && (useCache || this.dataLoadService.isFormattingChanges(jaql))) {
+            return this.dataLoadService;
+        }
+        return new index_js_1.SisenseDataLoadService(this.socket);
+    }
+    prepareDataService(dataLoadService) {
+        const dataService = new DataService_js_1.DataService(dataLoadService);
+        return {
+            loadData: (jaql, pageSize, isPaginated) => {
+                if (!dataService) {
+                    throw new Error('No DataService defined during "prepareDataService"');
+                }
+                return dataService.loadData(jaql, { pageSize, isPaginated });
+            },
+        };
+    }
+    loadInitData(jaql, isPaginated = true, elementsPerPage = 100, useCache = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pageSize = isPaginated ? elementsPerPage : undefined;
+            try {
+                const jaqlInternal = yield this.prepareRequest(jaql);
+                // Currently, each jaql need a separate dataLoadService instance
+                // In other words, each dataLoadService is associated with a jaql
+                this.dataLoadService = this.prepareLoadService(jaqlInternal, useCache);
+                const { loadData } = this.prepareDataService(this.dataLoadService);
+                const { rowsTreeService, columnsTreeService, cornerTreeService, isLastPage } = yield loadData(useCache ? undefined : jaqlInternal, pageSize, isPaginated);
+                return this.transformTreeStructuresToResultData({
+                    rowsTreeService,
+                    columnsTreeService,
+                    cornerTreeService,
+                    isLastPage,
+                });
+            }
+            catch (err) {
+                console.error('Error during loading initial page"', err);
+            }
+            return sdk_data_1.EMPTY_PIVOT_QUERY_RESULT_DATA;
+        });
+    }
+    buildColumnsHelper(columnType, columns, prefix, treeNode) {
+        var _a;
+        const columnName = `${prefix}${prefix === '' ? '' : ' | '}${(_a = treeNode.value) === null || _a === void 0 ? void 0 : _a.toString()}`;
+        if (treeNode.children) {
+            treeNode.children.forEach((child) => {
+                this.buildColumnsHelper(columnType, columns, columnName, child);
+            });
+        }
+        else {
+            columns.push({ name: columnName, type: columnType });
+        }
+    }
+    /**
+     * Transforms Pivot Grid to Columns of Table structure
+     *
+     * @param columnType - type of column
+     * @param grid - pivot grid
+     * @returns An array of columns
+     */
+    transformGridToColumns(columnType, grid) {
+        if (!grid || grid.length === 0) {
+            return [];
+        }
+        const columns = [];
+        grid === null || grid === void 0 ? void 0 : grid[0].forEach((cell) => {
+            if (typeof cell === 'string')
+                return;
+            this.buildColumnsHelper(columnType, columns, '', cell);
+        });
+        return columns || [];
+    }
+    // eslint-disable-next-line sonarjs/cognitive-complexity,max-lines-per-function
+    transformTreeStructuresToResultData(pivotTreeData) {
+        const { rowsTreeService, columnsTreeService, cornerTreeService } = pivotTreeData;
+        if (!rowsTreeService && !columnsTreeService && !cornerTreeService) {
+            return sdk_data_1.EMPTY_PIVOT_QUERY_RESULT_DATA;
+        }
+        const cornerGrid = cornerTreeService ? cornerTreeService.getGrid() : [];
+        const columnsGrid = columnsTreeService ? columnsTreeService.getGrid() : [];
+        const rowsGrid = rowsTreeService ? rowsTreeService.getGrid() : [];
+        const cornerColumns = this.transformGridToColumns('string', cornerGrid);
+        const columnsColumns = this.transformGridToColumns('number', columnsGrid);
+        const columns = [...cornerColumns, ...columnsColumns];
+        const FILL_IN_THE_BLANKS = true;
+        const valuesGrid = rowsTreeService
+            ? rowsTreeService.extractData(columnsTreeService)
+            : [];
+        const rowCount = rowsGrid.length;
+        const columnCount = columns.length;
+        const rows = [];
+        let curRowIndex = 0;
+        let curColIndex = 0;
+        Array.from(Array(rowCount)).map((c, rowIndex) => {
+            const row = [];
+            Array.from(Array(columnCount)).map((c, colIndex) => {
+                var _a, _b;
+                let dataNode;
+                if (colIndex < cornerColumns.length) {
+                    curRowIndex = rowIndex;
+                    curColIndex = colIndex;
+                    try {
+                        dataNode = rowsGrid[curRowIndex][curColIndex];
+                    }
+                    catch (err) {
+                        throw new Error(`Can't find data item for ${curRowIndex}-${curColIndex}`);
+                    }
+                }
+                else {
+                    curRowIndex = rowIndex;
+                    curColIndex = colIndex - cornerColumns.length;
+                    try {
+                        dataNode = valuesGrid[curRowIndex][curColIndex];
+                    }
+                    catch (err) {
+                        throw new Error(`Can't find data item for ${curRowIndex}-${curColIndex}`);
+                    }
+                }
+                let value;
+                if (typeof dataNode === 'string') {
+                    if (FILL_IN_THE_BLANKS) {
+                        const indexes = dataNode.split('-');
+                        // eslint-disable-next-line max-lines
+                        if (indexes.length === 2) {
+                            const parentRowIndex = Number(indexes[0]);
+                            const parentColIndex = Number(indexes[1]);
+                            dataNode = rowsGrid[parentRowIndex][parentColIndex];
+                            value = ((_a = dataNode.value) === null || _a === void 0 ? void 0 : _a.toString()) || '';
+                        }
+                        else {
+                            // eslint-disable-next-line max-lines
+                            value = '';
+                        }
+                    }
+                    else {
+                        value = '';
+                    }
+                    // eslint-disable-next-line max-lines
+                }
+                else {
+                    value = ((_b = dataNode.value) === null || _b === void 0 ? void 0 : _b.toString()) || '';
+                }
+                row.push({ data: value, text: value });
+            });
+            rows.push(row);
+        });
+        return {
+            table: {
+                columns: columns,
+                rows: rows,
+            },
+            grids: {
+                corner: cornerGrid,
+                rows: rowsGrid,
+                columns: columnsGrid,
+                values: valuesGrid,
+            },
+        };
+    }
+}
+exports.PivotDataBuilder = PivotDataBuilder;

package/dist/cjs/builders/socket-builder.d.ts

@@ -0,0 +1,18 @@
+import { Authenticator } from '@sisense/sdk-rest-client';
+import { SocketI } from '../data-load/types.js';
+export declare class SocketBuilder {
+    private _socket;
+    private readonly _url;
+    private readonly _auth;
+    /**
+     * Boolean flag to indicate if the socket should be mocked or not (for testing).
+     *
+     * @internal
+     */
+    private readonly _mockSocket;
+    constructor(url: string, auth: Authenticator, mockSocket?: boolean);
+    private getQueryOptionsSso;
+    private getQueryOptionsBearer;
+    private getQueryOptionsWat;
+    get socket(): SocketI;
+}

package/dist/cjs/builders/socket-builder.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SocketBuilder = void 0;
+const sdk_rest_client_1 = require("@sisense/sdk-rest-client");
+const index_js_1 = require("../data-load/index.js");
+const TestSocket_js_1 = __importDefault(require("../data-load/sockets/TestSocket.js"));
+/**
+ * Builder to create a web socket client on demand to communicate with a Sisense web socket server.
+ *
+ * @internal
+ */
+const PIVOT_NAMESPACE = 'pivot2';
+class SocketBuilder {
+    constructor(url, auth, mockSocket = false) {
+        this._url = url;
+        this._auth = auth;
+        this._mockSocket = mockSocket;
+    }
+    getQueryOptionsSso(auth) {
+        // No need to add query params as SSO authentication
+        // is using cookies sent automatically by the browser
+        return {};
+    }
+    getQueryOptionsBearer(auth) {
+        const authToken = auth.bearer;
+        if (!authToken) {
+            throw new Error('Missing bearer token');
+        }
+        return {
+            token: authToken,
+        };
+    }
+    getQueryOptionsWat(auth) {
+        const headers = new Headers();
+        auth.applyHeaders(headers);
+        const authorization = headers.get('Authorization');
+        const initialiser = headers.get('Initialiser');
+        if (!authorization || !initialiser) {
+            throw new Error('Missing auth header');
+        }
+        return {
+            authorization,
+            initialiser,
+        };
+    }
+    get socket() {
+        // initialize socket only when needed
+        if (!this._socket) {
+            if (this._mockSocket) {
+                // use a mock socket for testing
+                this._socket = new TestSocket_js_1.default();
+                return this._socket;
+            }
+            const auth = this._auth;
+            const url = this._url;
+            let query = {};
+            // Do not use instanceof because it checks if the constructors are the same.
+            // However, when the class is imported from @sisense/sdk-rest-client,
+            // the code gets its own copy of the constructor from the code in the library,
+            // so they are not the same instance anymore.
+            // Reference: https://stackoverflow.com/a/63937850/2425556
+            if ((0, sdk_rest_client_1.isBearerAuthenticator)(auth)) {
+                query = this.getQueryOptionsBearer(auth);
+            }
+            else if ((0, sdk_rest_client_1.isWatAuthenticator)(auth)) {
+                query = this.getQueryOptionsWat(auth);
+            }
+            else if ((0, sdk_rest_client_1.isSsoAuthenticator)(auth)) {
+                query = this.getQueryOptionsSso(auth);
+            }
+            this._socket = new index_js_1.SisenseSocket(url, query, PIVOT_NAMESPACE);
+        }
+        return this._socket;
+    }
+}
+exports.SocketBuilder = SocketBuilder;