@sisense/sdk-pivot-query-client 2.17.0

package/dist/cjs/data-load/sockets/TestSocket.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSocket = void 0;
+const events_1 = __importDefault(require("events"));
+class TestSocket {
+    constructor() {
+        /** @private */
+        this.ready = true;
+        this.events = new events_1.default();
+        this.ready = true;
+    }
+    /**
+     * Checks if socket is ready for sending messages or not
+     *
+     * @returns {boolean} - true - ready
+     */
+    isReady() {
+        return this.ready;
+    }
+    /**
+     * Attach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    on(event, cb) {
+        this.events.on(event, cb);
+    }
+    /**
+     * Detach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    off(event, cb) {
+        this.events.removeListener(event, cb);
+    }
+    /**
+     * Send message via socket
+     *
+     * @param {string} event - message name
+     * @param {Array<any>} args - arguments
+     * @param {Array<any>} args.0 - message data
+     * @returns {void}
+     */
+    send(event, ...args) {
+        const noUsed = event || args;
+        this.ready = !!noUsed || true;
+    }
+    /**
+     * Specific message handler
+     *
+     * @param {string} type - message type
+     * @param {string} subType - message subtype (query ID)
+     * @param {Function} callback - handler function
+     * @returns {Function} - unsubscribe function
+     */
+    onMessage(type, subType, callback) {
+        this.onMessageCallback = callback;
+        const handler = () => { };
+        this.on('message', handler);
+        return () => {
+            this.off('message', handler);
+        };
+    }
+    /**
+     * Emulate receiving message from socket
+     *
+     * @param {string} event - message type
+     * @param {any} data - message data
+     * @returns {Promise} - waiting promise
+     */
+    trigger(event, data) {
+        return new Promise((resolve) => {
+            setTimeout(() => {
+                if (this.onMessageCallback) {
+                    this.onMessageCallback(event, data);
+                }
+                resolve();
+            }, 10);
+        });
+    }
+}
+exports.TestSocket = TestSocket;
+exports.default = TestSocket;

package/dist/cjs/data-load/sockets/helpers.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Prepare data for CSRF response
+ */
+export declare function getCsrfResponseData(): {};

package/dist/cjs/data-load/sockets/helpers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCsrfResponseData = void 0;
+/**
+ * Get XSRF token from `document.cookie`
+ */
+function getCsrfToken(cookie = document.cookie) {
+    const csrfCookieName = 'XSRF-TOKEN';
+    const match = cookie.match(new RegExp(`(^| )${csrfCookieName}=([^;]+)`));
+    if (match !== null && match[2]) {
+        return match[2];
+    }
+    return null;
+}
+/**
+ * Prepare data for CSRF response
+ */
+function getCsrfResponseData() {
+    const csrfToken = getCsrfToken();
+    const data = {};
+    // The CSRF token is optional, but the domain needs to be added to the whitelist to pass the check without a token
+    if (csrfToken) {
+        data['X-XSRF-TOKEN'] = csrfToken;
+    }
+    return data;
+}
+exports.getCsrfResponseData = getCsrfResponseData;

package/dist/cjs/data-load/sockets/index.d.ts

@@ -0,0 +1,2 @@
+export { SisenseSocket } from './SisenseSocket.js';
+export { TestSocket } from './TestSocket.js';

package/dist/cjs/data-load/sockets/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestSocket = exports.SisenseSocket = void 0;
+/* eslint-disable import/prefer-default-export */
+var SisenseSocket_js_1 = require("./SisenseSocket.js");
+Object.defineProperty(exports, "SisenseSocket", { enumerable: true, get: function () { return SisenseSocket_js_1.SisenseSocket; } });
+var TestSocket_js_1 = require("./TestSocket.js");
+Object.defineProperty(exports, "TestSocket", { enumerable: true, get: function () { return TestSocket_js_1.TestSocket; } });

package/dist/cjs/data-load/types.d.ts

