@quillsql/react 2.12.27 → 2.12.29

package/dist/cjs/utils/dataFetcher.js

@@ -1,13 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getDataFromCloud = exports.getData = void 0;
+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]?.row_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
-async function getData(client, cloudQueryEndpoint, noCred, hostedRequestBody, cloudRequestBody, method = 'POST') {
+async function getData(client, cloudQueryEndpoint, noCred, hostedRequestBody, cloudRequestBody, method = 'POST', queryParam) {
+    if (!client) {
+        return null;
+    }
     try {
         if (client.queryEndpoint) {
             // self hosted
-            const resp = await fetch(client.queryEndpoint, {
+            const processedParam = queryParam ? `?${queryParam}` : '';
+            const resp = await fetch(`${client.queryEndpoint}${processedParam}`, {
                 method: 'POST',
                 headers: {
                     ...client.queryHeaders,
@@ -21,21 +44,46 @@ async function getData(client, cloudQueryEndpoint, noCred, hostedRequestBody, cl
                 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' ||
+                    hostedRequestBody.metadata.useUpdatedDataGathering)) {
+                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/cjs/utils/dates.d.ts

@@ -7,4 +7,13 @@ 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";
+export declare function parseDateByDatabaseType(date: any, databaseType: string): Date;
 //# sourceMappingURL=dates.d.ts.map

package/dist/cjs/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;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,QAMtE"}

package/dist/cjs/utils/dates.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDateFormat = exports.convertComparisonRange = void 0;
+exports.parseDateByDatabaseType = exports.getDateBucketFromRange = exports.getComparisonInterval = exports.isDateFormat = exports.convertComparisonRange = void 0;
+const date_fns_1 = require("date-fns");
 const dateRangePickerUtils_1 = require("../DateRangePicker/dateRangePickerUtils");
 /**
  * Converts the comparison range label to match the date filter range if the
@@ -27,6 +28,7 @@ exports.convertComparisonRange = convertComparisonRange;
 function isDateFormat(xAxisFormat) {
     const DATE_FORMATS = [
         'yyyy',
+        'MMM_dd',
         'MMM_yyyy',
         'MMM_dd_yyyy',
         'hh_ap_pm',
@@ -38,3 +40,43 @@ function isDateFormat(xAxisFormat) {
     return isDate;
 }
 exports.isDateFormat = isDateFormat;
+function getComparisonInterval(comparisonRange, dateBucket) {
+    const dayCount = (0, date_fns_1.differenceInDays)(comparisonRange.endDate, comparisonRange.startDate);
+    if (!isNaN(dayCount)) {
+        if (dateBucket === 'month') {
+            return Math.floor(dayCount / 30) + ' month';
+        }
+        else if (dateBucket === 'year') {
+            return Math.floor(dayCount / 365) + ' year';
+        }
+        else {
+            return dayCount + ' day';
+        }
+    }
+}
+exports.getComparisonInterval = getComparisonInterval;
+function getDateBucketFromRange(dateRange) {
+    const difference = (0, date_fns_1.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';
+    }
+}
+exports.getDateBucketFromRange = getDateBucketFromRange;
+function parseDateByDatabaseType(date, databaseType) {
+    if (databaseType.toLowerCase() === 'bigquery') {
+        return new Date(date.value);
+    }
+    else {
+        return new Date(date);
+    }
+}
+exports.parseDateByDatabaseType = parseDateByDatabaseType;

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

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

package/dist/cjs/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/cjs/utils/logging.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.internalLog = void 0;
+function internalLog(message, ...optionalParams) {
+    if (process.env.QUILL_ENV === 'development') {
+        const completeMessage = `Quill: ${message}: ${optionalParams.join('\n')}`;
+        console.log(completeMessage);
+    }
+}
+exports.internalLog = internalLog;

package/dist/cjs/utils/monacoAutocomplete.d.ts

@@ -0,0 +1,20 @@
+import { Monaco } from '@monaco-editor/react';
+import { Range } from 'monaco-editor';
+interface CompletionItem {
+    label: string;
+    kind: number;
+    insertText: string;
+    insertTextRules: number;
+    range: any;
+    detail?: string;
+}
+export declare function generateSuggestionsBySchema(schema: any[], monaco: Monaco, range: Range, databaseType: string): CompletionItem[];
+export declare function generateSuggestionsByDatasource(monaco: Monaco, range: Range, databaseType: string): {
+    label: string;
+    kind: import("monaco-editor").languages.CompletionItemKind;
+    insertText: string;
+    insertTextRules: import("monaco-editor").languages.CompletionItemInsertTextRule;
+    range: Range;
+}[];
+export {};
+//# sourceMappingURL=monacoAutocomplete.d.ts.map

package/dist/cjs/utils/monacoAutocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"monacoAutocomplete.d.ts","sourceRoot":"","sources":["../../../src/utils/monacoAutocomplete.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAC9C,OAAO,EAAY,KAAK,EAAE,MAAM,eAAe,CAAC;AAGhD,UAAU,cAAc;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,GAAG,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AA4HD,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,GAAG,EAAE,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM,GACnB,cAAc,EAAE,CA4BlB;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,KAAK,EACZ,YAAY,EAAE,MAAM;;;;;;IAMrB"}

package/dist/cjs/utils/monacoAutocomplete.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSuggestionsByDatasource = exports.generateSuggestionsBySchema = void 0;
+const queryConstructor_1 = require("./queryConstructor");
+const GENERIC_DATASOURCE_SUGGESTIONS = (monaco, range) => {
+    return [
+        {
+            label: 'SELECT',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'SELECT',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'FROM',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'FROM',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'JOIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'JOIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'LEFT JOIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'LEFT JOIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'INNER JOIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'INNER JOIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'MAX',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'MAX',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'MIN',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'MIN',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'ON',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'ON',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'WHERE',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'WHERE',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'LIMIT',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'LIMIT',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'GROUP BY',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'GROUP BY',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'ORDER BY',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'ORDER BY',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+    ];
+};
+const POSTGRES_DATASOURCE_SUGGESTIONS = (monaco, range) => {
+    return [
+        {
+            label: 'SELECT',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'SELECT',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+        {
+            label: 'FROM',
+            kind: monaco.languages.CompletionItemKind.Keyword,
+            insertText: 'FROM',
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        },
+    ];
+};
+function generateSuggestionsBySchema(schema, monaco, range, databaseType) {
+    console.log(databaseType);
+    const suggestions = [];
+    schema.forEach((table) => {
+        const curSuggestion = {
+            label: table.name,
+            kind: monaco.languages.CompletionItemKind.Field,
+            insertText: `${(0, queryConstructor_1.processColumnReference)(table.name, databaseType).replaceAll('`', '')}`,
+            insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+            range,
+        };
+        suggestions.push(curSuggestion);
+        table.columns.forEach((column) => {
+            const insertText = `${(0, queryConstructor_1.processColumnReference)(column.name, databaseType).replaceAll('`', '')}`;
+            const curSuggestion = {
+                label: column.name,
+                kind: monaco.languages.CompletionItemKind.Field,
+                insertText,
+                detail: table.name,
+                insertTextRules: monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet,
+                range,
+            };
+            suggestions.push(curSuggestion);
+        });
+    }, []);
+    return suggestions;
+}
+exports.generateSuggestionsBySchema = generateSuggestionsBySchema;
+function generateSuggestionsByDatasource(monaco, range, databaseType) {
+    return [
+        ...POSTGRES_DATASOURCE_SUGGESTIONS(monaco, range),
+        ...GENERIC_DATASOURCE_SUGGESTIONS(monaco, range),
+    ];
+}
+exports.generateSuggestionsByDatasource = generateSuggestionsByDatasource;

package/dist/cjs/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/cjs/utils/pivotConstructor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivotConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAiB,MAAM,uCAAuC,CAAC;AAO7E,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;;;eAsKtB"}

package/dist/cjs/utils/pivotConstructor.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePivotWithSQL = void 0;
+const ChartBuilder_1 = require("../ChartBuilder");
+const ast_1 = require("../components/ReportBuilder/ast");
+const PivotModal_1 = require("../internals/ReportBuilder/PivotModal");
+const columnProcessing_1 = require("./columnProcessing");
+const dataFetcher_1 = require("./dataFetcher");
+const dates_1 = require("./dates");
+const queryConstructor_1 = require("./queryConstructor");
+const textProcessing_1 = require("./textProcessing");
+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 = (0, dates_1.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;
+    }
+    let distinctStringValues = undefined;
+    if (!distinctStrings && report.rows && pivot.columnField) {
+        const distinctValues = Array.from(new Set(report.rows.map((row) => row[pivot.columnField])));
+        distinctStringValues = distinctValues.map((value) => value.toString());
+    }
+    const sqlQuery = (0, queryConstructor_1.generatePivotQuery)(pivot, report.itemQuery, client.databaseType, comparisonInterval, distinctStrings ? distinctStrings : distinctStringValues, dateBucket);
+    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 (0, dataFetcher_1.getData)(client, 'query', 'same-origin', hostedBody, cloudBody, 'POST', 'fetch-pivot');
+        // 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;
+        if (pivot.columnField && client.databaseType.toLowerCase() === 'bigquery') {
+            rows.forEach((row) => {
+                Object.keys(row).forEach((key) => {
+                    const processedKey = (0, columnProcessing_1.processColumnName)(key);
+                    if (processedKey !== key) {
+                        row[processedKey] = row[key];
+                        delete row[key];
+                    }
+                });
+            });
+        }
+        const columns = resp.queryResults[0].fields
+            .map((field) => ({
+            field: (0, columnProcessing_1.processColumnName)(field.name),
+            label: (0, textProcessing_1.snakeCaseToTitleCase)((0, columnProcessing_1.processColumnName)(field.name.replace('comparison_', 'comparison '))),
+        }))
+            .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0)
+            .sort((a, b) => {
+            if (a.field === pivot.rowField) {
+                return -1;
+            }
+            if (b.field === pivot.rowField) {
+                return 1;
+            }
+            return 0;
+        });
+        if (pivot.rowField && !['string', 'varchar'].includes(pivot.rowFieldType)) {
+            rows.forEach((row) => {
+                row[pivot.rowField] = (0, PivotModal_1.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 = (0, PivotModal_1.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;
+                    });
+                }
+            }
+        }
+        if (pivot.sort) {
+            rows.sort((a, b) => {
+                if (pivot.sortDirection === 'ASC') {
+                    if (ChartBuilder_1.dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                        // @ts-ignore
+                        return new Date(a[pivot.sortField]) - new Date(b[pivot.sortField]);
+                    }
+                    else if ((0, ast_1.isNumericColumnType)(pivot.sortFieldType)) {
+                        return a[pivot.sortField] - b[pivot.sortField];
+                    }
+                    return a[pivot.sortField].localeCompare(b[pivot.sortField]);
+                }
+                else {
+                    if (ChartBuilder_1.dateFormatOptions.includes(pivot.sortFieldType ?? '')) {
+                        // @ts-ignore
+                        return new Date(b[pivot.sortField]) - new Date(a[pivot.sortField]);
+                    }
+                    else if ((0, ast_1.isNumericColumnType)(pivot.sortFieldType)) {
+                        return b[pivot.sortField] - a[pivot.sortField];
+                    }
+                    return b[pivot.sortField].localeCompare(a[pivot.sortField]);
+                }
+            });
+        }
+        return {
+            rows: rows,
+            columns: columns,
+        };
+    }
+}
+exports.generatePivotWithSQL = generatePivotWithSQL;

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

@@ -1,4 +1,7 @@
 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 processColumnReference(column: string, databaseType: string): string;
+export declare function generateCountQuery(fields: string[], query: string, databaseType: string): string;
+export declare function generateDistinctQuery(stringFields: string[], query: string, databaseType: string): string;
+export declare function generateMinMaxRangeQueries(columnFields: string[], query: string, databaseType: string): string;
+export declare function generatePivotQuery(pivot: Pivot, itemQueries: string[], databaseType: string, comparisonInterval?: string, distinctStrings?: string[], dateBucket?: string): string | undefined;
 //# sourceMappingURL=queryConstructor.d.ts.map

package/dist/cjs/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;AAmB9D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,UAa1E;AA4CD,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EAAE,EAChB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UAUrB;AAED,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,MAAM,EAAE,EACtB,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,MAAM,UASrB;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,YAAY,EAAE,MAAM,EACpB,kBAAkB,CAAC,EAAE,MAAM,EAC3B,eAAe,CAAC,EAAE,MAAM,EAAE,EAC1B,UAAU,CAAC,EAAE,MAAM,GAClB,MAAM,GAAG,SAAS,CAwBpB"}