@sisense/sdk-pivot-query-client 2.17.0

package/dist/data-load/AbstractDataLoadService.js

@@ -0,0 +1,466 @@
+/* eslint-disable @typescript-eslint/ban-types */
+import EventEmitter from 'events';
+import { PanelType } from '../data-handling/constants.js';
+import { cloneObject } from '../utils/index.js';
+import { MESSAGES_ORDER, MessageType } from './constants.js';
+const formattingProps = {
+    INCLUDE: [
+        'metadata.$.jaql',
+        'metadata.$.field',
+        'metadata.$.panel',
+        'metadata.$.hierarchies',
+        'metadata.$.format',
+        'metadata.$.disabled',
+        'metadata.$.distinctTotals',
+    ],
+    EXCLUDE: [
+        'metadata.$.jaql.title',
+        'metadata.$.format.mask',
+        'metadata.$.format.width',
+        'queryGuid',
+        'widget',
+        'dashboard',
+        'grandTotals.title',
+    ],
+};
+/**
+ * Initiate single socket connection and creates new PivotDataSource for each JAQL request
+ */
+export class AbstractDataLoadService {
+    constructor(events) {
+        /**
+         * @private
+         *
+         * jaql request object
+         */
+        this.jaql = undefined;
+        /**
+         * @private
+         *
+         * cache object
+         */
+        this.data = undefined;
+        /**
+         * @private
+         *
+         * state for "load" method
+         */
+        this.isLoadInProgress = false;
+        /**
+          @private */
+        this.loadPromiseResolve = undefined;
+        /**
+         *
+         * @private
+         */
+        this.loadPromiseReject = undefined;
+        /**
+         * @private
+         *
+         * info about amount of data which already loaded from cache
+         */
+        this.loadFromCacheState = undefined;
+        /**
+          @private */
+        this.loadFromCacheInitialTimer = undefined;
+        /**
+          @private */
+        this.loadFromCacheTimer = undefined;
+        /**
+         * @private
+         *
+         * defines initial pivot data structure
+         */
+        this.isSingleBranchTree = false;
+        /**
+         * @private
+         *
+         * items count loaded on client side
+         */
+        this.loadedItemsCount = 0;
+        /**
+         * @private
+         *
+         * total items count on back-end side
+         */
+        this.totalItemsCount = 0;
+        /**
+         * @private
+         *
+         * defines if amount of data was limited on back-end or not
+         */
+        this.isLimited = false;
+        /**
+         * @private
+         *
+         * detects if finish event was received
+         */
+        this.isFinishEventReceived = false;
+        this.events = events || new EventEmitter();
+    }
+    /**
+     * Destroys data load service
+     *
+     * @returns {void}
+     */
+    destroy() {
+        this.data = undefined;
+        this.events.removeAllListeners();
+    }
+    /**
+     * Return copy of load service
+     *
+     * @returns {DataLoadService} - cloned instance
+     */
+    clone() {
+        throw new Error(`"AbstractDataLoadService.clone" should be overridden in subclass`);
+    }
+    /**
+     * Start data loading according to JAQL request
+     *
+     * @param {JaqlRequest} jaql - JAQL request
+     * @returns {Promise<any>} - whole data loading promise
+     */
+    load(jaql) {
+        if (!jaql) {
+            throw new Error(`AbstractDataLoadService "jaql" is not defined for "load" method`);
+        }
+        const shouldLoadFromCache = !!this.data;
+        const prevJaql = this.jaql;
+        this.jaql = jaql;
+        if (shouldLoadFromCache && prevJaql) {
+            // do not overwrite jaql queryGuid if data will be loaded from cache
+            // needed for sending cancel-query request with proper jaql queryGuid
+            this.jaql.queryGuid = prevJaql.queryGuid;
+        }
+        this.isLoadInProgress = true;
+        const loadPromise = new Promise((resolve, reject) => {
+            this.loadPromiseResolve = resolve;
+            this.loadPromiseReject = reject;
+        });
+        if (this.loadFromCacheInitialTimer) {
+            clearTimeout(this.loadFromCacheInitialTimer);
+        }
+        try {
+            if (shouldLoadFromCache) {
+                this.loadFromCache();
+            }
+            else {
+                this.loadFromServer();
+            }
+        }
+        catch (err) {
+            this.notifyAboutDataError(err);
+        }
+        return loadPromise;
+    }
+    /**
+     * Clear data cache
+     *
+     * @returns {void}
+     */
+    clear() {
+        this.data = undefined;
+    }
+    /**
+     * Returns current jaql request object
+     *
+     * @returns {JaqlRequest} - jaql request object
+     */
+    getJaql() {
+        return this.jaql;
+    }
+    /**
+     * Defines data structure
+     *
+     * @returns {boolean} - true - single branch tree
+     */
+    isSingleRowTree() {
+        return this.isSingleBranchTree;
+    }
+    /**
+     * Returns total amount items count handled on back-end side
+     *
+     * @returns {number} - items count
+     */
+    getTotalItemsCount() {
+        return this.totalItemsCount;
+    }
+    /**
+     * Defines if new jaql has only formatting changes or it requires new data loading from server
+     *
+     * @param {JaqlRequest} jaql - jaql request object
+     * @returns {boolean} - true - only formatting changes, can use cached data
+     */
+    isFormattingChanges(jaql) {
+        const currentFormatInfo = cloneObject(this.jaql, {
+            include: formattingProps.INCLUDE,
+            exclude: formattingProps.EXCLUDE,
+            excludeEmpty: true,
+        });
+        const newFormatInfo = cloneObject(jaql, {
+            include: formattingProps.INCLUDE,
+            exclude: formattingProps.EXCLUDE,
+            excludeEmpty: true,
+        });
+        [...((currentFormatInfo === null || currentFormatInfo === void 0 ? void 0 : currentFormatInfo.metadata) || []), ...((newFormatInfo === null || newFormatInfo === void 0 ? void 0 : newFormatInfo.metadata) || [])].forEach((panelItem) => {
+            if (panelItem && panelItem.panel === PanelType.SCOPE) {
+                delete panelItem.field;
+            }
+        });
+        return JSON.stringify(currentFormatInfo) === JSON.stringify(newFormatInfo);
+    }
+    /**
+     * Defines if service have some data
+     *
+     * @returns {boolean} - true - has some data
+     */
+    hasData() {
+        return !!(this.data && this.data[MessageType.DATA]);
+    }
+    /**
+     * Defines if service have some error
+     *
+     * @returns {boolean} - true - has some error
+     */
+    hasError() {
+        if (this.data) {
+            return !!this.data[MessageType.ERROR];
+        }
+        return false;
+    }
+    /**
+     * Start data loading from the server
+     *
+     * @returns {void}
+     * @private
+     */
+    loadFromServer() {
+        throw new Error(`"AbstractDataLoadService.loadFromServer" should be overridden in subclass`);
+    }
+    /**
+     * Method for canceling the processing of query already sent
+     *
+     * @returns {Promise<void>} - waiting promise
+     */
+    cancelQuery() {
+        const error = new Error(`"AbstractDataLoadService.cancelQuery" should be overridden in subclass.`);
+        return Promise.reject(error);
+    }
+    /**
+     * Method for detection if cancel query is still needed
+     *
+     * @returns {boolean} - is cancel query needed
+     */
+    isCancelQueryNeeded() {
+        return !this.isFinishEventReceived;
+    }
+    /**
+     * Start data loading from the cache
+     *
+     * @returns {Promise<void>} - waiting promise
+     * @private
+     */
+    loadFromCache() {
+        return Promise.resolve()
+            .then(() => {
+            if (this.loadFromCacheInitialTimer) {
+                clearTimeout(this.loadFromCacheInitialTimer);
+            }
+            return new Promise((resolve) => {
+                this.loadFromCacheInitialTimer = setTimeout(resolve);
+                // eslint-disable-next-line max-lines
+            });
+        })
+            .then(() => new Promise((resolve) => {
+            if (this.loadFromCacheTimer) {
+                clearImmediate(this.loadFromCacheTimer);
+            }
+            this.loadFromCacheState = undefined;
+            this.loadMessageFromCache(() => {
+                this.loadFromCacheState = undefined;
+                if (this.loadFromCacheTimer) {
+                    clearImmediate(this.loadFromCacheTimer);
+                }
+                resolve();
+            });
+        }));
+    }
+    /**
+     * Starts loading data from cache queue
+     *
+     * @param {Function} onFinish - on finish callback
+     * @returns {void}
+     * @private
+     */
+    loadMessageFromCache(onFinish) {
+        // Note: removed `setImmediate` as not supported
+        this.loadFromCacheState = this.loadFromCacheState || {};
+        const state = this.loadFromCacheState;
+        let typeToSend = '';
+        let indexToSend = 0;
+        MESSAGES_ORDER.forEach((type) => {
+            if (typeToSend) {
+                return;
+            }
+            state[type] = state[type] || 0;
+            const loadedCount = state[type];
+            if (loadedCount < ((this.data || {})[type] || []).length) {
+                typeToSend = type;
+                indexToSend = state[type];
+            }
+        });
+        if (typeToSend) {
+            const payload = ((this.data || {})[typeToSend] || [])[indexToSend];
+            this.notifyAboutDataChunk(typeToSend || '', payload, true);
+            state[typeToSend] = indexToSend + 1;
+            this.loadMessageFromCache(onFinish);
+        }
+        else if (onFinish) {
+            onFinish();
+        }
+    }
+    /**
+     * Cache appropriate message
+     *
+     * @param {string} type - message type
+     * @param {any} data - message payload
+     * @returns {void}
+     * @private
+     */
+    cacheData(type, data) {
+        this.data = this.data || {};
+        const cache = this.data;
+        if (!cache) {
+            return;
+        }
+        cache[type] = cache[type] || [];
+        cache[type].push(data || true);
+    }
+    /*
+     *
+     * @private
+     */
+    /**
+     * Notify outside about data chunk with saving to inner cache, applying chunk formatting with
+     * saving initial messages queue
+     *
+     * @param {string} type - data chunk type
+     * @param {any} chunk - data chunk data
+     * @param {boolean} isFromCache - mark data which already was cached
+     * @returns {void}
+     * @private
+     */
+    // eslint-disable-next-line sonarjs/cognitive-complexity
+    notifyAboutDataChunk(type, chunk, isFromCache = false) {
+        // console.log('notifyAboutDataChunk', type, chunk, isFromCache);
+        const data = chunk && chunk.data && type === MessageType.DATA ? chunk.data : chunk;
+        if (!isFromCache) {
+            this.cacheData(type, chunk);
+        }
+        if (!isFromCache && this.loadFromCacheState) {
+            // if load original data but new loading from cache started
+            return;
+        }
+        if (type === MessageType.METADATA) {
+            this.isSingleBranchTree = !!(data && data.isSingleBranchTree);
+        }
+        if (type === MessageType.ERROR) {
+            this.notifyAboutDataError(data);
+        }
+        if (type === MessageType.DATA_FINISH) {
+            this.loadedItemsCount = data ? data.rowsCount : 0;
+            this.notifyAboutDataLoaded(this.data);
+        }
+        if (type === MessageType.TOTAL_ROWS) {
+            this.totalItemsCount = data ? data.rowsCount : 0;
+            if (this.totalItemsCount !== this.loadedItemsCount) {
+                this.isLimited = true;
+            }
+        }
+        if (type === MessageType.FINISH) {
+            this.isFinishEventReceived = true;
+        }
+        const clonedData = cloneObject(data);
+        this.events.emit(type, clonedData);
+    }
+    /**
+     * Resolve "load" method with appropriate data information
+     *
+     * @param {any} data - data to resolve with
+     * @returns {void}
+     * @private
+     */
+    notifyAboutDataLoaded(data) {
+        if (!this.isLoadInProgress) {
+            return;
+        }
+        this.isLoadInProgress = false;
+        if (typeof this.loadPromiseResolve === 'function') {
+            this.loadPromiseResolve(data);
+        }
+        this.loadPromiseReject = undefined;
+        this.loadPromiseResolve = undefined;
+    }
+    /**
+     * Reject "load" method with appropriate data information
+     *
+     * @param {any} data - data to reject with
+     * @returns {void}
+     * @private
+     */
+    notifyAboutDataError(data) {
+        if (!this.isLoadInProgress) {
+            return;
+        }
+        this.isLoadInProgress = false;
+        if (typeof this.loadPromiseReject === 'function') {
+            this.loadPromiseReject(data);
+        }
+        this.loadPromiseReject = undefined;
+        this.loadPromiseResolve = undefined;
+    }
+    /**
+     * Subscribe to event notification
+     *
+     * @param {string} eventName - event name to subscribe
+     * @param {Function} callback - event handler
+     * @returns {void}
+     */
+    on(eventName, callback) {
+        this.events.on(eventName, callback);
+    }
+    /**
+     * Unsubscribe from event notification
+     *
+     * @param {string} eventName - event name to unsubscribe
+     * @param {Function} callback - event handler
+     * @returns {void}
+     */
+    off(eventName, callback) {
+        this.events.removeListener(eventName, callback);
+    }
+    /**
+     * Unsubscribe from all event notifications
+     *
+     * @param {string} eventName - event name to unsubscribe
+     * @returns {void}
+     */
+    offAll(eventName) {
+        this.events.removeAllListeners(eventName);
+    }
+    listenerCount(eventName) {
+        return this.events.listenerCount(eventName);
+    }
+    /**
+     * Trigger event notification
+     *
+     * @param {string} eventName - event name to subscribe
+     * @param {Array<any>} rest - arguments will be passed to event handler
+     * @returns {void}
+     */
+    emit(eventName, ...rest) {
+        this.events.emit(eventName, ...rest);
+    }
+}
+export default AbstractDataLoadService;

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