@@ -0,0 +1,90 @@
+import { type BaseJaql } from '@sisense/sdk-data';
+export declare type MeasurePath = {
+    [key: string]: string;
+};
+export declare type SortDetails = {
+    field?: number;
+    initialized?: boolean;
+    sortingLastDimension?: boolean;
+    measurePath?: MeasurePath | null;
+    dir: string | null;
+    isLastApplied?: boolean;
+};
+export declare type Jaql = Omit<BaseJaql, 'sort'> & {
+    sortDetails?: SortDetails;
+    type?: string;
+    sort?: BaseJaql['sort'] | null;
+};
+export declare type JaqlPanel = {
+    jaql: Jaql;
+    panel: string;
+    field?: {
+        id?: string;
+        index?: number;
+    };
+    disabled?: boolean;
+    hierarchies?: Array<string>;
+    format?: {
+        subtotal?: boolean;
+        width?: number;
+        databars?: boolean;
+        color?: {
+            type: string;
+            color?: string;
+            conditions?: Array<{
+                color: string;
+                operator: string;
+                expression: string | Record<string, any>;
+            }>;
+        };
+    };
+};
+export declare type JaqlDatasource = {
+    id: string;
+    title: string;
+    address: string;
+    database: string;
+    fullname: string;
+    lastBuildTime: string;
+};
+export declare type JaqlRequest = {
+    datasource?: JaqlDatasource;
+    metadata: Array<JaqlPanel>;
+    queryGuid?: string;
+    grandTotals?: null | {
+        title: string;
+        columns?: boolean;
+        rows?: boolean;
+    };
+};
+export interface DataLoadServiceI {
+    clone(): DataLoadServiceI;
+    load(jaql: JaqlRequest): Promise<any>;
+    getJaql(): JaqlRequest | undefined;
+    isSingleRowTree(): boolean;
+    getTotalItemsCount(): number;
+    clear(): void;
+    on(eventName: string, callback: (payload: any) => void): void;
+    off(eventName: string, callback: (payload: any) => void): void;
+    offAll(eventName: string): void;
+    listenerCount(eventName: string): number;
+    emit(eventName: string, ...rest: Array<any>): void;
+    isFormattingChanges(jaql?: JaqlRequest, isLimited?: boolean): boolean;
+    hasData(): boolean;
+    hasError(): boolean;
+    destroy(): void;
+    cancelQuery(): Promise<void>;
+}
+export interface SocketI {
+    isReady(): boolean;
+    on(event: string, cb: Function): void;
+    off(event: string, cb: Function): void;
+    onMessage(type: string | undefined, subType: string | undefined, callback: (type: string, data: any) => void): () => void;
+    send(event: string, ...args: any[]): void;
+    trigger(event: string, data: any): any;
+}
+export interface SocketQueryOptions {
+    token?: string;
+    authorization?: string;
+    initialiser?: string;
+}

package/dist/cjs/data-load/types.js

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

package/dist/cjs/errors/LoadingCanceledError.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Using for canceling query promises
+ */
+export declare class LoadingCanceledError extends Error {
+    constructor(message?: string | undefined);
+}
+export default LoadingCanceledError;

package/dist/cjs/errors/LoadingCanceledError.js

@@ -0,0 +1,24 @@
+"use strict";
+/* eslint-disable import/prefer-default-export, no-proto */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadingCanceledError = void 0;
+/**
+ * Using for canceling query promises
+ */
+class LoadingCanceledError extends Error {
+    constructor(message = 'Loading canceled') {
+        super(message);
+        this.name = 'LoadingCanceledError';
+        // restore prototype chain
+        const actualProto = new.target.prototype;
+        if (Object.setPrototypeOf) {
+            Object.setPrototypeOf(this, actualProto);
+        }
+        else {
+            // TODO review this
+            // this.__proto__ = actualProto;
+        }
+    }
+}
+exports.LoadingCanceledError = LoadingCanceledError;
+exports.default = LoadingCanceledError;

package/dist/cjs/errors/index.d.ts

@@ -0,0 +1 @@
+export { LoadingCanceledError } from './LoadingCanceledError.js';

