@quillsql/react 2.12.21 → 2.12.23

package/dist/esm/utils/dashboard.js

@@ -1,6 +1,9 @@
 import { valueFormatter } from './valueFormatter';
-import { generatePivotTable, generatePivotTableYAxis, } from '../internals/ReportBuilder/PivotModal';
+import { generatePivotTable, generatePivotTableYAxis, getDateRange, getDateString, } from '../internals/ReportBuilder/PivotModal';
 import { snakeAndCamelCaseToTitleCase } from './textProcessing';
+import { generatePivotQuery } from './queryConstructor';
+import { getData } from './dataFetcher';
+import { differenceInDays } from 'date-fns';
 const defaultDashboardItem = {
     id: '',
     name: '',
@@ -28,7 +31,7 @@ const defaultDashboardItem = {
  * interface to build amazing dashboards on top of.
  * @param item
  */
-export function cleanDashboardItem(item, dashboardFilters) {
+export async function cleanDashboardItem(item, dashboardFilters, client, dateBucket) {
     if (!item)
         return defaultDashboardItem;
     if (!item.rows)
@@ -37,7 +40,7 @@ export function cleanDashboardItem(item, dashboardFilters) {
             id: item._id,
             name: item.name,
         };
-    const pivotTable = getPivotTable(item, dashboardFilters);
+    const pivotTable = await getPivotTable(item, dashboardFilters, client, dateBucket);
     const { primaryAggregation, comparisonAggregation, aggregationPercentChange, } = getAggragations(pivotTable, item);
     return {
         id: item._id,
@@ -105,12 +108,117 @@ function formatAggragation(item, value) {
 /**
  * Extract and transform the data from itemInfo.
  */
-function getPivotTable(report, dashboardFilters) {
+async function getPivotTable(report, dashboardFilters, client, dateBucketInitial) {
     if (!report)
         return undefined;
-    const dateFilter = Object.values(dashboardFilters ?? {}).find((filter) => filter.filterType == 'date_range');
+    let dateFilter = Object.values(dashboardFilters ?? {}).find((filter) => filter.filterType === 'date_range' || filter.opterator === 'BETWEEN');
+    if (dateFilter?.opterator === 'BETWEEN') {
+        dateFilter.startDate = dateFilter.value[0];
+        dateFilter.endDate = dateFilter.value[1];
+    }
     const pivot = report?.pivot;
     const data = report || {};
+    if (client && client.databaseType.toLowerCase() === 'postgresql') {
+        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';
+                }
+            }
+            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';
+                    }
+                }
+            }
+            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,
+                };
+            }
+        }
+        catch (e) { }
+    }
     return pivot && data.rows
         ? generatePivotTable(pivot, JSON.parse(JSON.stringify(data.rows)), // deep copy
         dateFilter?.startDate && dateFilter?.endDate

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

@@ -1 +1 @@
-{"version":3,"file":"errorProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/errorProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,GAAG,QAO/C"}
+{"version":3,"file":"errorProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/errorProcessing.ts"],"names":[],"mappings":"AAAA,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,GAAG,QAI/C"}

package/dist/esm/utils/errorProcessing.js

@@ -2,7 +2,4 @@ export function processFilterErrorList(resp) {
     if (!resp || !resp.filterErrorList || !Array.isArray(resp.filterErrorList)) {
         return;
     }
-    resp.filterErrorList.forEach((filterError) => {
-        console.error(filterError);
-    });
 }

package/dist/esm/utils/merge.js

@@ -1,5 +1,5 @@
 export function mergeComparisonRange(resp) {
-    if (resp.chartType === "table")
+    if (resp.chartType === 'table')
         return;
     mergeForwards(resp);
     // mergeBackwards(resp); // uncomment to switch back and forth

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

@@ -1 +1 @@
-{"version":3,"file":"pivotProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotProcessing.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAC9D,OAAO,EAAU,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG3D,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,EAAE,GACxB,MAAM,CAsCR;AAmED,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,WAgBxC;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,cAAc,EAAE,EACzB,YAAY,EAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE;;;;EAsCvC;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,eAAe,EAAE;IACf,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC;CAClB,GACA,KAAK,CAqCP"}
+{"version":3,"file":"pivotProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotProcessing.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,KAAK,EAAE,MAAM,uCAAuC,CAAC;AAC9D,OAAO,EAAU,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAG3D,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,cAAc,EAAE,GACxB,MAAM,CAsCR;AAkBD,wBAAgB,YAAY,CAAC,KAAK,EAAE,KAAK,WAgBxC;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,cAAc,EAAE,EACzB,YAAY,EAAE;IAAE,CAAC,KAAK,EAAE,MAAM,GAAG,GAAG,CAAA;CAAE;;;;EAsCvC;AAED,wBAAgB,UAAU,CACxB,KAAK,EAAE,KAAK,EACZ,eAAe,EAAE;IACf,SAAS,EAAE,GAAG,CAAC;IACf,YAAY,EAAE,GAAG,CAAC;IAClB,WAAW,EAAE,GAAG,CAAC;CAClB,GACA,KAAK,CAqCP"}

package/dist/esm/utils/pivotProcessing.js

@@ -30,48 +30,6 @@ export function pivotToSql(pivot, query, columns) {
     }
     return query;
 }