@@ -0,0 +1,63 @@
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { AbstractDataLoadService } from './AbstractDataLoadService.js';
+import { DataLoadServiceI, SocketI } from './types.js';
+export declare class DataLoadService extends AbstractDataLoadService implements DataLoadServiceI {
+    /**
+     * @private
+     *
+     * Active WebSocket connection instance
+     */
+    socket: SocketI;
+    /**
+     * @private
+     *
+     * WebSocket initialization delay promise
+     */
+    initPromise?: Promise<void>;
+    /**
+     *
+     * @private
+     *
+     * WebSocket initialization ready flag
+     */
+    isInitInProgress: boolean;
+    /**
+     *
+     * @private
+     *
+     * onMessage remove listeners callback
+     */
+    onMessageCancel?: Function;
+    constructor(socket?: SocketI, events?: EventEmitter);
+    destroy(): void;
+    /**
+     * Return copy of load service
+     *
+     * @returns {DataLoadService} - cloned instance
+     */
+    clone(): DataLoadServiceI;
+    /**
+     * Start data loading from the server
+     *
+     * @returns {void}
+     * @private
+     */
+    loadFromServer(): void;
+    /**
+     * Method for canceling the processing of query already sent
+     *
+     * @returns {Promise<void>} - waiting promise
+     */
+    cancelQuery(): Promise<void>;
+    /**
+     *  Wait for socket connection
+     *
+     * @returns {Promise<void>} - wait promise
+     * @private
+     */
+    waitForSocketReady(): Promise<void>;
+    onSocketError: (error: Error) => void;
+    onSocketDisconnect: () => void;
+}
+export default DataLoadService;

