@sisense/sdk-query-client 1.7.2 → 1.8.0

package/dist/jaql/get-jaql-query-payload.js

@@ -4,6 +4,7 @@ import { v4 as uuid } from 'uuid';
 import merge from 'ts-deepmerge';
 import { isPivotAttribute, isPivotMeasure, DEFAULT_PIVOT_GRAND_TOTALS, isDataSourceInfo, } from '@sisense/sdk-data';
 import { applyHighlightFilters, matchHighlightsWithAttributes } from './metadata/highlights.js';
+import { getPivotMetadataStats, normalizeLastRowSorting, preparePivotRowJaqlSortOptions, } from './pivot/pivot-query-utils.js';
 const JAQL_BY_CSDK = 'ComposeSDK';
 /**
  * @internal
@@ -62,8 +63,12 @@ export function getPivotJaqlQueryPayload(pivotQueryDescription, shouldSkipHighli
     }
     return queryPayload;
 }
-function jaqlPivotAttribute(a, panel, index) {
-    return Object.assign(Object.assign(Object.assign({}, (isPivotAttribute(a) ? a.attribute.jaql() : a.jaql())), (isPivotAttribute(a) && a.includeSubTotals ? { format: { subtotal: true } } : {})), { panel, field: { index: index, id: `${panel}-${index}` } });
+function jaqlPivotAttribute(a, panel, index, metadataStats) {
+    const jaql = Object.assign(Object.assign({}, (isPivotAttribute(a) ? a.attribute.jaql(true) : a.jaql(true))), (panel === 'rows' &&
+        isPivotAttribute(a) &&
+        a.sort &&
+        preparePivotRowJaqlSortOptions(a.sort, index, metadataStats)));
+    return Object.assign(Object.assign({ jaql }, (isPivotAttribute(a) && a.includeSubTotals ? { format: { subtotal: true } } : {})), { panel, field: { index: index, id: `${panel}-${index}` } });
 }
 function jaqlPivotMeasure(m, panel, index) {
     return Object.assign(Object.assign({}, (isPivotMeasure(m)
@@ -82,10 +87,11 @@ function jaqlPivotMeasure(m, panel, index) {
  */
 function preparePivotQueryMetadata(pivotMetadataDescription, shouldSkipHighlightsWithoutAttributes) {
     const { rowsAttributes, columnsAttributes, measures, filters, filterRelations, highlights } = pivotMetadataDescription;
+    const metadataStats = getPivotMetadataStats(rowsAttributes, columnsAttributes, measures);
     let fieldIndex = 0; // used as a global counter to build field.index in Jaql MetadataItem
-    const rowsAttributesMetadata = rowsAttributes.map((a, index) => jaqlPivotAttribute(a, 'rows', index + fieldIndex));
+    const rowsAttributesMetadata = rowsAttributes.map((a, index) => jaqlPivotAttribute(a, 'rows', index + fieldIndex, metadataStats));
     fieldIndex = fieldIndex + rowsAttributes.length;
-    const columnsAttributesMetadata = columnsAttributes.map((a, index) => jaqlPivotAttribute(a, 'columns', index + fieldIndex));
+    const columnsAttributesMetadata = columnsAttributes.map((a, index) => jaqlPivotAttribute(a, 'columns', index + fieldIndex, metadataStats));
     fieldIndex = fieldIndex + columnsAttributes.length;
     const attributesMetadata = [
         ...rowsAttributesMetadata,
@@ -93,7 +99,9 @@ function preparePivotQueryMetadata(pivotMetadataDescription, shouldSkipHighlight
     ];
     const measuresMetadata = measures.map((m, index) => jaqlPivotMeasure(m, 'measures', index + fieldIndex));
     const filtersMetadata = prepareFilterMetadata(attributesMetadata, filters, filterRelations, highlights, shouldSkipHighlightsWithoutAttributes);
-    return [...attributesMetadata, ...measuresMetadata, ...filtersMetadata];
+    const metadata = [...attributesMetadata, ...measuresMetadata, ...filtersMetadata];
+    normalizeLastRowSorting(metadata, metadataStats);
+    return metadata;
 }
 /**
  * Prepares the options part of the JAQL payload for a pivot query.

package/dist/jaql/pivot/pivot-query-utils.d.ts

@@ -0,0 +1,38 @@
+import type { Attribute, Measure, PivotAttribute, PivotMeasure, PivotRowsSort, SortDirection } from '@sisense/sdk-data';
+import { MetadataItem } from '../../types.js';
+/**
+ * Represents statistics about a pivot table metadata.
+ */
+export type PivotMetadataStats = {
+    rowsCount: number;
+    columnsCount: number;
+    measuresCount: number;
+};
+/**
+ * Calculates statistics about the pivot table metadata.
+ */
+export declare function getPivotMetadataStats(rowsAttributes: (Attribute | PivotAttribute)[], columnsAttributes: (Attribute | PivotAttribute)[], measures: (Measure | PivotMeasure)[]): PivotMetadataStats;
+/**
+ * Converts sort direction to JAQL sort direction.
+ */
+export declare function convertSortDirectionToJaqlSort(direction: SortDirection): "asc" | "desc" | "none";
+/**
+ * Prepares JAQL sort options for pivot table row.
+ */
+export declare function preparePivotRowJaqlSortOptions(sort: PivotRowsSort, rowIndex: number, metadataStats: PivotMetadataStats): {
+    sort: string;
+    sortDetails: {
+        dir: string;
+        field?: number | undefined;
+        measurePath?: Record<number, string | number> | undefined;
+        sortingLastDimension?: boolean | undefined;
+        initialized?: boolean | undefined;
+    };
+};
+/**
+ * Normalizes sorting for the last row of the pivot table.
+ *
+ * According to the existing pivot JAQL structure,the sorting configuration of the last row
+ * should be located inside the target measure metadata
+ */
+export declare function normalizeLastRowSorting(metadata: MetadataItem[], metadataStats: PivotMetadataStats): void;

package/dist/jaql/pivot/pivot-query-utils.js

@@ -0,0 +1,76 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+/**
+ * Calculates statistics about the pivot table metadata.
+ */
+export function getPivotMetadataStats(rowsAttributes, columnsAttributes, measures) {
+    return {
+        rowsCount: rowsAttributes.length,
+        columnsCount: columnsAttributes.length,
+        measuresCount: measures.length,
+    };
+}
+/**
+ * Converts sort direction to JAQL sort direction.
+ */
+export function convertSortDirectionToJaqlSort(direction) {
+    switch (direction) {
+        case 'sortAsc':
+            return 'asc';
+        case 'sortDesc':
+            return 'desc';
+        default:
+            return 'none';
+    }
+}
+/**
+ * Prepares JAQL sort options for pivot table row.
+ */
+export function preparePivotRowJaqlSortOptions(sort, rowIndex, metadataStats) {
+    const sortDirection = convertSortDirectionToJaqlSort(sort.direction);
+    const isLastRow = rowIndex === metadataStats.rowsCount - 1;
+    const sortDetails = {
+        dir: sortDirection,
+        initialized: true,
+        field: sort.by && 'valuesIndex' in sort.by
+            ? metadataStats.rowsCount + metadataStats.columnsCount + sort.by.valuesIndex
+            : rowIndex,
+    };
+    if (isLastRow) {
+        sortDetails.sortingLastDimension = true;
+    }
+    if (sort.by) {
+        sortDetails.measurePath = (sort.by.columnsMembersPath || []).reduce((path, columnMember, columnIndex) => (Object.assign(Object.assign({}, path), { [metadataStats.rowsCount + columnIndex]: columnMember })), {});
+    }
+    return {
+        sort: sortDirection,
+        sortDetails,
+    };
+}
+/**
+ * Normalizes sorting for the last row of the pivot table.
+ *
+ * According to the existing pivot JAQL structure,the sorting configuration of the last row
+ * should be located inside the target measure metadata
+ */
+export function normalizeLastRowSorting(metadata, metadataStats) {
+    const lastRowMetadata = metadata[metadataStats.rowsCount - 1];
+    const isSortedByMeasure = lastRowMetadata.jaql.sortDetails &&
+        lastRowMetadata.jaql.sortDetails.field !== metadataStats.rowsCount - 1;
+    if (isSortedByMeasure) {
+        const targetMeasureMetadata = metadata[lastRowMetadata.jaql.sortDetails.field];
+        const _a = lastRowMetadata.jaql, { sortDetails, sort } = _a, jaqlWithoutSortOptions = __rest(_a, ["sortDetails", "sort"]);
+        targetMeasureMetadata.jaql.sortDetails = sortDetails;
+        targetMeasureMetadata.jaql.sort = sort;
+        lastRowMetadata.jaql = jaqlWithoutSortOptions;
+    }
+}

package/dist/types.d.ts

@@ -72,6 +72,42 @@ export type ExecutingPivotQueryResult = {
     resultPromise: Promise<PivotQueryResultData>;
     cancel: (reason?: string) => Promise<void>;
 };
+interface DecimalAbbreviations {
+    k: boolean;
+    m: boolean;
+    b: boolean;
+    t: boolean;
+}
+export declare enum CurrencyPosition {
+    PRE = "pre",
+    POST = "post"
+}
+export type NumericMask = {
+    isdefault?: boolean;
+    abbreviations?: DecimalAbbreviations;
+    decimals?: 'auto' | number | string;
+    currency?: {
+        symbol: string;
+        position: CurrencyPosition;
+    };
+    percent?: boolean;
+    number?: {
+        separated: boolean;
+    };
+    separated?: boolean;
+    type?: string;
+};
+export type DatetimeMask = {
+    isdefault?: boolean;
+    years: string;
+    quarters: string;
+    months: string;
+    weeks: string;
+    minutes: string;
+    days: string;
+    type: string;
+    dateAndTime?: string;
+};
 export type MetadataItem = {
     instanceid?: string;
     measure?: MetadataItemJaql;
@@ -79,9 +115,7 @@ export type MetadataItem = {
     panel?: string;
     isScope?: boolean;
     format?: {
-        mask?: {
-            [level: string]: string | undefined;
-        };
+        mask?: Partial<DatetimeMask> | Partial<NumericMask>;
         number?: string;
         subtotal?: boolean;
         width?: number;
@@ -124,11 +158,19 @@ export type MetadataItemJaql = {
         };
     };
     title?: string;
+    type?: string;
     formula?: string;
     context?: {
         [itemId: string]: MetadataItemJaql;
     };
     filter?: MetadataItem;
+    sortDetails?: {
+        dir: string;
+        field?: number;
+        measurePath?: Record<number, string | number>;
+        sortingLastDimension?: boolean;
+        initialized?: boolean;
+    };
 };
 export type JaqlQueryPayload = QueryOptions & {
     filterRelations?: FilterRelationsJaql;
@@ -161,3 +203,4 @@ export type DataSourceSchema = {
 } & AnyObject;
 export type AbortRequestFunction = (reason?: string) => void;
 export type QueryGuid = string;
+export {};

package/dist/types.js

@@ -1 +1,5 @@
-export {};
+export var CurrencyPosition;
+(function (CurrencyPosition) {
+    CurrencyPosition["PRE"] = "pre";
+    CurrencyPosition["POST"] = "post";
+})(CurrencyPosition = CurrencyPosition || (CurrencyPosition = {}));

package/package.json

@@ -11,7 +11,7 @@
     "Sisense",
     "Compose SDK"
   ],
-  "version": "1.7.2",
+  "version": "1.8.0",
   "type": "module",
   "exports": "./dist/index.js",
   "main": "./dist/index.js",
@@ -20,10 +20,10 @@
   "author": "Sisense",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@sisense/sdk-common": "^1.7.2",
-    "@sisense/sdk-data": "^1.7.2",
-    "@sisense/sdk-pivot-client": "^1.7.2",
-    "@sisense/sdk-rest-client": "^1.7.2",
+    "@sisense/sdk-common": "^1.8.0",
+    "@sisense/sdk-data": "^1.8.0",
+    "@sisense/sdk-pivot-client": "^1.8.0",
+    "@sisense/sdk-rest-client": "^1.8.0",
     "@sisense/task-manager": "^0.1.0",
     "numeral": "^2.0.6",
     "ts-deepmerge": "6.0.2",