@sisense/sdk-pivot-query-client 2.17.0

package/dist/data-load/SisenseDataLoadService.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { DataLoadService } from './DataLoadService.js';
+import { DataLoadServiceI, SocketI } from './types.js';
+declare type Options = {
+    socketRegisterCheckInterval?: number;
+};
+/**
+ * Initiate single socket connection and creates new PivotDataSource for each JAQL request
+ */
+export declare class SisenseDataLoadService extends DataLoadService implements DataLoadServiceI {
+    /**
+     * @private
+     */
+    options: Options;
+    /**
+     * @private
+     */
+    registrationWaitTimer?: NodeJS.Timeout;
+    /**
+     * @private
+     *
+     * onMessage remove listeners callback
+     */
+    onMessageCancels: Array<Function | undefined>;
+    constructor(socket?: SocketI, events?: EventEmitter, options?: Options);
+    destroy(): void;
+    /**
+     * Start data loading from the server
+     *
+     * @returns {void}
+     * @private
+     */
+    loadFromServer(): void;
+    /**
+     * Wait for socket connection and registration
+     *
+     * @returns {Promise<*>} - wait promise
+     * @private
+     */
+    waitForSocketReady(): Promise<any>;
+}
+export default SisenseDataLoadService;

package/dist/data-load/SisenseDataLoadService.js

@@ -0,0 +1,83 @@
+import { v4 as uuid } from 'uuid';
+import { MessageType } from './constants.js';
+import { DataLoadService } from './DataLoadService.js';
+/**
+ * Initiate single socket connection and creates new PivotDataSource for each JAQL request
+ */
+export class SisenseDataLoadService extends DataLoadService {
+    constructor(socket, events, options = {}) {
+        super(socket, events);
+        /**
+         * @private
+         *
+         * onMessage remove listeners callback
+         */
+        this.onMessageCancels = [];
+        this.options = options;
+    }
+    destroy() {
+        super.destroy();
+        if (this.onMessageCancels.length) {
+            this.onMessageCancels.forEach((onMessageCancel) => {
+                if (onMessageCancel) {
+                    onMessageCancel();
+                }
+            });
+            this.onMessageCancels.length = 0;
+        }
+    }
+    /**
+     * Start data loading from the server
+     *
+     * @returns {void}
+     * @private
+     */
+    loadFromServer() {
+        // eslint-disable-next-line promise/catch-or-return
+        this.waitForSocketReady().then(() => {
+            const queryJaql = Object.assign({ queryGuid: uuid() }, this.jaql);
+            const { queryGuid } = queryJaql;
+            if (this.onMessageCancels.length) {
+                this.onMessageCancels.forEach((onMessageCancel) => {
+                    if (onMessageCancel) {
+                        onMessageCancel();
+                    }
+                });
+                this.onMessageCancels.length = 0;
+            }
+            Object.values(MessageType).forEach((mType) => {
+                // TODO: misnomer??? It should be onMessageHandle
+                const onMessageCancel = this.socket.onMessage(mType, queryGuid, (type, data) => {
+                    this.notifyAboutDataChunk(type, data);
+                });
+                this.onMessageCancels.push(onMessageCancel);
+            });
+            this.socket.send('pivot', queryJaql);
+        });
+    }
+    /**
+     * Wait for socket connection and registration
+     *
+     * @returns {Promise<*>} - wait promise
+     * @private
+     */
+    waitForSocketReady() {
+        if (this.socket.isReady()) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            const { socketRegisterCheckInterval = 100 } = this.options;
+            if (this.registrationWaitTimer) {
+                clearInterval(this.registrationWaitTimer);
+            }
+            const checkSocketReady = () => {
+                if (this.socket.isReady()) {
+                    clearInterval(this.registrationWaitTimer);
+                    resolve();
+                }
+            };
+            this.registrationWaitTimer = setInterval(checkSocketReady, socketRegisterCheckInterval);
+        });
+    }
+}
+export default SisenseDataLoadService;