package/dist/data-load/DataLoadService.js

@@ -0,0 +1,148 @@
+import { cloneObject } from '../utils/index.js';
+import { AbstractDataLoadService } from './AbstractDataLoadService.js';
+import { MessageType } from './constants.js';
+export class DataLoadService extends AbstractDataLoadService {
+    constructor(socket, events) {
+        super(events);
+        /**
+         * @private
+         *
+         * WebSocket initialization delay promise
+         */
+        this.initPromise = undefined;
+        /**
+         *
+         * @private
+         *
+         * WebSocket initialization ready flag
+         */
+        this.isInitInProgress = false;
+        /**
+         *
+         * @private
+         *
+         * onMessage remove listeners callback
+         */
+        this.onMessageCancel = undefined;
+        this.onSocketError = (error) => {
+            this.emit('error', {
+                error: true,
+                type: 500,
+                details: `Socket error: ${error.message}`,
+            });
+        };
+        this.onSocketDisconnect = () => {
+            this.emit('error', {
+                error: true,
+                type: 500,
+                details: 'Socket disconnected',
+            });
+        };
+        if (!socket) {
+            throw new Error(`DataLoadService "socket" not defined.`);
+        }
+        this.socket = socket;
+        this.socket.on('error', this.onSocketError);
+        this.socket.on('disconnect', this.onSocketDisconnect);
+        this.on(MessageType.ERROR, (data) => {
+            const errorMsg = JSON.stringify(data, null, 4);
+            if (process.env.NODE_ENV !== 'production') {
+                // eslint-disable-next-line no-console
+                console.warn(`DataLoadService error message: \n${errorMsg}`);
+            }
+        });
+    }
+    destroy() {
+        super.destroy();
+        if (this.onMessageCancel) {
+            this.onMessageCancel();
+            this.onMessageCancel = undefined;
+        }
+        // removed because of duplication of cancel-query request
+        // this.cancelQuery();
+        this.socket.off('error', this.onSocketError);
+        this.socket.off('disconnect', this.onSocketDisconnect);
+    }
+    /**
+     * Return copy of load service
+     *
+     * @returns {DataLoadService} - cloned instance
+     */
+    clone() {
+        const data = cloneObject(this.data);
+        // restore empty headers object
+        if (!data[MessageType.HEADERS]) {
+            data[MessageType.HEADERS] = [{}];
+        }
+        const instance = new DataLoadService(this.socket);
+        instance.data = data;
+        instance.jaql = this.jaql;
+        instance.isFinishEventReceived = this.isFinishEventReceived;
+        instance.isSingleBranchTree = this.isSingleBranchTree;
+        instance.loadedItemsCount = this.loadedItemsCount;
+        instance.totalItemsCount = this.totalItemsCount;
+        instance.isLimited = this.isLimited;
+        return instance;
+    }
+    /**
+     * Start data loading from the server
+     *
+     * @returns {void}
+     * @private
+     */
+    loadFromServer() {
+        // eslint-disable-next-line promise/catch-or-return
+        this.waitForSocketReady().then(() => {
+            if (this.onMessageCancel) {
+                this.onMessageCancel();
+            }
+            this.onMessageCancel = this.socket.onMessage(undefined, undefined, (type, data) => {
+                this.notifyAboutDataChunk(type, data);
+            });
+            this.socket.send('pivot', this.jaql);
+        });
+    }
+    /**
+     * Method for canceling the processing of query already sent
+     *
+     * @returns {Promise<void>} - waiting promise
+     */
+    cancelQuery() {
+        if (!this.isCancelQueryNeeded()) {
+            return Promise.resolve();
+        }
+        return this.waitForSocketReady().then(() => {
+            this.socket.send('pivot/cancel-query', {
+                // eslint-disable-next-line promise/always-return
+                queryGuid: this.jaql && this.jaql.queryGuid,
+            });
+        });
+    }
+    /**
+     *  Wait for socket connection
+     *
+     * @returns {Promise<void>} - wait promise
+     * @private
+     */
+    waitForSocketReady() {
+        if (this.socket.isReady()) {
+            return Promise.resolve();
+        }
+        if (this.isInitInProgress && this.initPromise) {
+            return this.initPromise;
+        }
+        this.isInitInProgress = true;
+        this.initPromise = new Promise((resolve, reject) => {
+            this.socket.on('open', () => {
+                if (this.socket && this.socket.isReady()) {
+                    resolve();
+                }
+                else {
+                    reject(new Error('Can not open WebSocket connection'));
+                }
+            });
+        });
+        return this.initPromise;
+    }
+}
+export default DataLoadService;