-function createPivotSqlQuery(rowField, columnField, valueField, aggregationType, query) {
-    // const sqlAggregationType = convertToSqlAggregationType(aggregationType);
-    return `with query_table as (${query}),
-  distinct_column_fields as (
-    select distinct
-      ${columnField}
-    from
-      query_table
-  ),
-  case_when_query as (
-    select
-      string_agg(
-        concat(
-          '${aggregationType}(CASE WHEN ${columnField} = ''',
-          replace(${columnField}, '''', ''''''),
-          ''' THEN ${valueField} ELSE 0 END) AS ',
-          concat(concat('"', replace(${columnField}, ' ', '_')), '"')
-        ),
-        ',
-    '
-      ) as sql_part
-    from
-      distinct_column_fields
-  ),
-  joined_queries as (
-    select
-      concat(
-        'WITH query_table as (${query}) SELECT ${rowField}, ',
-        sql_part,
-        ' 
-    FROM query_table 
-    GROUP BY ${rowField} 
-    ORDER BY ${rowField}'
-      ) as query
-    from
-    case_when_query
-  )
-select
-  query
-from
-  joined_queries;`;
-}
 function generateTwoDPivotQuery(pivot, query, columns) {
     const caseWhens = columns.map((column) => {
         return `${pivot.aggregationType}(

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

@@ -1,2 +1,4 @@
+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;
 //# 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,wBAAgB,qBAAqB,CAAC,YAAY,EAAE,MAAM,EAAE,EAAE,KAAK,EAAE,MAAM,UAQ1E"}
+{"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"}

package/dist/esm/utils/queryConstructor.js

@@ -1,3 +1,16 @@
+import { isValidPivot } from './pivotProcessing';
+function processAggType(aggType) {
+    if (aggType === 'count')
+        return 'SUM';
+    return aggType?.toLowerCase() === 'average' ? 'AVG' : aggType?.toLowerCase();
+}
+function processValueField(aggType, valueField) {
+    if (aggType === 'min' || aggType === 'max')
+        return `"${valueField}" ELSE null`;
+    if (aggType === 'count')
+        return `1 ELSE 0`;
+    return valueField ? `"${valueField}" ELSE 0` : `1 ELSE 0`;
+}
 export function generateDistinctQuery(stringFields, query) {
     const distinctQueries = stringFields.map((field) => {
         return `SELECT '${field}' AS field, ARRAY_AGG(DISTINCT ${field}) AS string_values FROM querytable`;
@@ -5,3 +18,112 @@ export function generateDistinctQuery(stringFields, query) {
     const distinctQuery = distinctQueries.join(' UNION ALL ');
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
 }
+export function generatePivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval) {
+    if (!isValidPivot(pivot)) {
+        return undefined;
+    }
+    if (!pivot.rowField) {
+        return undefined;
+    }
+    if (pivot.columnField) {
+        return create2DPivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval);
+    }
+    return create1DPivotQuery(pivot, itemQueries, dateBucket, comparisonInterval);
+}
+function create2DPivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval) {
+    if (!pivot || !pivot.columnField) {
+        return undefined;
+    }
+    // @ts-ignore
+    const columnValues = rows.map((row) => row[pivot.columnField]);
+    const distinctColumnValues = Array.from(new Set(columnValues)).filter((value) => value !== undefined && value !== null);
+    if (distinctColumnValues.length === 0) {
+        return undefined;
+    }
+    if (pivot.rowFieldType === 'string') {
+        return create2DStringPivotQuery(pivot, itemQueries, distinctColumnValues);
+    }
+    return create2DDatePivotQuery(pivot, itemQueries, distinctColumnValues, dateBucket, comparisonInterval);
+}
+function create2DStringPivotQuery(pivot, itemQueries, distinctColumnValues) {
+    const caseWhens = distinctColumnValues.map((column) => {
+        return `${processAggType(pivot.aggregationType)}(CASE WHEN "${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "${column}"`;
+    });
+    const caseWhensCompare = distinctColumnValues.map((column) => {
+        return `${processAggType(pivot.aggregationType)}(CASE WHEN "${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "comparison_${column}"`;
+    });
+    const compareCTE = itemQueries[1]
+        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
+        : '';
+    const compareCaseWhenCTE = itemQueries[1]
+        ? `, quill_ct_cw as (SELECT "${pivot.rowField}" as "comparison_${pivot.rowField}", ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY ${pivot.rowField})`
+        : '';
+    const joinQuery = itemQueries[1]
+        ? `JOIN quill_ct_cw ct ON ct."comparison_${pivot.rowField}" = qt."${pivot.rowField}"`
+        : '';
+    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
+  quill_qt_cw AS (SELECT ${pivot.rowField}, ${caseWhens.join(', ')} FROM quill_qt GROUP BY ${pivot.rowField})
+  ${compareCTE} ${compareCaseWhenCTE}
+  SELECT * FROM quill_qt_cw qt 
+  ${joinQuery}`;
+}
+function create2DDatePivotQuery(pivot, itemQueries, distinctColumnValues, dateBucket = 'month', comparisonInterval) {
+    const caseWhens = distinctColumnValues.map((column) => {
+        return `${processAggType(pivot.aggregationType)}(CASE WHEN qt."${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "${column}"`;
+    });
+    const caseWhensCompare = distinctColumnValues.map((column) => {
+        return `${processAggType(pivot.aggregationType)}(CASE WHEN "${pivot.columnField}" = '${column.replaceAll("'", "''")}' THEN ${processValueField(pivot.aggregationType, pivot.valueField)} END) AS "comparison_${column}"`;
+    });
+    const compareCTE = itemQueries[1] && comparisonInterval
+        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
+        : '';
+    const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
+        ? `, quill_ct_cw as (SELECT date_trunc('${dateBucket}', ${pivot.rowField}) as comparison_${pivot.rowField}, ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))`
+        : '';
+    const joinQuery = itemQueries[1] && comparisonInterval
+        ? `LEFT JOIN quill_ct_cw ct ON qt."${pivot.rowField}" = date_trunc('${dateBucket}', (ct."comparison_${pivot.rowField}" + INTERVAL '${comparisonInterval} day'))`
+        : '';
+    return `WITH quill_query_table AS (${itemQueries[0]?.replaceAll(';', '')}),
+  quill_qt_agg as (SELECT date_trunc('${dateBucket}', ${pivot.rowField}) as ${pivot.rowField}, ${caseWhens.join(', ')} FROM quill_query_table qt GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))
+  ${compareCTE} ${compareCaseWhenCTE}
+  SELECT * FROM quill_qt_agg qt 
+  ${joinQuery} ORDER BY qt."${pivot.rowField}"`;
+}
+function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', comparisonInterval) {
+    if (pivot.rowFieldType === 'string') {
+        return create1DStringPivotQuery(pivot, itemQueries);
+    }
+    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, comparisonInterval);
+}
+function create1DStringPivotQuery(pivot, itemQueries) {
+    const compareCTE = itemQueries[1]
+        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
+        : '';
+    const compareCaseWhenCTE = itemQueries[1]
+        ? `, quill_ct_cw as (SELECT ${pivot.rowField} as "comparison_${pivot.rowField}", ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as comparison_${pivot.valueField} FROM quill_ct GROUP BY ${pivot.rowField})`
+        : '';
+    const joinQuery = itemQueries[1]
+        ? `JOIN quill_ct_cw ct ON ct."comparison_${pivot.rowField}" = qt."${pivot.rowField}"`
+        : '';
+    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
+  quill_qt_cw AS (SELECT ${pivot.rowField}, ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as ${pivot.valueField} FROM quill_qt GROUP BY ${pivot.rowField})
+  ${compareCTE} ${compareCaseWhenCTE}
+  SELECT * FROM quill_qt_cw qt 
+  ${joinQuery}`;
+}
+function create1DDatePivotQuery(pivot, itemQueries, dateBucket = 'month', comparisonInterval) {
+    const compareCTE = itemQueries[1] && comparisonInterval
+        ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
+        : '';
+    const compareCaseWhenCTE = itemQueries[1] && comparisonInterval
+        ? `, quill_ct_cw as (SELECT date_trunc('${dateBucket}', ${pivot.rowField}) as comparison_${pivot.rowField}, ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as comparison_${pivot.valueField} FROM quill_ct GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))`
+        : '';
+    const joinQuery = itemQueries[1] && comparisonInterval
+        ? `LEFT JOIN quill_ct_cw ct ON qt."${pivot.rowField}" = date_trunc('${dateBucket}', (ct."comparison_${pivot.rowField}" + INTERVAL '${comparisonInterval}'))`
+        : '';
+    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
+  quill_qt_agg AS (SELECT date_trunc('${dateBucket}', ${pivot.rowField}) as ${pivot.rowField}, ${processAggType(pivot.aggregationType)}(${pivot.valueField}) as ${pivot.valueField} FROM quill_qt GROUP BY date_trunc('${dateBucket}', ${pivot.rowField}))
+  ${compareCTE} ${compareCaseWhenCTE}
+  SELECT * FROM quill_qt_agg qt 
+  ${joinQuery} ORDER BY qt."${pivot.rowField}"`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quillsql/react",
-  "version": "2.12.21",
+  "version": "2.12.23",
   "exports": {
     ".": {
       "import": "./dist/esm/index.js",