@lightdash/common 0.1973.0 → 0.1973.1

package/dist/cjs/pivot/pivotQueryResults.d.ts

@@ -1,3 +1,4 @@
+import type { ReadyQueryResultsPage } from '../index';
 import { type ItemsMap } from '../types/field';
 import { type MetricQuery } from '../types/metricQuery';
 import { type PivotConfig, type PivotData } from '../types/pivot';
@@ -26,5 +27,17 @@ export declare const pivotResultsAsCsv: ({ pivotConfig, rows, itemMap, metricQue
     maxColumnLimit: number;
     undefinedCharacter?: string;
 }) => string[][];
+/**
+ * Converts SQL-pivoted results to PivotData format
+ * This handles results that are already pivoted at the SQL level (e.g., payments_total_revenue_any_bank_transfer)
+ * and transforms them into the same PivotData structure as pivotQueryResults
+ */
+export declare const convertSqlPivotedRowsToPivotData: ({ rows, pivotDetails, pivotConfig, getField, getFieldLabel, }: {
+    rows: ResultRow[];
+    pivotDetails: NonNullable<ReadyQueryResultsPage["pivotDetails"]>;
+    pivotConfig: Pick<PivotConfig, "rowTotals" | "columnTotals" | "metricsAsRows" | "hiddenMetricFieldIds" | "columnOrder">;
+    getField: FieldFunction;
+    getFieldLabel: FieldLabelFunction;
+}) => PivotData;
 export {};
 //# sourceMappingURL=pivotQueryResults.d.ts.map

