@sisense/sdk-pivot-query-client 2.17.0

package/dist/data-handling/utils/plugins/validator.js

@@ -0,0 +1,165 @@
+import { PluginsPanelFields } from '../../constants.js';
+/**
+ * Validate metadata by target type
+ *
+ * @param {DimensionTarget | ValueTarget} target - object of target rules
+ * @param {Array<DimensionMetadata | MeasureMetadata>} metadata - Array of cell metadata
+ * @param {DimensionOptions | MeasureOptions} options - array of fields to compare
+ * @returns {boolean} validation result
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function fieldsComparator(target, metadata, options) {
+    if (!metadata || !metadata.length) {
+        return false;
+    }
+    return metadata.some((metadataItem) => {
+        let fieldsValid = true;
+        if (options && options.fields && options.fields.length) {
+            options.fields.forEach((field) => {
+                if (target[field] !== undefined && metadataItem[field] === undefined) {
+                    fieldsValid = false;
+                }
+                else if (target[field] !== undefined && metadataItem[field] !== undefined) {
+                    if (Array.isArray(target[field])) {
+                        fieldsValid = fieldsValid && target[field].indexOf(metadataItem[field]) !== -1;
+                    }
+                    else {
+                        fieldsValid = fieldsValid && target[field] === metadataItem[field];
+                    }
+                }
+            });
+        }
+        return fieldsValid;
+    });
+}
+/**
+ * Validate metadata by target type
+ *
+ * @param {Array<string>} target - types of cells
+ * @param {Array<string>} metadata - current cell type
+ * @returns {boolean} validation result
+ */
+const isValidType = (target, metadata = []) => {
+    let valid = false;
+    if (!metadata || !metadata.length) {
+        return false;
+    }
+    if (target.length === 0) {
+        return true;
+    }
+    target.forEach((type) => {
+        if (metadata.includes(type)) {
+            valid = true;
+        }
+    });
+    return valid;
+};
+/**
+ * Validate metadata with target
+ *
+ * @param {DimensionTarget} target - target rows
+ * @param {Array<DimensionMetadata>} dimMetadata - array of rows or columns in metadata
+ * @returns {boolean} validation result
+ */
+const isValidDimension = (target, dimMetadata) => {
+    // validate by indexes || dimension & member || title
+    let valid = true;
+    if (!dimMetadata || !dimMetadata.length) {
+        valid = false;
+    }
+    else {
+        target.forEach((dimTarget) => {
+            if (dimTarget.index) {
+                const currentPanel = dimMetadata[dimMetadata.length - 1];
+                valid =
+                    valid &&
+                        fieldsComparator(dimTarget, [currentPanel], { fields: [PluginsPanelFields.INDEX] });
+            }
+            if (dimTarget.dim) {
+                dimTarget.name = dimTarget.dim;
+                if (dimTarget.members) {
+                    dimTarget.member = dimTarget.members;
+                }
+                valid =
+                    valid &&
+                        fieldsComparator(dimTarget, dimMetadata, {
+                            fields: [PluginsPanelFields.NAME, PluginsPanelFields.MEMBER],
+                        });
+            }
+            if (dimTarget.title) {
+                const currentPanel = dimMetadata[dimMetadata.length - 1];
+                valid =
+                    valid &&
+                        fieldsComparator(dimTarget, [currentPanel], { fields: [PluginsPanelFields.TITLE] });
+            }
+        });
+    }
+    return valid;
+};
+/**
+ * Validate metadata with target
+ *
+ * @param {ValueTarget} target - target rows
+ * @param {MeasureMetadata} measureMetadata - array of rows or columns in metadata
+ * @returns {boolean} validation result
+ */
+const isValidMeasure = (target, measureMetadata) => {
+    // validate by indexes || dimension & member || title
+    let valid = true;
+    if (!measureMetadata || !measureMetadata.length) {
+        valid = false;
+    }
+    else {
+        target.forEach((measureTarget) => {
+            if (measureTarget.index) {
+                valid =
+                    valid &&
+                        fieldsComparator(measureTarget, measureMetadata, { fields: [PluginsPanelFields.INDEX] });
+            }
+            if (measureTarget.dim) {
+                measureTarget.name = measureTarget.dim;
+                valid =
+                    valid &&
+                        fieldsComparator(measureTarget, measureMetadata, {
+                            fields: [PluginsPanelFields.DIM, PluginsPanelFields.AGG],
+                        });
+            }
+            if (measureTarget.title) {
+                valid =
+                    valid &&
+                        fieldsComparator(measureTarget, measureMetadata, { fields: [PluginsPanelFields.TITLE] });
+            }
+        });
+    }
+    return valid;
+};
+/**
+ * Collect and return rows or columns group metadata
+ *
+ * @param {Target} target - target rows
+ * @param {Metadata} metadata - array of rows in metadata
+ * @returns {boolean} validation result
+ */
+// eslint-disable-next-line sonarjs/cognitive-complexity
+export const validate = (target, metadata) => {
+    let valid = true;
+    if (target.type && valid) {
+        valid = valid && isValidType(target.type, metadata.type);
+    }
+    if (target.rows && target.rows.length && valid) {
+        const rows = metadata.rows ? metadata.rows : [];
+        valid = valid && isValidDimension(target.rows, rows);
+    }
+    if (target.columns && valid) {
+        const columns = metadata.columns ? metadata.columns : [];
+        valid = valid && isValidDimension(target.columns, columns);
+    }
+    if (target.values && valid) {
+        const measure = metadata.measure ? [metadata.measure] : [];
+        valid = valid && isValidMeasure(target.values, measure);
+    }
+    return valid;
+};
+export default {
+    validate,
+};

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