package/dist/cjs/errors/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadingCanceledError = void 0;
+/* eslint-disable import/prefer-default-export */
+var LoadingCanceledError_js_1 = require("./LoadingCanceledError.js");
+Object.defineProperty(exports, "LoadingCanceledError", { enumerable: true, get: function () { return LoadingCanceledError_js_1.LoadingCanceledError; } });

package/dist/cjs/index.d.ts

@@ -0,0 +1,17 @@
+export { type TreeServiceI } from './tree-structure/types.js';
+export { type TreeNode, type ColumnsCount, type TreeNodeMetadata } from './tree-structure/types.js';
+export { type SocketI, type JaqlRequest, type JaqlPanel, type Jaql, type SortDetails, } from './data-load/types.js';
+export { EVENT_DATA_CELL_FORMAT, EVENT_HEADER_CELL_FORMAT, EVENT_DATA_CHUNK_LOADED, EVENT_GRAND_CHUNK_LOADED, EVENT_PROGRESS_ERROR, EVENT_TOTAL_COLUMNS_COUNT, EVENT_TOTAL_ROWS_COUNT, DataService, } from './data-handling/DataService.js';
+export { UserType, PanelType, SortingDirection, JaqlDataType } from './data-handling/constants.js';
+export type { ListOfSortingDirections, ListOfJaqlDataTypes } from './data-handling/constants.js';
+export { PivotQueryClient } from './pivot-query-client.js';
+export { SocketBuilder } from './builders/socket-builder.js';
+export { SisenseDataLoadService } from './data-load/SisenseDataLoadService.js';
+export type { AllDataInfo, DataServiceI, InitPageData, PivotTreeNode, PivotDataNode, } from './data-handling/types.js';
+export { createPivotTreeNode, jaqlProcessor } from './data-handling/utils/index.js';
+export { LoadingCanceledError } from './errors/index.js';
+export { treeNode } from './tree-structure/utils/index.js';
+export { Position } from './tree-structure/constants.js';
+export type { Metadata } from './data-handling/utils/plugins/types.js';
+export type { SortingSettingsItem } from './data-handling/utils/jaqlProcessor.js';
+export type { InputStyles } from './utils/types.js';