package/dist/data-load/TestDataLoadService.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { DataLoadServiceI, JaqlRequest } from './types.js';
+export declare class TestDataLoadService implements DataLoadServiceI {
+    events: EventEmitter;
+    data?: JaqlRequest;
+    delegatedLoadService?: DataLoadServiceI;
+    constructor(url: string, events?: EventEmitter);
+    destroy(): void;
+    clone(): DataLoadServiceI;
+    load(jaql: JaqlRequest): Promise<any>;
+    cancelQuery(): Promise<void>;
+    clear(): void;
+    getJaql(): JaqlRequest | undefined;
+    isSingleRowTree(): boolean;
+    getTotalItemsCount(): number;
+    delegate(loadService: DataLoadServiceI): 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): boolean;
+    hasData(): boolean;
+    hasError(): boolean;
+}
+export default TestDataLoadService;

package/dist/data-load/TestDataLoadService.js

@@ -0,0 +1,69 @@
+/* eslint-disable class-methods-use-this */
+import EventEmitter from 'events';
+export class TestDataLoadService {
+    constructor(url, events) {
+        this.delegatedLoadService = undefined;
+        this.events = events || new EventEmitter();
+    }
+    destroy() {
+        this.data = undefined;
+    }
+    clone() {
+        throw new Error(`"TestDataLoadService.clone" should not be called`);
+    }
+    load(jaql) {
+        this.data = jaql;
+        return Promise.resolve(null);
+    }
+    cancelQuery() {
+        return Promise.resolve();
+    }
+    clear() {
+        this.data = undefined;
+    }
+    getJaql() {
+        return this.data;
+    }
+    isSingleRowTree() {
+        return !this.data;
+    }
+    getTotalItemsCount() {
+        return this && 0;
+    }
+    delegate(loadService) {
+        this.delegatedLoadService = loadService;
+    }
+    on(eventName, callback) {
+        this.events.on(eventName, callback);
+    }
+    off(eventName, callback) {
+        this.events.removeListener(eventName, callback);
+    }
+    offAll(eventName) {
+        this.events.removeAllListeners(eventName);
+    }
+    listenerCount(eventName) {
+        return this.events.listenerCount(eventName);
+    }
+    emit(eventName, ...rest) {
+        this.events.emit(eventName, ...rest);
+    }
+    isFormattingChanges(jaql) {
+        return jaql ? true : !!this;
+    }
+    // applyFormattingChanges(jaql?: JaqlRequest): Promise<DataLoadServiceI> {
+    //   const res = jaql ? this : this;
+    //   return Promise.resolve(res);
+    // }
+    //
+    // checkSorting(): Promise<void> {
+    //   return this && Promise.resolve();
+    // }
+    hasData() {
+        return this && true;
+    }
+    hasError() {
+        return this && false;
+    }
+}
+export default TestDataLoadService;

package/dist/data-load/constants.d.ts

@@ -0,0 +1,13 @@
+export declare const MessageType: {
+    HEADERS: string;
+    METADATA: string;
+    DATA: string;
+    GRAND: string;
+    FINISH: string;
+    ERROR: string;
+    TOTAL_ROWS: string;
+    DATA_FINISH: string;
+    DATABARS: string;
+    RANGE_MIN_MAX: string;
+};
+export declare const MESSAGES_ORDER: string[];

package/dist/data-load/constants.js

@@ -0,0 +1,25 @@
+// Message type for each of the data chunks
+export const MessageType = {
+    HEADERS: 'headers',
+    METADATA: 'metadata',
+    DATA: 'data',
+    GRAND: 'grand',
+    FINISH: 'finish',
+    ERROR: 'error',
+    TOTAL_ROWS: 'totalRows',
+    DATA_FINISH: 'dataFinish',
+    DATABARS: 'dataBars',
+    RANGE_MIN_MAX: 'rangeMinMax',
+};
+export const MESSAGES_ORDER = [
+    MessageType.ERROR,
+    MessageType.HEADERS,
+    MessageType.GRAND,
+    MessageType.METADATA,
+    MessageType.DATA,
+    MessageType.DATA_FINISH,
+    MessageType.TOTAL_ROWS,
+    MessageType.DATABARS,
+    MessageType.RANGE_MIN_MAX,
+    MessageType.FINISH,
+];

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

@@ -0,0 +1,6 @@
+export { AbstractDataLoadService } from './AbstractDataLoadService.js';
+export { DataLoadService } from './DataLoadService.js';
+export { SisenseDataLoadService } from './SisenseDataLoadService.js';
+export { TestDataLoadService } from './TestDataLoadService.js';
+export { SisenseSocket } from './sockets/SisenseSocket.js';
+export { type MeasurePath } from './types.js';