package/dist/cjs/pivot/pivotQueryResults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pivotQueryResults.d.ts","sourceRoot":"","sources":["../../../src/pivot/pivotQueryResults.ts"],"names":[],"mappings":"AAIA,OAAO,EAKH,KAAK,QAAQ,EAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,SAAS,EAEjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,SAAS,EAAoB,MAAM,kBAAkB,CAAC;AAIpE,KAAK,aAAa,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAEvE,KAAK,kBAAkB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAElE,KAAK,qBAAqB,GAAG;IACzB,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,IAAI,CACb,WAAW,EACT,YAAY,GACZ,SAAS,GACT,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB,CACvB,CAAC;IACF,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IAC5D,OAAO,EAAE;QACL,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,kBAAkB,CAAC;CACrC,CAAC;AA8UF,eAAO,MAAM,iBAAiB,4FAQ3B,qBAAqB,KAAG,SAma1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,4GAS3B;IACC,WAAW,EAAE,WAAW,CAAC;IACzB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B,eA8DA,CAAC"}
+{"version":3,"file":"pivotQueryResults.d.ts","sourceRoot":"","sources":["../../../src/pivot/pivotQueryResults.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEtD,OAAO,EAKH,KAAK,QAAQ,EAChB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,EAEH,KAAK,WAAW,EAChB,KAAK,SAAS,EAEjB,MAAM,gBAAgB,CAAC;AACxB,OAAO,EAAE,KAAK,SAAS,EAAoB,MAAM,kBAAkB,CAAC;AAIpE,KAAK,aAAa,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,QAAQ,CAAC,MAAM,CAAC,GAAG,SAAS,CAAC;AAEvE,KAAK,kBAAkB,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;AAElE,KAAK,qBAAqB,GAAG;IACzB,WAAW,EAAE,WAAW,CAAC;IACzB,WAAW,EAAE,IAAI,CACb,WAAW,EACT,YAAY,GACZ,SAAS,GACT,mBAAmB,GACnB,mBAAmB,GACnB,kBAAkB,CACvB,CAAC;IACF,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,gBAAgB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IAC5D,OAAO,EAAE;QACL,UAAU,EAAE,MAAM,CAAC;KACtB,CAAC;IACF,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,kBAAkB,CAAC;CACrC,CAAC;AAydF,eAAO,MAAM,iBAAiB,4FAQ3B,qBAAqB,KAAG,SAuV1B,CAAC;AAEF,eAAO,MAAM,iBAAiB,4GAS3B;IACC,WAAW,EAAE,WAAW,CAAC;IACzB,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,OAAO,EAAE,QAAQ,CAAC;IAClB,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAC;IACjD,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC/B,eA8DA,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,kEAM1C;IACC,IAAI,EAAE,SAAS,EAAE,CAAC;IAClB,YAAY,EAAE,WAAW,CAAC,qBAAqB,CAAC,cAAc,CAAC,CAAC,CAAC;IACjE,WAAW,EAAE,IAAI,CACb,WAAW,EACT,WAAW,GACX,cAAc,GACd,eAAe,GACf,sBAAsB,GACtB,aAAa,CAClB,CAAC;IACF,QAAQ,EAAE,aAAa,CAAC;IACxB,aAAa,EAAE,kBAAkB,CAAC;CACrC,KAAG,SAyhBH,CAAC"}

package/dist/cjs/pivot/pivotQueryResults.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pivotResultsAsCsv = exports.pivotQueryResults = void 0;
+exports.convertSqlPivotedRowsToPivotData = exports.pivotResultsAsCsv = exports.pivotQueryResults = void 0;
 const tslib_1 = require("tslib");
 const isNumber_1 = tslib_1.__importDefault(require("lodash/isNumber"));
 const last_1 = tslib_1.__importDefault(require("lodash/last"));
@@ -246,6 +246,77 @@ const combinedRetrofit = (data, getField, getFieldLabel) => {
     data.retrofitData = { allCombinedData, pivotColumnInfo };
     return data;
 };
+const getHeaderValueTypes = ({ metricsAsRows, pivotDimensionNames, }) => {
+    const headerDimensionValueTypes = pivotDimensionNames.map((fieldId) => ({
+        type: field_1.FieldType.DIMENSION,
+        fieldId,
+    }));
+    const headerMetricValueTypes = metricsAsRows
+        ? []
+        : [{ type: field_1.FieldType.METRIC }];
+    return [...headerDimensionValueTypes, ...headerMetricValueTypes];
+};
+const getColumnTotals = ({ summableMetricFieldIds, rowIndices, totalColumns, dataColumns, dataValues, hasIndex, pivotConfig, indexValues, }) => {
+    let columnTotalFields;
+    let columnTotals;
+    const N_DATA_COLUMNS = dataColumns;
+    if (pivotConfig.columnTotals && hasIndex) {
+        if (pivotConfig.metricsAsRows) {
+            const N_TOTAL_ROWS = summableMetricFieldIds.length;
+            const N_TOTAL_COLS = totalColumns;
+            columnTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            columnTotals = create2DArray(N_TOTAL_ROWS, N_DATA_COLUMNS);
+            summableMetricFieldIds.forEach((fieldId, metricIndex) => {
+                columnTotalFields[metricIndex][N_TOTAL_COLS - 1] = {
+                    fieldId,
+                };
+            });
+            columnTotals = columnTotals.map((row, rowIndex) => row.map((_, totalColIndex) => {
+                const totalColFieldId = columnTotalFields[rowIndex][N_TOTAL_COLS - 1]?.fieldId;
+                const valueColIndices = totalColFieldId
+                    ? getAllIndicesForFieldId(rowIndices, totalColFieldId)
+                    : [];
+                return dataValues
+                    .filter((__, dataValueColIndex) => valueColIndices.includes(dataValueColIndex))
+                    .reduce((acc, value) => acc + parseNumericValue(value[totalColIndex]), 0);
+            }));
+        }
+        else {
+            const N_TOTAL_COLS = indexValues[0].length;
+            const N_TOTAL_ROWS = 1;
+            columnTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            columnTotals = create2DArray(N_TOTAL_ROWS, N_DATA_COLUMNS);
+            // set the last index cell as the "Total"
+            columnTotalFields[N_TOTAL_ROWS - 1][N_TOTAL_COLS - 1] = {
+                fieldId: undefined,
+            };
+            columnTotals = columnTotals.map((row, _totalRowIndex) => row.map((_col, colIndex) => dataValues
+                .map((dataRow) => dataRow[colIndex])
+                .reduce((acc, value) => acc + parseNumericValue(value), 0)));
+        }
+    }
+    return { columnTotalFields, columnTotals };
+};
+const getTitleFields = ({ hasHeader, hasIndex, headerValueTypes, indexValueTypes, }) => {
+    const titleFields = create2DArray(hasHeader ? headerValueTypes.length : 1, hasIndex ? indexValueTypes.length : 1);
+    headerValueTypes.forEach((headerValueType, headerIndex) => {
+        if (headerValueType.type === field_1.FieldType.DIMENSION) {
+            titleFields[headerIndex][hasIndex ? indexValueTypes.length - 1 : 0] = {
+                fieldId: headerValueType.fieldId,
+                direction: 'header',
+            };
+        }
+    });
+    indexValueTypes.forEach((indexValueType, indexIndex) => {
+        if (indexValueType.type === field_1.FieldType.DIMENSION) {
+            titleFields[hasHeader ? headerValueTypes.length - 1 : 0][indexIndex] = {
+                fieldId: indexValueType.fieldId,
+                direction: 'index',
+            };
+        }
+    });
+    return titleFields;
+};
 const pivotQueryResults = ({ pivotConfig, metricQuery, rows, options, getField, getFieldLabel, groupedSubtotals, }) => {
     if (rows.length === 0) {
         throw new Error('Cannot pivot results with no rows');
@@ -264,15 +335,10 @@ const pivotQueryResults = ({ pivotConfig, metricQuery, rows, options, getField,
     const dimensions = [...metricQuery.dimensions];
     // Headers (column index)
     const headerDimensions = pivotConfig.pivotDimensions.filter((pivotDimension) => dimensions.includes(pivotDimension));
-    const headerDimensionValueTypes = headerDimensions.map((d) => ({
-        type: field_1.FieldType.DIMENSION,
-        fieldId: d,
-    }));
-    const headerMetricValueTypes = pivotConfig.metricsAsRows ? [] : [{ type: field_1.FieldType.METRIC }];
-    const headerValueTypes = [
-        ...headerDimensionValueTypes,
-        ...headerMetricValueTypes,
-    ];
+    const headerValueTypes = getHeaderValueTypes({
+        metricsAsRows: pivotConfig.metricsAsRows,
+        pivotDimensionNames: headerDimensions,
+    });
     // Indices (row index)
     const indexDimensions = dimensions
         .filter((d) => !pivotConfig.pivotDimensions.includes(d))
@@ -444,59 +510,21 @@ const pivotQueryResults = ({ pivotConfig, metricQuery, rows, options, getField,
             }));
         }
     }
-    let columnTotalFields;
-    let columnTotals;
-    if (pivotConfig.columnTotals && hasIndex) {
-        if (pivotConfig.metricsAsRows) {
-            const N_TOTAL_ROWS = summableMetricFieldIds.length;
-            const N_TOTAL_COLS = indexValueTypes.length;
-            columnTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
-            columnTotals = create2DArray(N_TOTAL_ROWS, N_DATA_COLUMNS);
-            summableMetricFieldIds.forEach((fieldId, metricIndex) => {
-                columnTotalFields[metricIndex][N_TOTAL_COLS - 1] = {
-                    fieldId,
-                };
-            });
-            columnTotals = columnTotals.map((row, rowIndex) => row.map((_, totalColIndex) => {
-                const totalColFieldId = columnTotalFields[rowIndex][N_TOTAL_COLS - 1]?.fieldId;
-                const valueColIndices = totalColFieldId
-                    ? getAllIndicesForFieldId(rowIndices, totalColFieldId)
-                    : [];
-                return dataValues
-                    .filter((__, dataValueColIndex) => valueColIndices.includes(dataValueColIndex))
-                    .reduce((acc, value) => acc + parseNumericValue(value[totalColIndex]), 0);
-            }));
-        }
-        else {
-            const N_TOTAL_COLS = indexValues[0].length;
-            const N_TOTAL_ROWS = 1;
-            columnTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
-            columnTotals = create2DArray(N_TOTAL_ROWS, N_DATA_COLUMNS);
-            // set the last index cell as the "Total"
-            columnTotalFields[N_TOTAL_ROWS - 1][N_TOTAL_COLS - 1] = {
-                fieldId: undefined,
-            };
-            columnTotals = columnTotals.map((row, _totalRowIndex) => row.map((_col, colIndex) => dataValues
-                .map((dataRow) => dataRow[colIndex])
-                .reduce((acc, value) => acc + parseNumericValue(value), 0)));
-        }
-    }
-    const titleFields = create2DArray(hasHeader ? headerValueTypes.length : 1, hasIndex ? indexValueTypes.length : 1);
-    headerValueTypes.forEach((headerValueType, headerIndex) => {
-        if (headerValueType.type === field_1.FieldType.DIMENSION) {
-            titleFields[headerIndex][hasIndex ? indexValueTypes.length - 1 : 0] = {
-                fieldId: headerValueType.fieldId,
-                direction: 'header',
-            };
-        }
+    const { columnTotalFields, columnTotals } = getColumnTotals({
+        summableMetricFieldIds,
+        totalColumns: indexValueTypes.length,
+        dataColumns: N_DATA_COLUMNS,
+        dataValues,
+        rowIndices,
+        pivotConfig,
+        indexValues,
+        hasIndex,
     });
-    indexValueTypes.forEach((indexValueType, indexIndex) => {
-        if (indexValueType.type === field_1.FieldType.DIMENSION) {
-            titleFields[hasHeader ? headerValueTypes.length - 1 : 0][indexIndex] = {
-                fieldId: indexValueType.fieldId,
-                direction: 'index',
-            };
-        }
+    const titleFields = getTitleFields({
+        hasIndex,
+        hasHeader,
+        headerValueTypes,
+        indexValueTypes,
     });
     const cellsCount = (indexValueTypes.length === 0 ? titleFields[0].length : 0) +
         indexValueTypes.length +
@@ -572,4 +600,421 @@ const pivotResultsAsCsv = ({ pivotConfig, rows, itemMap, metricQuery, customLabe
     return [...headers, ...pivotedRows];
 };
 exports.pivotResultsAsCsv = pivotResultsAsCsv;
+/**
+ * Converts SQL-pivoted results to PivotData format
+ * This handles results that are already pivoted at the SQL level (e.g., payments_total_revenue_any_bank_transfer)
+ * and transforms them into the same PivotData structure as pivotQueryResults
+ */
+const convertSqlPivotedRowsToPivotData = ({ rows, pivotDetails, pivotConfig, getField, getFieldLabel, }) => {
+    if (rows.length === 0) {
+        throw new Error('Cannot convert SQL pivoted results with no rows');
+    }
+    const hiddenMetricFieldIds = pivotConfig.hiddenMetricFieldIds || [];
+    // Extract information from pivot details metadata
+    let indexColumns;
+    if (pivotDetails.indexColumn) {
+        if (Array.isArray(pivotDetails.indexColumn)) {
+            indexColumns = pivotDetails.indexColumn.map((col) => col.reference);
+        }
+        else {
+            indexColumns = [pivotDetails.indexColumn.reference];
+        }
+    }
+    else {
+        indexColumns = [];
+    }
+    // Get unique base metrics from valuesColumns
+    const baseMetricsArray = Array.from(new Set(pivotDetails.valuesColumns.map((col) => col.referenceField)));
+    const headerValueTypes = getHeaderValueTypes({
+        metricsAsRows: pivotConfig.metricsAsRows,
+        pivotDimensionNames: (pivotDetails.groupByColumns ?? []).map(({ reference }) => reference),
+    });
+    const indexValueTypes = pivotConfig.metricsAsRows
+        ? [
+            ...indexColumns.map((col) => ({
+                type: field_1.FieldType.DIMENSION,
+                fieldId: col,
+            })),
+            { type: field_1.FieldType.METRIC },
+        ]
+        : indexColumns.map((col) => ({
+            type: field_1.FieldType.DIMENSION,
+            fieldId: col,
+        }));
+    // Build header values (pivot dimension values)
+    const headerValues = [];
+    pivotDetails.groupByColumns?.forEach(({ reference }, index) => {
+        headerValues.push([]);
+        let columns = pivotDetails.valuesColumns;
+        if (pivotConfig.metricsAsRows) {
+            // For metrics as rows, we only need unique combinations of pivot values, excluding per metric duplicates
+            columns = Array.from(new Map(columns.map((col) => [
+                col.pivotValues
+                    .map(({ referenceField, value }) => `${referenceField}:${value}`)
+                    .join('|'),
+                col,
+            ])).values());
+        }
+        columns.forEach(({ pivotValues, pivotColumnName }) => {
+            const pivotValue = pivotValues.find(({ referenceField }) => referenceField === reference);
+            if (pivotValue) {
+                const field = getField(pivotValue.referenceField);
+                const formattedValue = field
+                    ? (0, formatting_1.formatItemValue)(field, pivotValue.value)
+                    : String(pivotValue.value);
+                const allColumnsWithSamePivotValues = columns.filter((matchingColumn) => {
+                    const referencesToMatch = (pivotDetails.groupByColumns || [])
+                        .map((groupByColumn) => groupByColumn.reference)
+                        .slice(0, index + 1);
+                    // Match all pivot values
+                    return referencesToMatch.every((referenceToMatch) => {
+                        const pivotValueA = pivotValues.find(({ referenceField: referenceField3 }) => referenceField3 === referenceToMatch);
+                        const pivotValueB = matchingColumn.pivotValues.find(({ referenceField: referenceField3 }) => referenceField3 === referenceToMatch);
+                        return pivotValueA?.value === pivotValueB?.value;
+                    });
+                });
+                const isFirstInGroup = allColumnsWithSamePivotValues[0].pivotColumnName ===
+                    pivotColumnName;
+                headerValues[index].push({
+                    type: 'value',
+                    fieldId: reference,
+                    value: {
+                        raw: pivotValue.value,
+                        formatted: formattedValue,
+                    },
+                    colSpan: isFirstInGroup
+                        ? allColumnsWithSamePivotValues.length
+                        : 0,
+                });
+            }
+        });
+    });
+    // Add metric labels for columns if not metrics as rows
+    if (!pivotConfig.metricsAsRows && baseMetricsArray.length > 0) {
+        headerValues.push(pivotDetails.valuesColumns.map(({ referenceField }) => ({
+            type: 'label',
+            fieldId: referenceField,
+        })));
+    }
+    const filteredHeaderValues = headerValues.filter((row) => row.length > 0);
+    // Build index values (row identifiers)
+    let indexValues;
+    if (pivotConfig.metricsAsRows) {
+        indexValues = rows.reduce((acc, row) => {
+            // multiply rows per metric
+            baseMetricsArray.forEach((metric) => {
+                acc.push([
+                    ...indexColumns.map((col) => ({
+                        type: 'value',
+                        fieldId: col,
+                        value: row[col].value,
+                        colSpan: 1,
+                    })),
+                    {
+                        type: 'label',
+                        fieldId: metric,
+                    },
+                ]);
+            });
+            return acc;
+        }, []);
+    }
+    else {
+        indexValues = rows.map((row) => indexColumns.map((col) => ({
+            type: 'value',
+            fieldId: col,
+            value: row[col].value,
+            colSpan: 1,
+        })));
+    }
+    // Build data values (the actual pivot data)
+    let dataValues;
+    const rowIndices = {};
+    let rowCount = 0;
+    // Get unique columns
+    const uniqueColumns = pivotConfig.metricsAsRows
+        ? Array.from(new Map(pivotDetails.valuesColumns.map((col) => [
+            col.pivotValues
+                .map(({ referenceField, value }) => `${referenceField}:${value}`)
+                .join('|'),
+            col,
+        ])).values())
+        : pivotDetails.valuesColumns;
+    if (pivotConfig.metricsAsRows) {
+        // multiply rows per metric
+        dataValues = rows.reduce((acc, row) => {
+            baseMetricsArray.forEach((metric) => {
+                const indexRowValues = [
+                    ...indexColumns.map((fieldId) => String(row[fieldId].value.raw)),
+                    metric,
+                ];
+                // Build row data for this metric using unique columns
+                // For each unique column combination, find the corresponding value for this metric
+                const rowData = uniqueColumns.map((uniqueCol) => {
+                    // Find the actual column in sortedValuesColumns that matches this unique combination and metric
+                    const matchingColumn = pivotDetails.valuesColumns.find((col) => col.referenceField === metric &&
+                        col.pivotValues.every((pv) => uniqueCol.pivotValues.some((upv) => upv.referenceField ===
+                            pv.referenceField &&
+                            upv.value === pv.value)));
+                    return matchingColumn && row[matchingColumn.pivotColumnName]
+                        ? row[matchingColumn.pivotColumnName].value
+                        : null;
+                });
+                acc.push(rowData);
+                setIndexByKey(rowIndices, indexRowValues, rowCount);
+                rowCount += 1;
+            });
+            return acc;
+        }, []);
+    }
+    else {
+        dataValues = rows.map((row, rowIndex) => {
+            const indexRowValues = indexColumns.map((fieldId) => String(row[fieldId].value.raw));
+            setIndexByKey(rowIndices, indexRowValues, rowIndex);
+            return pivotDetails.valuesColumns.map((valueCol) => row[valueCol.pivotColumnName]
+                ? row[valueCol.pivotColumnName].value
+                : null);
+        });
+        rowCount = rows.length;
+    }
+    const fullPivotConfig = {
+        pivotDimensions: pivotDetails.groupByColumns?.map((col) => col.reference) || [],
+        metricsAsRows: pivotConfig.metricsAsRows || false,
+        columnOrder: pivotConfig.columnOrder,
+        hiddenMetricFieldIds: pivotConfig.hiddenMetricFieldIds || [],
+        columnTotals: pivotConfig.columnTotals,
+        rowTotals: pivotConfig.rowTotals,
+    };
+    // Compute row totals if requested
+    let rowTotalFields;
+    let rowTotals;
+    const hasHeader = headerValueTypes.length > 0;
+    const hasIndex = indexValueTypes.length > 0;
+    const N_DATA_ROWS = hasIndex ? dataValues.length : 1;
+    const N_DATA_COLUMNS = hasHeader ? uniqueColumns.length : 1;
+    // Build column indices using unique columns
+    const columnIndices = uniqueColumns.reduce((acc, valuesColumn, index) => {
+        const pivotValues = (pivotDetails.groupByColumns || []).map((col) => valuesColumn.pivotValues.find(({ referenceField }) => referenceField === col.reference)?.value);
+        // Create nested structure based on pivotValues
+        let current = acc;
+        for (let i = 0; i < pivotValues.length; i += 1) {
+            const pivotValue = String(pivotValues[i]);
+            if (!Object.prototype.hasOwnProperty.call(current, pivotValue)) {
+                Object.defineProperty(current, pivotValue, {
+                    value: {},
+                    writable: true,
+                    enumerable: true,
+                    configurable: true,
+                });
+            }
+            current = current[pivotValue];
+        }
+        // For metricsAsRows, don't include metric in column key
+        if (!pivotConfig.metricsAsRows) {
+            Object.defineProperty(current, valuesColumn.referenceField, {
+                value: index,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+        else {
+            // Use a generic key since metrics are in rows, not columns
+            Object.defineProperty(current, 'value', {
+                value: index,
+                writable: true,
+                enumerable: true,
+                configurable: true,
+            });
+        }
+        return acc;
+    }, {});
+    const summableMetricFieldIds = baseMetricsArray.filter((metricId) => {
+        const field = getField(metricId);
+        // Skip if field is not found or is a dimension or is hidden
+        if (!field || (0, field_1.isDimension)(field))
+            return false;
+        if (hiddenMetricFieldIds.includes(metricId))
+            return false;
+        return (0, field_1.isSummable)(field);
+    });
+    if (fullPivotConfig.rowTotals && hasHeader) {
+        if (fullPivotConfig.metricsAsRows) {
+            const N_TOTAL_COLS = 1;
+            const N_TOTAL_ROWS = headerValues.length;
+            rowTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            rowTotals = create2DArray(N_DATA_ROWS, N_TOTAL_COLS);
+            // set the last header cell as the "Total"
+            rowTotalFields[N_TOTAL_ROWS - 1][N_TOTAL_COLS - 1] = {
+                fieldId: undefined,
+            };
+            rowTotals = rowTotals.map((row, rowIndex) => row.map(() => dataValues[rowIndex].reduce((acc, value) => acc + parseNumericValue(value), 0)));
+        }
+        else {
+            const N_TOTAL_COLS = summableMetricFieldIds.length;
+            const N_TOTAL_ROWS = headerValues.length;
+            rowTotalFields = create2DArray(N_TOTAL_ROWS, N_TOTAL_COLS);
+            rowTotals = create2DArray(rows.length, N_TOTAL_COLS);
+            // Set the last header cell as the "Total"
+            summableMetricFieldIds.forEach((fieldId, metricIndex) => {
+                rowTotalFields[N_TOTAL_ROWS - 1][metricIndex] = {
+                    fieldId,
+                };
+            });
+            rowTotals = rowTotals.map((row, rowIndex) => row.map((_, totalColIndex) => {
+                const totalColFieldId = rowTotalFields[N_TOTAL_ROWS - 1][totalColIndex]
+                    ?.fieldId;
+                const valueColIndices = totalColFieldId
+                    ? getAllIndicesForFieldId(columnIndices, totalColFieldId)
+                    : [];
+                return dataValues[rowIndex]
+                    .filter((__, dataValueColIndex) => valueColIndices.includes(dataValueColIndex))
+                    .reduce((acc, value) => acc + parseNumericValue(value), 0);
+            }));
+        }
+    }
+    const { columnTotalFields, columnTotals } = getColumnTotals({
+        summableMetricFieldIds,
+        totalColumns: indexValueTypes.length,
+        dataColumns: N_DATA_COLUMNS,
+        dataValues,
+        rowIndices,
+        pivotConfig,
+        indexValues,
+        hasIndex,
+    });
+    // Build retrofit data for backwards compatibility
+    const allCombinedData = rows
+        .map((row) => {
+        const combinedRow = {};
+        // Add index columns
+        indexColumns.forEach((col) => {
+            combinedRow[col] = row[col];
+        });
+        if (pivotConfig.metricsAsRows) {
+            // Add metric label with correct index (after all index columns)
+            const labelIndex = indexColumns.length;
+            const metricLabel = getFieldLabel(baseMetricsArray[0]) || baseMetricsArray[0];
+            combinedRow[`label-${labelIndex}`] = {
+                value: {
+                    raw: metricLabel,
+                    formatted: metricLabel,
+                },
+            };
+        }
+        // Add data columns with generated field IDs using metadata
+        pivotDetails.valuesColumns.forEach((valueCol, colIndex) => {
+            const pivotDimensions = (pivotDetails.groupByColumns || []).map((col) => col.reference);
+            const fieldId = pivotConfig.metricsAsRows
+                ? `${pivotDimensions.join('__')}__${colIndex}`
+                : `${pivotDimensions.join('__')}__${valueCol.referenceField}__${colIndex}`;
+            if (row[valueCol.pivotColumnName]) {
+                combinedRow[fieldId] = row[valueCol.pivotColumnName];
+            }
+        });
+        return combinedRow;
+    })
+        .map((combinedRow, rowIndex) => {
+        // Add row totals if enabled
+        if (fullPivotConfig.rowTotals && rowTotals) {
+            const rowTotalValue = rowTotals[rowIndex]?.[0];
+            if (rowTotalValue !== undefined) {
+                const field = getField(baseMetricsArray[0]);
+                const formattedValue = field
+                    ? (0, formatting_1.formatItemValue)(field, rowTotalValue)
+                    : String(rowTotalValue);
+                return {
+                    ...combinedRow,
+                    'row-total-0': {
+                        value: {
+                            raw: rowTotalValue,
+                            formatted: formattedValue,
+                        },
+                    },
+                };
+            }
+        }
+        return combinedRow;
+    });
+    const pivotColumnInfo = [
+        ...indexColumns.map((col) => ({
+            fieldId: col,
+            baseId: undefined,
+            underlyingId: undefined,
+            columnType: 'indexValue',
+        })),
+        ...(pivotConfig.metricsAsRows
+            ? [
+                {
+                    fieldId: `label-${indexColumns.length}`,
+                    baseId: undefined,
+                    underlyingId: undefined,
+                    columnType: 'label',
+                },
+            ]
+            : []),
+        ...pivotDetails.valuesColumns.map((valueCol, colIndex) => {
+            const pivotDimensions = (pivotDetails.groupByColumns || []).map((col) => col.reference);
+            const fieldId = pivotConfig.metricsAsRows
+                ? `${pivotDimensions.join('__')}__${colIndex}`
+                : `${pivotDimensions.join('__')}__${valueCol.referenceField}__${colIndex}`;
+            return {
+                fieldId,
+                baseId: pivotConfig.metricsAsRows
+                    ? pivotDimensions[0]
+                    : valueCol.referenceField,
+                underlyingId: undefined,
+                columnType: undefined,
+            };
+        }),
+        ...(fullPivotConfig.rowTotals
+            ? [
+                {
+                    fieldId: 'row-total-0',
+                    baseId: 'row-total-0',
+                    underlyingId: undefined,
+                    columnType: 'rowTotal',
+                },
+            ]
+            : []),
+    ];
+    const titleFields = getTitleFields({
+        hasIndex,
+        hasHeader,
+        headerValueTypes,
+        indexValueTypes,
+    });
+    const pivotData = {
+        titleFields,
+        headerValueTypes,
+        headerValues: filteredHeaderValues,
+        indexValueTypes,
+        indexValues,
+        dataColumnCount: N_DATA_COLUMNS,
+        dataValues,
+        rowTotalFields,
+        columnTotalFields,
+        rowTotals,
+        columnTotals,
+        cellsCount: pivotConfig.metricsAsRows
+            ? indexColumns.length +
+                1 + // label column
+                uniqueColumns.length +
+                (rowTotals ? rowTotals[0].length : 0)
+            : indexColumns.length +
+                uniqueColumns.length +
+                (rowTotals ? rowTotals[0].length : 0),
+        rowsCount: pivotConfig.metricsAsRows
+            ? rows.length * baseMetricsArray.length
+            : rows.length,
+        pivotConfig: fullPivotConfig,
+        retrofitData: {
+            allCombinedData,
+            pivotColumnInfo,
+        },
+        groupedSubtotals: undefined,
+    };
+    return combinedRetrofit(pivotData, getField, getFieldLabel);
+};
+exports.convertSqlPivotedRowsToPivotData = convertSqlPivotedRowsToPivotData;
 //# sourceMappingURL=pivotQueryResults.js.map