@@ -0,0 +1,256 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import EventEmitter from 'events';
+import { DataLoadServiceI, JaqlRequest } from './types.js';
+declare type DataCache = {
+    [key: string]: any;
+};
+declare type LoadState = {
+    [key: string]: number;
+};
+/**
+ * Initiate single socket connection and creates new PivotDataSource for each JAQL request
+ */
+export declare class AbstractDataLoadService implements DataLoadServiceI {
+    /**
+     *
+     * @private
+     *
+     * EventEmitter instance
+     */
+    events: EventEmitter;
+    /**
+     * @private
+     *
+     * jaql request object
+     */
+    jaql?: JaqlRequest;
+    /**
+     * @private
+     *
+     * cache object
+     */
+    data?: DataCache;
+    /**
+     * @private
+     *
+     * state for "load" method
+     */
+    isLoadInProgress: boolean;
+    /**
+      @private */
+    loadPromiseResolve?: Function;
+    /**
+     *
+     * @private
+     */
+    loadPromiseReject?: Function;
+    /**
+     * @private
+     *
+     * info about amount of data which already loaded from cache
+     */
+    loadFromCacheState?: LoadState;
+    /**
+      @private */
+    loadFromCacheInitialTimer?: NodeJS.Timeout;
+    /**
+      @private */
+    loadFromCacheTimer?: NodeJS.Immediate;
+    /**
+     * @private
+     *
+     * defines initial pivot data structure
+     */
+    isSingleBranchTree: boolean;
+    /**
+     * @private
+     *
+     * items count loaded on client side
+     */
+    loadedItemsCount: number;
+    /**
+     * @private
+     *
+     * total items count on back-end side
+     */
+    totalItemsCount: number;
+    /**
+     * @private
+     *
+     * defines if amount of data was limited on back-end or not
+     */
+    isLimited: boolean;
+    /**
+     * @private
+     *
+     * detects if finish event was received
+     */
+    isFinishEventReceived: boolean;
+    constructor(events?: EventEmitter);
+    /**
+     * Destroys data load service
+     *
+     * @returns {void}
+     */
+    destroy(): void;
+    /**
+     * Return copy of load service
+     *
+     * @returns {DataLoadService} - cloned instance
+     */
+    clone(): DataLoadServiceI;
+    /**
+     * Start data loading according to JAQL request
+     *
+     * @param {JaqlRequest} jaql - JAQL request
+     * @returns {Promise<any>} - whole data loading promise
+     */
+    load(jaql: JaqlRequest): Promise<any>;
+    /**
+     * Clear data cache
+     *
+     * @returns {void}
+     */
+    clear(): void;
+    /**
+     * Returns current jaql request object
+     *
+     * @returns {JaqlRequest} - jaql request object
+     */
+    getJaql(): JaqlRequest | undefined;
+    /**
+     * Defines data structure
+     *
+     * @returns {boolean} - true - single branch tree
+     */
+    isSingleRowTree(): boolean;
+    /**
+     * Returns total amount items count handled on back-end side
+     *
+     * @returns {number} - items count
+     */
+    getTotalItemsCount(): number;
+    /**
+     * 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?: JaqlRequest): boolean;
+    /**
+     * Defines if service have some data
+     *
+     * @returns {boolean} - true - has some data
+     */
+    hasData(): boolean;
+    /**
+     * Defines if service have some error
+     *
+     * @returns {boolean} - true - has some error
+     */
+    hasError(): boolean;
+    /**
+     * 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>;
+    /**
+     * Method for detection if cancel query is still needed
+     *
+     * @returns {boolean} - is cancel query needed
+     */
+    isCancelQueryNeeded(): boolean;
+    /**
+     * Start data loading from the cache
+     *
+     * @returns {Promise<void>} - waiting promise
+     * @private
+     */
+    loadFromCache(): Promise<void>;
+    /**
+     * Starts loading data from cache queue
+     *
+     * @param {Function} onFinish - on finish callback
+     * @returns {void}
+     * @private
+     */
+    loadMessageFromCache(onFinish: () => void): void;
+    /**
+     * Cache appropriate message
+     *
+     * @param {string} type - message type
+     * @param {any} data - message payload
+     * @returns {void}
+     * @private
+     */
+    cacheData(type: string, data?: any): void;
+    /**
+     * 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
+     */
+    notifyAboutDataChunk(type: string, chunk?: any, isFromCache?: boolean): void;
+    /**
+     * Resolve "load" method with appropriate data information
+     *
+     * @param {any} data - data to resolve with
+     * @returns {void}
+     * @private
+     */
+    notifyAboutDataLoaded(data?: any): void;
+    /**
+     * Reject "load" method with appropriate data information
+     *
+     * @param {any} data - data to reject with
+     * @returns {void}
+     * @private
+     */
+    notifyAboutDataError(data?: any): void;
+    /**
+     * Subscribe to event notification
+     *
+     * @param {string} eventName - event name to subscribe
+     * @param {Function} callback - event handler
+     * @returns {void}
+     */
+    on(eventName: string, callback: (payload: any) => void): void;
+    /**
+     * Unsubscribe from event notification
+     *
+     * @param {string} eventName - event name to unsubscribe
+     * @param {Function} callback - event handler
+     * @returns {void}
+     */
+    off(eventName: string, callback: (payload: any) => void): void;
+    /**
+     * Unsubscribe from all event notifications
+     *
+     * @param {string} eventName - event name to unsubscribe
+     * @returns {void}
+     */
+    offAll(eventName: string): void;
+    listenerCount(eventName: string): number;
+    /**
+     * 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: string, ...rest: Array<any>): void;
+}
+export default AbstractDataLoadService;