@quillsql/react 2.12.26 → 2.12.28

package/dist/esm/utils/dashboard.js

@@ -1,9 +1,9 @@
 import { valueFormatter } from './valueFormatter';
-import { generatePivotTable, generatePivotTableYAxis, getDateRange, getDateString, } from '../internals/ReportBuilder/PivotModal';
+import { generatePivotTable, generatePivotTableYAxis, } from '../internals/ReportBuilder/PivotModal';
 import { snakeAndCamelCaseToTitleCase } from './textProcessing';
-import { generatePivotQuery } from './queryConstructor';
 import { getData } from './dataFetcher';
-import { differenceInDays } from 'date-fns';
+import { getDateBucketFromRange } from './dates';
+import { generatePivotWithSQL } from './pivotConstructor';
 const defaultDashboardItem = {
     id: '',
     name: '',
@@ -67,8 +67,10 @@ export async function cleanDashboardItem(item, dashboardFilters, client, dateBuc
         xAxisFormat: item.xAxisFormat,
         order: item.order,
         filtersApplied: item.filtersApplied,
+        rowCount: parseInt(item.rowCount),
         sort: item.sort,
         page: item.page,
+        itemQuery: item.itemQuery,
     };
 }
 /**
@@ -118,106 +120,34 @@ async function getPivotTable(report, dashboardFilters, client, dateBucketInitial
     }
     const pivot = report?.pivot;
     const data = report || {};
-    if (client && client.databaseType.toLowerCase() === 'postgresql') {
+    if (pivot && client && client.databaseType.toLowerCase() === 'postgresql') {
+        if (report.rowCount === 0) {
+            return { rows: [], columns: [] };
+        }
         try {
-            let dateRange = undefined;
-            let comparisonInterval = undefined;
             let dateBucket = dateBucketInitial;
-            if (!dateBucket && pivot.rowFieldType !== 'string' && pivot.rowField) {
-                let filterDateRange = undefined;
-                if (dateFilter) {
-                    filterDateRange = {
-                        start: dateFilter.startDate,
-                        end: dateFilter.endDate,
-                    };
-                }
-                dateRange = getDateRange(filterDateRange, pivot.rowField, data.rows);
-                const difference = differenceInDays(dateRange.end, dateRange.start);
-                if (difference < 14) {
-                    dateBucket = 'day';
-                }
-                else if (difference < 60) {
-                    dateBucket = 'week';
-                }
-                else if (difference < 365 * 3) {
-                    dateBucket = 'month';
-                }
-                else {
-                    dateBucket = 'year';
-                }
+            let filterDateRange = undefined;
+            if (dateFilter) {
+                filterDateRange = {
+                    start: dateFilter.startDate,
+                    end: dateFilter.endDate,
+                };
             }
-            if (dateFilter && dateFilter && dateFilter.comparisonRange) {
-                const comparisonRange = differenceInDays(dateFilter?.comparisonRange.endDate, dateFilter?.comparisonRange.startDate);
-                if (!isNaN(comparisonRange)) {
-                    if (dateBucket === 'month') {
-                        comparisonInterval = comparisonRange / 30 + ' month';
-                    }
-                    else if (dateBucket === 'year') {
-                        comparisonInterval = comparisonRange / 365 + ' year';
-                    }
-                    else {
-                        comparisonInterval = comparisonRange + ' day';
-                    }
-                }
+            else if (report.dateRange) {
+                filterDateRange = report.dateRange;
             }
-            const sqlQuery = generatePivotQuery(pivot, report.itemQuery, report.rows, dateBucket, comparisonInterval);
-            if (sqlQuery && report.rows.length > 0) {
-                const hostedBody = {
-                    metadata: {
-                        preQueries: [sqlQuery],
-                        task: 'query',
-                        orgId: client.customerId || '*',
-                        clientId: client.publicKey,
-                        databaseType: client?.databaseType,
-                        getCustomFields: false,
-                        runQueryConfig: {
-                            overridePost: true,
-                            convertDatatypes: true,
-                        },
-                    },
-                };
-                const cloudBody = { ...hostedBody };
-                const resp = await getData(client, 'query', 'same-origin', hostedBody, cloudBody);
-                // With our current design we have to remove the second row field but leave the first for comparison purposes.
-                const rows = resp.queryResults[0].rows;
-                const columns = resp.queryResults[0].fields
-                    .map((field) => ({
-                    field: field.name,
-                    label: field.name.replace('comparison_', 'comparison '),
-                }))
-                    .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0);
-                if (pivot.rowFieldType !== 'string') {
-                    rows.forEach((row) => {
-                        row[pivot.rowField] = getDateString(row[pivot.rowField], undefined, dateBucket);
-                    });
-                    // add a row for each date in the range that doesn't have a value
-                    if (pivot.rowFieldType !== 'string') {
-                        const dateSet = new Set(rows.map((row) => row[pivot.rowField]));
-                        // create a loop that will go through each formatted date and add a row if it doesn't exist going to the current date
-                        for (let date = dateFilter.startDate; date <= dateFilter.endDate; date = new Date(date.getTime() + 24 * 60 * 60 * 1000)) {
-                            const formattedDate = getDateString(date.toDateString(), undefined, dateBucket);
-                            if (!dateSet.has(formattedDate)) {
-                                const newRow = {};
-                                newRow[pivot.rowField] = formattedDate;
-                                rows.push(newRow);
-                                dateSet.add(formattedDate);
-                            }
-                            // order the rows by the date field
-                            rows.sort((a, b) => {
-                                return new Date(a[pivot.rowField]) < new Date(b[pivot.rowField])
-                                    ? -1
-                                    : 1;
-                            });
-                        }
-                    }
-                }
-                return {
-                    rows: rows,
-                    columns: columns,
-                };
+            if (!dateBucket && filterDateRange) {
+                dateBucket = getDateBucketFromRange(filterDateRange);
             }
+            const pivotTable = await generatePivotWithSQL(pivot, report, client, dateBucket, dateFilter, report.distinctStrings);
+            if (pivotTable) {
+                return pivotTable;
+            }
+            throw new Error('Error generating pivot table');
+        }
+        catch (e) {
+            throw new Error('Error generating pivot table: ' + e);
         }
-        catch (e) { }
     }
     return pivot && data.rows
         ? generatePivotTable(pivot, JSON.parse(JSON.stringify(data.rows)), // deep copy
@@ -274,3 +204,21 @@ function extractPivotedYAxis(pivotTable, itemInfo, config = undefined) {
     }
     return fields;
 }
+export async function getDashboard(dashboardName, client) {
+    const searchParams = new URLSearchParams({
+        publicKey: client.publicKey,
+        orgId: client.customerId,
+        name: dashboardName,
+    }).toString();
+    const hostedBody = {
+        metadata: {
+            name: dashboardName,
+            task: 'config',
+            clientId: client.publicKey,
+            orgId: client.customerId || '*',
+            databaseType: client.databaseType,
+        },
+    };
+    const resp = await getData(client, `dashconfig?${searchParams}`, 'omit', hostedBody, null, 'GET');
+    return resp;
+}

package/dist/esm/utils/dataFetcher.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataFetcher.d.ts","sourceRoot":"","sources":["../../../src/utils/dataFetcher.tsx"],"names":[],"mappings":"AAEA,wBAAsB,OAAO,CAC3B,MAAM,EAAE,GAAG,EACX,kBAAkB,EAAE,MAAM,EAC1B,MAAM,EAAE,kBAAkB,EAC1B,iBAAiB,EAAE,GAAG,EACtB,gBAAgB,EAAE,GAAG,EACrB,MAAM,SAAS,gBAgEhB;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,GAAG,EACX,kBAAkB,EAAE,MAAM,EAC1B,gBAAgB,EAAE,GAAG,EACrB,MAAM,SAAS,gBAgChB"}
+{"version":3,"file":"dataFetcher.d.ts","sourceRoot":"","sources":["../../../src/utils/dataFetcher.tsx"],"names":[],"mappings":"AAqBA,wBAAsB,OAAO,CAC3B,MAAM,EAAE,GAAG,EACX,kBAAkB,EAAE,MAAM,EAC1B,MAAM,EAAE,kBAAkB,EAC1B,iBAAiB,EAAE,GAAG,EACtB,gBAAgB,EAAE,GAAG,EACrB,MAAM,SAAS,gBAmGhB;AAED,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,GAAG,EACX,kBAAkB,EAAE,MAAM,EAC1B,gBAAgB,EAAE,GAAG,EACrB,MAAM,SAAS,gBAgChB"}

package/dist/esm/utils/dataFetcher.js

@@ -1,3 +1,22 @@
+function parseData(rows, queryType) {
+    if (!rows || rows.length === 0)
+        return [];
+    switch (queryType) {
+        case 'dateRange':
+            return {
+                start: new Date(rows[0]?.min_date),
+                end: new Date(rows[0]?.max_date),
+            };
+        case 'rowCount':
+            return parseInt(rows[0]?.count);
+        case 'distinctStrings':
+            return rows.map((row) => {
+                return row['column_field'];
+            });
+        default:
+            return rows;
+    }
+}
 // this function gets the data either from the self hosted endpoint or
 // our cloud server
 export async function getData(client, cloudQueryEndpoint, noCred, hostedRequestBody, cloudRequestBody, method = 'POST') {
@@ -18,21 +37,45 @@ export async function getData(client, cloudQueryEndpoint, noCred, hostedRequestB
                 return { success: false, errorMessage: responseJson.error };
             }
             let result;
-            if (responseJson.data?.data) {
-                result = {
-                    fields: responseJson?.data.queries?.queryResults[0]?.fields,
-                    ...responseJson.data.data,
-                    rows: responseJson?.data.queries?.queryResults[0]?.rows,
-                    compareRows: responseJson?.data.queries?.queryResults[1]?.rows,
-                };
+            if (hostedRequestBody &&
+                hostedRequestBody.metadata &&
+                hostedRequestBody.metadata.task === 'report') {
+                if (responseJson.data?.data) {
+                    result = {
+                        fields: responseJson?.data.queries?.queryResults[0]?.fields,
+                        ...responseJson.data.data,
+                    };
+                    responseJson.data.data.queryOrder.forEach((queryKey, index) => {
+                        result[queryKey] = parseData(responseJson.queries.queryResults[index].rows, queryKey);
+                    });
+                }
+                else {
+                    result = {
+                        fields: responseJson?.queries?.queryResults[0]?.fields,
+                        ...responseJson.data,
+                    };
+                    responseJson.data.queryOrder.forEach((queryKey, index) => {
+                        result[queryKey] = parseData(responseJson.queries.queryResults[index].rows, queryKey);
+                    });
+                }
             }
             else {
-                result = {
-                    fields: responseJson?.queries?.queryResults[0]?.fields,
-                    ...responseJson.data,
-                    rows: responseJson?.queries?.queryResults[0]?.rows,
-                    compareRows: responseJson?.queries?.queryResults[1]?.rows,
-                };
+                if (responseJson.data?.data) {
+                    result = {
+                        fields: responseJson?.data.queries?.queryResults[0]?.fields,
+                        ...responseJson.data.data,
+                        rows: responseJson?.data.queries?.queryResults[0]?.rows,
+                        compareRows: responseJson?.data.queries?.queryResults[1]?.rows,
+                    };
+                }
+                else {
+                    result = {
+                        fields: responseJson?.queries?.queryResults[0]?.fields,
+                        ...responseJson.data,
+                        rows: responseJson?.queries?.queryResults[0]?.rows,
+                        compareRows: responseJson?.queries?.queryResults[1]?.rows,
+                    };
+                }
             }
             if (responseJson.data.columns &&
                 responseJson.data.fields &&

package/dist/esm/utils/dates.d.ts

@@ -7,4 +7,12 @@ export declare function convertComparisonRange(primaryRange: string, comparisonR
  * Returns whether the xAxisFormat is a date format.
  */
 export declare function isDateFormat(xAxisFormat: string): boolean;