package/dist/data-load/index.js

@@ -0,0 +1,6 @@
+/* eslint-disable import/prefer-default-export */
+export { AbstractDataLoadService } from './AbstractDataLoadService.js';
+export { DataLoadService } from './DataLoadService.js';
+export { SisenseDataLoadService } from './SisenseDataLoadService.js';
+export { TestDataLoadService } from './TestDataLoadService.js';
+export { SisenseSocket } from './sockets/SisenseSocket.js';

package/dist/data-load/sockets/SisenseSocket.d.ts

@@ -0,0 +1,81 @@
+import { SocketI, SocketQueryOptions } from '../types.js';
+export declare class SisenseSocket implements SocketI {
+    /**
+      @private */
+    socket: SocketIOClient.Socket;
+    private isRegistered;
+    private isListening;
+    /**
+      @private */
+    onMessageCallback?: (type: string, data: any) => void;
+    /**
+     * Creates a new SisenseSocket instance.
+     *
+     * @param data - Either a URL string or an existing SocketIOClient.Socket instance
+     * @param query - Socket query options for authentication
+     * @param namespace - Optional socket.io namespace to connect to (e.g., 'pivot2')
+     */
+    constructor(data: string | SocketIOClient.Socket, query: SocketQueryOptions, namespace?: string);
+    /**
+     * Subscribes on socket readiness events
+     */
+    subcribeOnSocketReadiness(): void;
+    /**
+     * Checks if socket is ready for sending messages or not
+     *
+     * @returns {boolean} - true - ready
+     */
+    isReady(): boolean;
+    /**
+     * Attach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    on(event: string, cb: Function): void;
+    /**
+     * Detach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    off(event: string, cb: Function): void;
+    /**
+     * 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: string, ...args: any[]): void;
+    /**
+     * 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: string, subType: string, callback: (type: string, data: any) => void): () => void;
+    /**
+     * Emulate receiving message from socket
+     *
+     * @param {string} event - message type
+     * @param {any} data - message data
+     * @returns {void}
+     */
+    trigger(event: string, data: any): any;
+    /**
+     * Creates and configures a new socket.io connection.
+     *
+     * @param url - Base URL of the Sisense instance
+     * @param query - Socket query options for authentication
+     * @param namespace - Optional socket.io namespace to connect to (e.g., 'pivot2')
+     * @returns Configured SocketIOClient.Socket instance
+     */
+    static createNewSocket(url: string, query: SocketQueryOptions, namespace?: string): SocketIOClient.Socket;
+}
+export default SisenseSocket;

package/dist/data-load/sockets/SisenseSocket.js