package/dist/cjs/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Position = exports.treeNode = exports.LoadingCanceledError = exports.jaqlProcessor = exports.createPivotTreeNode = exports.SisenseDataLoadService = exports.SocketBuilder = exports.PivotQueryClient = exports.JaqlDataType = exports.SortingDirection = exports.PanelType = exports.UserType = exports.DataService = exports.EVENT_TOTAL_ROWS_COUNT = exports.EVENT_TOTAL_COLUMNS_COUNT = exports.EVENT_PROGRESS_ERROR = exports.EVENT_GRAND_CHUNK_LOADED = exports.EVENT_DATA_CHUNK_LOADED = exports.EVENT_HEADER_CELL_FORMAT = exports.EVENT_DATA_CELL_FORMAT = void 0;
+var DataService_js_1 = require("./data-handling/DataService.js");
+Object.defineProperty(exports, "EVENT_DATA_CELL_FORMAT", { enumerable: true, get: function () { return DataService_js_1.EVENT_DATA_CELL_FORMAT; } });
+Object.defineProperty(exports, "EVENT_HEADER_CELL_FORMAT", { enumerable: true, get: function () { return DataService_js_1.EVENT_HEADER_CELL_FORMAT; } });
+Object.defineProperty(exports, "EVENT_DATA_CHUNK_LOADED", { enumerable: true, get: function () { return DataService_js_1.EVENT_DATA_CHUNK_LOADED; } });
+Object.defineProperty(exports, "EVENT_GRAND_CHUNK_LOADED", { enumerable: true, get: function () { return DataService_js_1.EVENT_GRAND_CHUNK_LOADED; } });
+Object.defineProperty(exports, "EVENT_PROGRESS_ERROR", { enumerable: true, get: function () { return DataService_js_1.EVENT_PROGRESS_ERROR; } });
+Object.defineProperty(exports, "EVENT_TOTAL_COLUMNS_COUNT", { enumerable: true, get: function () { return DataService_js_1.EVENT_TOTAL_COLUMNS_COUNT; } });
+Object.defineProperty(exports, "EVENT_TOTAL_ROWS_COUNT", { enumerable: true, get: function () { return DataService_js_1.EVENT_TOTAL_ROWS_COUNT; } });
+Object.defineProperty(exports, "DataService", { enumerable: true, get: function () { return DataService_js_1.DataService; } });
+var constants_js_1 = require("./data-handling/constants.js");
+Object.defineProperty(exports, "UserType", { enumerable: true, get: function () { return constants_js_1.UserType; } });
+Object.defineProperty(exports, "PanelType", { enumerable: true, get: function () { return constants_js_1.PanelType; } });
+Object.defineProperty(exports, "SortingDirection", { enumerable: true, get: function () { return constants_js_1.SortingDirection; } });
+Object.defineProperty(exports, "JaqlDataType", { enumerable: true, get: function () { return constants_js_1.JaqlDataType; } });
+var pivot_query_client_js_1 = require("./pivot-query-client.js");
+Object.defineProperty(exports, "PivotQueryClient", { enumerable: true, get: function () { return pivot_query_client_js_1.PivotQueryClient; } });
+var socket_builder_js_1 = require("./builders/socket-builder.js");
+Object.defineProperty(exports, "SocketBuilder", { enumerable: true, get: function () { return socket_builder_js_1.SocketBuilder; } });
+var SisenseDataLoadService_js_1 = require("./data-load/SisenseDataLoadService.js");
+Object.defineProperty(exports, "SisenseDataLoadService", { enumerable: true, get: function () { return SisenseDataLoadService_js_1.SisenseDataLoadService; } });
+var index_js_1 = require("./data-handling/utils/index.js");
+Object.defineProperty(exports, "createPivotTreeNode", { enumerable: true, get: function () { return index_js_1.createPivotTreeNode; } });
+Object.defineProperty(exports, "jaqlProcessor", { enumerable: true, get: function () { return index_js_1.jaqlProcessor; } });
+var index_js_2 = require("./errors/index.js");
+Object.defineProperty(exports, "LoadingCanceledError", { enumerable: true, get: function () { return index_js_2.LoadingCanceledError; } });
+var index_js_3 = require("./tree-structure/utils/index.js");
+Object.defineProperty(exports, "treeNode", { enumerable: true, get: function () { return index_js_3.treeNode; } });
+var constants_js_2 = require("./tree-structure/constants.js");
+Object.defineProperty(exports, "Position", { enumerable: true, get: function () { return constants_js_2.Position; } });

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/pivot-query-client.d.ts

@@ -0,0 +1,13 @@
+import { PivotQueryResultData } from '@sisense/sdk-data';
+import { Authenticator } from '@sisense/sdk-rest-client';
+import { SocketBuilder } from './builders/index.js';
+import { JaqlRequest } from './data-load/types.js';
+export declare class PivotQueryClient {
+    /**
+     * Builder to create on demand a web socket to the Sisense instance
+     * Required by the pivot table service
+     */
+    socketBuilder: SocketBuilder;
+    constructor(url: string, auth: Authenticator, mockSocket?: boolean);
+    queryData(jaql: JaqlRequest, isPaginated: boolean, elementsPerPage: number, useCache: boolean): Promise<PivotQueryResultData>;
+}

package/dist/cjs/pivot-query-client.js

@@ -0,0 +1,26 @@
+"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.PivotQueryClient = void 0;
+const sdk_common_1 = require("@sisense/sdk-common");
+const index_js_1 = require("./builders/index.js");
+class PivotQueryClient {
+    constructor(url, auth, mockSocket = false) {
+        this.socketBuilder = new index_js_1.SocketBuilder((0, sdk_common_1.normalizeUrl)(url), auth, mockSocket);
+    }
+    queryData(jaql, isPaginated, elementsPerPage, useCache) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const pivotDataBuilder = new index_js_1.PivotDataBuilder(this.socketBuilder.socket);
+            return pivotDataBuilder.loadInitData(jaql, isPaginated, elementsPerPage, useCache);
+        });
+    }
+}
+exports.PivotQueryClient = PivotQueryClient;