+export declare function getComparisonInterval(comparisonRange: {
+    startDate: Date;
+    endDate: Date;
+}, dateBucket?: string): string | undefined;
+export declare function getDateBucketFromRange(dateRange: {
+    start: Date;
+    end: Date;
+}): "month" | "week" | "day" | "year";
 //# sourceMappingURL=dates.d.ts.map

package/dist/esm/utils/dates.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../src/utils/dates.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,eAAe,EAAE,MAAM,UAYxB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,WAY/C"}
+{"version":3,"file":"dates.d.ts","sourceRoot":"","sources":["../../../src/utils/dates.ts"],"names":[],"mappings":"AAGA;;;GAGG;AACH,wBAAgB,sBAAsB,CACpC,YAAY,EAAE,MAAM,EACpB,eAAe,EAAE,MAAM,UAYxB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,WAa/C;AAED,wBAAgB,qBAAqB,CACnC,eAAe,EAAE;IACf,SAAS,EAAE,IAAI,CAAC;IAChB,OAAO,EAAE,IAAI,CAAC;CACf,EACD,UAAU,CAAC,EAAE,MAAM,sBAepB;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE;IAAE,KAAK,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,IAAI,CAAA;CAAE,qCAW3E"}

package/dist/esm/utils/dates.js

@@ -1,3 +1,4 @@
+import { differenceInDays } from 'date-fns';
 import { COMPARISON_OPTIONS } from '../DateRangePicker/dateRangePickerUtils';
 /**
  * Converts the comparison range label to match the date filter range if the
@@ -23,6 +24,7 @@ export function convertComparisonRange(primaryRange, comparisonRange) {
 export function isDateFormat(xAxisFormat) {
     const DATE_FORMATS = [
         'yyyy',
+        'MMM_dd',
         'MMM_yyyy',
         'MMM_dd_yyyy',
         'hh_ap_pm',
@@ -33,3 +35,32 @@ export function isDateFormat(xAxisFormat) {
     const isDate = DATE_FORMATS.includes(xAxisFormat);
     return isDate;
 }
+export function getComparisonInterval(comparisonRange, dateBucket) {
+    const dayCount = differenceInDays(comparisonRange.endDate, comparisonRange.startDate);
+    if (!isNaN(dayCount)) {
+        if (dateBucket === 'month') {
+            return dayCount / 30 + ' month';
+        }
+        else if (dateBucket === 'year') {
+            return dayCount / 365 + ' year';
+        }
+        else {
+            return dayCount + ' day';
+        }
+    }
+}
+export function getDateBucketFromRange(dateRange) {
+    const difference = differenceInDays(dateRange.end, dateRange.start);
+    if (difference < 14) {
+        return 'day';
+    }
+    else if (difference < 60) {
+        return 'week';
+    }
+    else if (difference < 365 * 3) {
+        return 'month';
+    }
+    else {
+        return 'year';
+    }
+}

package/dist/esm/utils/filterProcessing.d.ts

@@ -1,2 +1,4 @@
 export declare function findAndProcessDateFilter(filters: any[]): any;
+export declare function processFilterFromBackend(filter: any, rows: any[]): any;
+export declare function updateFilter(filter: any, value?: any, comparison?: any): any;
 //# sourceMappingURL=filterProcessing.d.ts.map

package/dist/esm/utils/filterProcessing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filterProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/filterProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,CAoB5D"}
+{"version":3,"file":"filterProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/filterProcessing.ts"],"names":[],"mappings":"AAQA,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,CAoB5D;AAMD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,OA4BhE;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,GAAG,EACX,KAAK,GAAE,GAAU,EACjB,UAAU,GAAE,GAAU,OAuGvB"}

package/dist/esm/utils/filterProcessing.js

@@ -1,3 +1,4 @@
+import { COMPARISON_RANGE, PRIMARY_RANGE, defaultOptionsV2, getRangeFromPresetOptions, } from '../DateRangePicker/dateRangePickerUtils';
 export function findAndProcessDateFilter(filters) {
     let dateFilter = filters.find((filter) => filter.filterType === 'date_range');
     if (dateFilter) {
@@ -19,3 +20,128 @@ export function findAndProcessDateFilter(filters) {
 function isValidDate(date) {
     return !isNaN(Date.parse(date));
 }
+export function processFilterFromBackend(filter, rows) {
+    if (filter.filterType === 'date_range') {
+        return {
+            ...filter,
+            startDate: new Date(filter.startDate),
+            endDate: new Date(filter.endDate),
+            options: defaultOptionsV2,
+            comparisonRange: {
+                ...filter.comparisonRange,
+                value: filter.defaultComparisonRange,
+            },
+        };
+    }
+    if (filter.filterType === 'string') {
+        const options = rows.map((row) => row[filter.field]);
+        const distinctOptions = Array.from(new Set(options)).filter((value) => value !== undefined && value !== null);
+        return {
+            ...filter,
+            options: distinctOptions.map((option) => ({
+                label: option,
+                value: option,
+            })),
+        };
+    }
+    return filter;
+}
+export function updateFilter(filter, value = null, comparison = null) {
+    //for dateObjects only, since values are arrays for dateObjects
+    const { selectedValue: _, operator, ...filterWithoutSelectedValue } = filter; // _ is a throwaway variable
+    if (filter.filterType === 'string') {
+        let selectedValue = {};
+        if (value) {
+            if (filter.stringFilterType === 'multiselect') {
+                const parsedValue = JSON.parse(value);
+                if (parsedValue.length === 0) {
+                    selectedValue = { values: [] };
+                }
+                else {
+                    selectedValue = { values: parsedValue, operator: 'IN' };
+                }
+            }
+            else {
+                selectedValue = { selectedValue: value };
+            }
+        }
+        return {
+            ...filterWithoutSelectedValue,
+            ...selectedValue,
+            dashboardName: name,
+        };
+    }
+    if (filter.filterType === 'date' || filter.filterType === 'date_range') {
+        let presetsOptions = defaultOptionsV2;
+        if (filter.presetRanges) {
+            presetsOptions = filter.presetRanges.map((elem) => {
+                if (!elem.isStatic) {
+                    return {
+                        label: elem.label,
+                        value: elem.value,
+                        startDate: PRIMARY_RANGE[elem.value].start,
+                        endDate: PRIMARY_RANGE[elem.value].end,
+                    };
+                }
+                return {
+                    label: elem.label,
+                    value: elem.value,
+                    startDate: new Date(elem.startDate),
+                    endDate: new Date(elem.endDate),
+                };
+            });
+        }
+        if (comparison ||
+            (filter.comparison && filter.comparisonRange.value !== 'NO_COMPARISON')) {
+            let preset = '';
+            if (comparison) {
+                preset = filter.preset.label;
+            }
+            const key = comparison?.value || filter.comparisonRange.value;
+            let primaryRange = {
+                start: value ? value.startDate : filter.startDate,
+                end: value ? value.endDate : filter.endDate,
+            };
+            if (value && value.preset) {
+                preset = value.preset;
+                primaryRange = getRangeFromPresetOptions(value.preset, presetsOptions);
+            }
+            return {
+                startDate: primaryRange.start,
+                endDate: primaryRange.end,
+                filterType: 'date_range',
+                label: 'Date',
+                field: 'date_range',
+                preset: { label: preset },
+                options: filter.options,
+                comparison: true,
+                comparisonRange: {
+                    startDate: COMPARISON_RANGE[key](primaryRange)?.start,
+                    endDate: COMPARISON_RANGE[key](primaryRange)?.end,
+                    value: key,
+                },
+                dashboardName: name,
+            };
+        }
+        else {
+            const primaryRange = value && value.preset
+                ? getRangeFromPresetOptions(value.preset, presetsOptions)
+                : {
+                    start: value?.startDate || filter.startDate,
+                    end: value?.endDate || filter.endDate,
+                };
+            const preset = value?.preset ? value.preset : '';
+            return {
+                ...filter,
+                preset: { label: preset },
+                startDate: primaryRange.start,
+                endDate: primaryRange.end,
+                filterType: 'date_range',
+                field: 'date_range',
+                options: filter.options,
+                label: 'Date',
+                dashboardName: name,
+            };
+        }
+    }
+}

package/dist/esm/utils/logging.d.ts

@@ -0,0 +1,2 @@
+export declare function internalLog(message: string, ...optionalParams: any[]): void;
+//# sourceMappingURL=logging.d.ts.map

package/dist/esm/utils/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../../src/utils/logging.ts"],"names":[],"mappings":"AAAA,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE,QAKpE"}

package/dist/esm/utils/logging.js

@@ -0,0 +1,6 @@
+export function internalLog(message, ...optionalParams) {
+    if (process.env.QUILL_ENV === 'development') {
+        const completeMessage = `Quill: ${message}: ${optionalParams.join('\n')}`;
+        console.log(completeMessage);
+    }
+}

package/dist/esm/utils/pivotConstructor.d.ts

@@ -0,0 +1,6 @@
+import { Pivot } from '../internals/ReportBuilder/PivotModal';
+export declare function generatePivotWithSQL(pivot: Pivot, report: any, client: any, dateBucket?: string, dateFilter?: any, distinctStrings?: any): Promise<{
+    rows: any;
+    columns: any;
+} | undefined>;
+//# sourceMappingURL=pivotConstructor.d.ts.map

package/dist/esm/utils/pivotConstructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivotConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAiB,MAAM,uCAAuC,CAAC;AAK7E,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,GAAG,EACX,MAAM,EAAE,GAAG,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,GAAG,EAChB,eAAe,CAAC,EAAE,GAAG;;;eAkHtB"}

package/dist/esm/utils/pivotConstructor.js

@@ -0,0 +1,83 @@
+import { getDateString } from '../internals/ReportBuilder/PivotModal';
+import { getData } from './dataFetcher';
+import { getComparisonInterval } from './dates';
+import { generatePivotQuery } from './queryConstructor';
+export async function generatePivotWithSQL(pivot, report, client, dateBucket, dateFilter, distinctStrings) {
+    if (dateFilter && dateFilter.startDate) {
+        dateFilter.start = dateFilter.startDate;
+        dateFilter.end = dateFilter.endDate;
+        if (dateFilter.comparisonRange && dateFilter.comparisonRange.startDate) {
+            dateFilter.comparisonRange.start = dateFilter.comparisonRange.startDate;
+            dateFilter.comparisonRange.end = dateFilter.comparisonRange.endDate;
+        }
+    }
+    let comparisonInterval = undefined;
+    if (dateFilter && dateFilter.comparisonRange) {
+        comparisonInterval = getComparisonInterval({
+            startDate: dateFilter.comparisonRange.start,
+            endDate: dateFilter.comparisonRange.end,
+        }, dateBucket);
+    }
+    if (pivot.rowField && !pivot.rowFieldType) {
+        const rowColumn = report.columns.find((column) => column.field === pivot.rowField);
+        pivot.rowFieldType = rowColumn.format;
+    }
+    const sqlQuery = generatePivotQuery(pivot, report.itemQuery, report.rows, dateBucket, comparisonInterval, distinctStrings);
+    if (sqlQuery && report.rows.length > 0) {
+        const hostedBody = {
+            metadata: {
+                preQueries: [sqlQuery],
+                task: 'query',
+                orgId: client.customerId || '*',
+                clientId: client.publicKey,
+                databaseType: client?.databaseType,
+                getCustomFields: false,
+                runQueryConfig: {
+                    overridePost: true,
+                    convertDatatypes: true,
+                },
+            },
+        };
+        const cloudBody = { ...hostedBody };
+        const resp = await getData(client, 'query', 'same-origin', hostedBody, cloudBody);
+        // With our current design we have to remove the second row field but leave the first for comparison purposes.
+        const rows = resp.queryResults[0].rows;
+        const columns = resp.queryResults[0].fields
+            .map((field) => ({
+            field: field.name,
+            label: field.name.replace('comparison_', 'comparison '),
+        }))
+            .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0);
+        if (pivot.rowField && !['string', 'varchar'].includes(pivot.rowFieldType)) {
+            rows.forEach((row) => {
+                row[pivot.rowField] = getDateString(row[pivot.rowField], undefined, dateBucket);
+            });
+            // add a row for each date in the range that doesn't have a value
+            if (pivot.rowField &&
+                !['string', 'varchar'].includes(pivot.rowFieldType) &&
+                dateFilter) {
+                const dateSet = new Set(rows.map((row) => row[pivot.rowField]));
+                // create a loop that will go through each formatted date and add a row if it doesn't exist going to the current date
+                for (let date = dateFilter.start ?? dateFilter.startDate; date <= dateFilter.end; date = new Date(date.getTime() + 24 * 60 * 60 * 1000)) {
+                    const formattedDate = getDateString(date.toDateString(), undefined, dateBucket);
+                    if (!dateSet.has(formattedDate)) {
+                        const newRow = {};
+                        newRow[pivot.rowField] = formattedDate;
+                        rows.push(newRow);
+                        dateSet.add(formattedDate);
+                    }
+                    // order the rows by the date field
+                    rows.sort((a, b) => {
+                        return new Date(a[pivot.rowField]) < new Date(b[pivot.rowField])
+                            ? -1
+                            : 1;
+                    });
+                }
+            }
+        }
+        return {
+            rows: rows,
+            columns: columns,
+        };
+    }
+}

package/dist/esm/utils/queryConstructor.d.ts

@@ -1,4 +1,5 @@
 import { Pivot } from '../internals/ReportBuilder/PivotModal';
 export declare function generateDistinctQuery(stringFields: string[], query: string): string;
-export declare function generatePivotQuery(pivot: Pivot, itemQueries: string[], rows: any[], dateBucket?: string, comparisonInterval?: string): string | undefined;
+export declare function generateMinMaxRangeQueries(columnFields: string[], query: string, databaseType: string): string;
+export declare function generatePivotQuery(pivot: Pivot, itemQueries: string[], rows: any[], dateBucket?: string, comparisonInterval?: string, distinctStrings?: string[]): string | undefined;
 //# sourceMappingURL=queryConstructor.d.ts.map

package/dist/esm/utils/queryConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAe9D,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAQ1E;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,GAAG,EAAE,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,kBAAkB,CAAC,EAAE,MAAM,GAC1B,MAAM,GAAG,SAAS,CAiBpB"}
+{"version":3,"file":"queryConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAe9D,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAQ1E;AAED,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAcrB;AAED,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,KAAK,EACZ,WAAW,EAAE,MAAM,EAAE,EACrB,IAAI,EAAE,GAAG,EAAE,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,kBAAkB,CAAC,EAAE,MAAM,EAC3B,eAAe,CAAC,EAAE,MAAM,EAAE,GACzB,MAAM,GAAG,SAAS,CAuBpB"}