@@ -0,0 +1,155 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import { normalizeUrl } from '@sisense/sdk-common';
+import io from 'socket.io-client';
+import { getCsrfResponseData } from './helpers.js';
+export class SisenseSocket {
+    /**
+     * Creates a new SisenseSocket instance.
+     *
+     * @param data - Either a URL string or an existing SocketIOClient.Socket instance
+     * @param query - Socket query options for authentication
+     * @param namespace - Optional socket.io namespace to connect to (e.g., 'pivot2')
+     */
+    constructor(data, query, namespace) {
+        this.isRegistered = false;
+        this.isListening = false;
+        if (typeof data === 'string') {
+            this.socket = SisenseSocket.createNewSocket(data, query, namespace);
+            this.subcribeOnSocketReadiness();
+        }
+        else {
+            this.socket = data;
+        }
+    }
+    /**
+     * Subscribes on socket readiness events
+     */
+    subcribeOnSocketReadiness() {
+        this.socket.on('register', () => {
+            this.isRegistered = true;
+        });
+        this.socket.on('listen', () => {
+            this.isListening = true;
+        });
+    }
+    /**
+     * Checks if socket is ready for sending messages or not
+     *
+     * @returns {boolean} - true - ready
+     */
+    isReady() {
+        // return this.socket.registeredInSisense;
+        return this.isRegistered && this.isListening;
+    }
+    /**
+     * Attach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    on(event, cb) {
+        this.socket.on(event, cb);
+    }
+    /**
+     * Detach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    off(event, cb) {
+        this.socket.off(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 data = args[0];
+        this.socket.emit(event, JSON.stringify(data));
+    }
+    /**
+     * 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 eventType = type || '';
+        const eventSubType = subType || '';
+        const eventName = eventSubType ? `${eventType}-${eventSubType}` : eventType;
+        const handler = (event) => {
+            let data = null;
+            try {
+                data = JSON.parse(event);
+            }
+            catch (err) {
+                throw new Error('Error parsing response message');
+            }
+            callback(eventType, data);
+        };
+        this.on(eventName, handler);
+        return () => {
+            this.off(eventName, handler);
+        };
+    }
+    /**
+     * Emulate receiving message from socket
+     *
+     * @param {string} event - message type
+     * @param {any} data - message data
+     * @returns {void}
+     */
+    trigger(event, data) {
+        if (this.onMessageCallback) {
+            this.onMessageCallback(event, data);
+        }
+    }
+    /**
+     * Creates and configures a new socket.io connection.
+     *
+     * @param url - Base URL of the Sisense instance
+     * @param query - Socket query options for authentication
+     * @param namespace - Optional socket.io namespace to connect to (e.g., 'pivot2')
+     * @returns Configured SocketIOClient.Socket instance
+     */
+    static createNewSocket(url, query, namespace) {
+        const gatewayUrl = new URL('./gateway', new URL(normalizeUrl(url)));
+        const uri = gatewayUrl.origin + (namespace ? `/${namespace}` : '');
+        const socket = io.connect(uri, {
+            path: gatewayUrl.pathname,
+            transports: ['websocket'],
+            reconnection: true,
+            query,
+        });
+        socket.on('connect_error', (err) => {
+            console.log(`connect_error due to ${err.message}`);
+        });
+        socket.on('csrf', () => {
+            // If CSRF is enabled, we will receive a CSRF event from the server and should send a CSRF event back to initiate the CSRF check
+            socket.emit('csrf', getCsrfResponseData());
+        });
+        socket.on('listen', () => {
+            // Send the register event only when the server is ready to listen
+            socket.emit('register', {});
+        });
+        socket.on('register', () => {
+            socket.emit('{"eventName": "_registerEvent", "data": "pivot2"}');
+            // socket.registeredInSisense = true;
+        });
+        socket.on('error', (err) => {
+            // eslint-disable-next-line no-console
+            console.warn(`"SisenseSocket" socket error "${err}"`);
+        });
+        return socket;
+    }
+}
+export default SisenseSocket;

package/dist/data-load/sockets/TestSocket.d.ts

@@ -0,0 +1,61 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { SocketI } from '../types.js';
+export declare class TestSocket implements SocketI {
+    /** @private */
+    events: EventEmitter;
+    /** @private */
+    ready: boolean;
+    /** @private */
+    onMessageCallback?: (type: string, data: any) => void;
+    constructor();
+    /**
+     * Checks if socket is ready for sending messages or not
+     *
+     * @returns {boolean} - true - ready
+     */
+    isReady(): boolean;
+    /**
+     * Attach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    on(event: string, cb: (...args: Array<any>) => void): void;
+    /**
+     * Detach event handler
+     *
+     * @param {string} event - event name
+     * @param {Function} cb - handler function
+     * @returns {void}
+     */
+    off(event: string, cb: (...args: Array<any>) => void): void;
+    /**
+     * 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: string, ...args: any[]): void;
+    /**
+     * 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: string, subType: string, callback: (type: string, data: any) => void): () => void;
+    /**
+     * Emulate receiving message from socket
+     *
+     * @param {string} event - message type
+     * @param {any} data - message data
+     * @returns {Promise} - waiting promise
+     */
+    trigger(event: string, data: any): any;
+}
+export default TestSocket;

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

@@ -0,0 +1,83 @@
+import EventEmitter from 'events';
+export class TestSocket {
+    constructor() {
+        /** @private */
+        this.ready = true;
+        this.events = new EventEmitter();
+        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);
+        });
+    }
+}
+export default TestSocket;

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

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

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

@@ -0,0 +1,23 @@
+/**
+ * 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
+ */
+export 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;
+}