@quillsql/react 2.12.28 → 2.12.30

package/dist/esm/utils/queryConstructor.js

@@ -1,19 +1,71 @@
 import { isValidPivot } from './pivotProcessing';
-function processAggType(aggType) {
-    if (aggType === 'count')
+function processSingleQuotes(value, databaseType) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        return value.replaceAll("'", "''");
+    }
+    return value.replaceAll("'", "\\'");
+}
+function processAggType(aggType, hasColumnField = false) {
+    if (aggType === 'count' && hasColumnField)
         return 'SUM';
     return aggType?.toLowerCase() === 'average' ? 'AVG' : aggType?.toLowerCase();
 }
-function processValueField(aggType, valueField) {
-    if (aggType === 'min' || aggType === 'max')
-        return `"${valueField}" ELSE null`;
+function replaceBigQuerySpecialCharacters(column) {
+    return column.replaceAll('/', 'quill_forward_slash');
+}
+export function processColumnReference(column, databaseType) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        const columnParts = column.split('.');
+        if (columnParts.length > 1) {
+            return `"${columnParts[0]}"."${columnParts[1]}"`;
+        }
+        return `"${column}"`;
+    }
+    const columnParts = column.split('.');
+    if (columnParts.length > 1) {
+        return `\`${columnParts[0]}\`.\`${columnParts[1]}\``;
+    }
+    return `\`${replaceBigQuerySpecialCharacters(column)}\``;
+}
+function processInterval(interval, rowField, databaseType) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        return `(${processColumnReference(rowField, databaseType)} + INTERVAL '${interval}')`;
+    }
+    return `TIMESTAMP_ADD(${processColumnReference(rowField, databaseType)}, INTERVAL ${interval} )`;
+}
+function processDateTrunc(dateBucket, rowField, databaseType, comparisonInterval) {
+    if (['postgresql', 'snowflake'].includes(databaseType.toLowerCase())) {
+        const date = comparisonInterval
+            ? processInterval(comparisonInterval, rowField, databaseType)
+            : processColumnReference(rowField, databaseType);
+        return `date_trunc('${dateBucket}', ${date})`;
+    }
+    const date = comparisonInterval
+        ? processInterval(comparisonInterval, rowField, databaseType)
+        : processColumnReference(rowField, databaseType);
+    return `TIMESTAMP_TRUNC(${date}, ${dateBucket})`;
+}
+function processValueField(aggType, databaseType, valueField) {
+    if (aggType === 'min' ||
+        aggType === 'max' ||
+        aggType?.toLowerCase() === 'average')
+        return `${processColumnReference(valueField, databaseType)} ELSE null`;
     if (aggType === 'count')
         return `1 ELSE 0`;
-    return valueField ? `"${valueField}" ELSE 0` : `1 ELSE 0`;
+    return valueField
+        ? `${processColumnReference(valueField, databaseType)} ELSE 0`
+        : `1 ELSE 0`;
+}
+export function generateCountQuery(fields, query, databaseType) {
+    const countQuery = fields.map((field) => {
+        return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, COUNT(DISTINCT ${processColumnReference(field, databaseType)}) AS ${processColumnReference('count', databaseType)} FROM querytable`;
+    });
+    return (`WITH querytable AS (${query.replace(';', '')}) ` +
+        countQuery.join(' UNION ALL '));
 }
-export function generateDistinctQuery(stringFields, query) {
+export function generateDistinctQuery(stringFields, query, databaseType) {
     const distinctQueries = stringFields.map((field) => {
-        return `SELECT '${field}' AS field, ARRAY_AGG(DISTINCT ${field}) AS string_values FROM querytable`;
+        return `SELECT '${field}' AS ${processColumnReference('field', databaseType)}, ARRAY_AGG(DISTINCT ${field}) AS ${processColumnReference('string_values', databaseType)} FROM querytable`;
     });
     const distinctQuery = distinctQueries.join(' UNION ALL ');
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
@@ -28,135 +80,143 @@ export function generateMinMaxRangeQueries(columnFields, query, databaseType) {
     const distinctQuery = distinctQueries.join(' UNION ALL ');
     return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
 }
-export function generatePivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval, distinctStrings) {
+export function generatePivotQuery(pivot, itemQueries, databaseType, comparisonInterval, distinctStrings, dateBucket) {
     if (!isValidPivot(pivot)) {
         return undefined;
     }
     if (pivot.columnField) {
-        return create2DPivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval, distinctStrings);
+        return create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, distinctStrings);
     }
     if (pivot.rowField) {
-        return create1DPivotQuery(pivot, itemQueries, dateBucket, comparisonInterval);
+        return create1DPivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
     }
-    return createAggregationValuePivot(pivot, itemQueries);
+    return createAggregationValuePivot(pivot, itemQueries, databaseType);
 }
-function create2DPivotQuery(pivot, itemQueries, rows, dateBucket, comparisonInterval, distinctStrings) {
+function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, columnFieldValues) {
     if (!pivot || !pivot.columnField) {
         return undefined;
     }
-    // @ts-ignore
-    const columnValues = rows.map((row) => row[pivot.columnField]);
-    const distinctColumnValues = distinctStrings
-        ? distinctStrings
-        : Array.from(new Set(columnValues)).filter((value) => value !== undefined && value !== null);
-    if (distinctColumnValues.length === 0) {
+    if (!columnFieldValues) {
         return undefined;
     }
     if (['string', 'varchar'].includes(pivot.rowFieldType) ||
         !pivot.rowFieldType) {
-        return create2DStringPivotQuery(pivot, itemQueries, distinctColumnValues);
+        return create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType);
     }
-    return create2DDatePivotQuery(pivot, itemQueries, distinctColumnValues, dateBucket, comparisonInterval);
+    return create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, 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}"`;
+function create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType) {
+    if (!pivot.columnField || !pivot.rowField) {
+        return undefined;
+    }
+    const rowField = pivot.rowField;
+    const valueField = pivot.valueField;
+    const columnField = pivot.columnField;
+    const caseWhens = columnFieldValues.map((column) => {
+        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField)} END) AS ${processColumnReference(column, databaseType)}`;
     });
-    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 caseWhensCompare = columnFieldValues.map((column) => {
+        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, valueField)} END) AS ${processColumnReference(`comparison_${column}`, databaseType)}`;
     });
     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})`
+        ? `, quill_ct_cw as (SELECT ${processColumnReference(rowField, databaseType)} as ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY ${processColumnReference(rowField, databaseType)})`
         : '';
     const joinQuery = itemQueries[1]
-        ? `JOIN quill_ct_cw ct ON ct."comparison_${pivot.rowField}" = qt."${pivot.rowField}"`
+        ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(rowField, databaseType)}`
         : '';
     return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  quill_qt_cw AS (SELECT ${pivot.rowField}, ${caseWhens.join(', ')} FROM quill_qt GROUP BY ${pivot.rowField})
+  quill_qt_cw AS (SELECT ${processColumnReference(rowField, databaseType)}, ${caseWhens.join(', ')} FROM quill_qt GROUP BY ${processColumnReference(rowField, databaseType)})
   ${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}"`;
+function create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket = 'month', comparisonInterval) {
+    if (!pivot.columnField || !pivot.rowField) {
+        return undefined;
+    }
+    const rowField = pivot.rowField;
+    const columnField = pivot.columnField;
+    const caseWhens = columnFieldValues.map((column) => {
+        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN qt.${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, pivot.valueField)} END) AS ${processColumnReference(column, databaseType)}`;
     });
-    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 caseWhensCompare = columnFieldValues.map((column) => {
+        return `${processAggType(pivot.aggregationType, true)}(CASE WHEN ${processColumnReference(columnField, databaseType)} = '${processSingleQuotes(column, databaseType)}' THEN ${processValueField(pivot.aggregationType, databaseType, pivot.valueField)} END) AS ${processColumnReference(`comparison_${column}`, databaseType)}`;
     });
     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}))`
+        ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${caseWhensCompare.join(', ')} FROM quill_ct GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})`
         : '';
     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'))`
+        ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${processColumnReference(`${rowField}`, databaseType)} = ${processDateTrunc(dateBucket, `ct.comparison_${rowField}`, databaseType, comparisonInterval)}`
         : '';
     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}))
+  quill_qt_agg as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(rowField, databaseType)}, ${caseWhens.join(', ')} FROM quill_query_table qt GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})
   ${compareCTE} ${compareCaseWhenCTE}
   SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt."${pivot.rowField}"`;
+  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}`;
 }
-function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', comparisonInterval) {
+function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
     if (['string', 'varchar'].includes(pivot.rowFieldType) ||
         !pivot.rowFieldType) {
-        return create1DStringPivotQuery(pivot, itemQueries);
+        return create1DStringPivotQuery(pivot, itemQueries, databaseType);
     }
-    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, comparisonInterval);
+    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
 }
-function create1DStringPivotQuery(pivot, itemQueries) {
+function create1DStringPivotQuery(pivot, itemQueries, databaseType) {
+    const rowField = pivot.rowField;
+    const valueField = pivot.valueField;
     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})`
+        ? `, quill_ct_cw as (SELECT ${processColumnReference(`${rowField}`, databaseType)} as  ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`comparison_${valueField || 'count'}`, databaseType)} FROM quill_ct GROUP BY ${processColumnReference(`${rowField}`, databaseType)})`
         : '';
     const joinQuery = itemQueries[1]
-        ? `JOIN quill_ct_cw ct ON ct."comparison_${pivot.rowField}" = qt."${pivot.rowField}"`
+        ? `JOIN quill_ct_cw ct ON ct.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(`${rowField}`, databaseType)}`
         : '';
     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})
+  quill_qt_cw AS (SELECT ${processColumnReference(`${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`${valueField}` || 'count', databaseType)} FROM quill_qt GROUP BY ${processColumnReference(`${rowField}`, databaseType)})
   ${compareCTE} ${compareCaseWhenCTE}
-  SELECT * FROM quill_qt_cw qt 
+  SELECT * FROM quill_qt_cw qt
   ${joinQuery}`;
 }
-function create1DDatePivotQuery(pivot, itemQueries, dateBucket = 'month', comparisonInterval) {
+function create1DDatePivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
+    const rowField = pivot.rowField;
+    const valueField = pivot.valueField;
     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}))`
+        ? `, quill_ct_cw as (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`comparison_${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`comparison_${valueField || 'count'}`, databaseType)} FROM quill_ct GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})`
         : '';
     const joinQuery = itemQueries[1] && comparisonInterval
-        ? `LEFT JOIN quill_ct_cw ct ON qt."${pivot.rowField}" = date_trunc('${dateBucket}', (ct."comparison_${pivot.rowField}" + INTERVAL '${comparisonInterval}'))`
+        ? `LEFT JOIN quill_ct_cw ${processColumnReference(`ct`, databaseType)} ON qt.${processColumnReference(`${rowField}`, databaseType)} = ${processDateTrunc(dateBucket, `ct.comparison_${rowField}`, databaseType, 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}))
+  quill_qt_agg AS (SELECT ${processDateTrunc(dateBucket, rowField, databaseType)} as ${processColumnReference(`${rowField}`, databaseType)}, ${processAggType(pivot.aggregationType)}(${processColumnReference(`${valueField || rowField}`, databaseType)}) as ${processColumnReference(`${valueField || 'count'}`, databaseType)} FROM quill_qt GROUP BY ${processDateTrunc(dateBucket, rowField, databaseType)})
   ${compareCTE} ${compareCaseWhenCTE}
   SELECT * FROM quill_qt_agg qt 
-  ${joinQuery} ORDER BY qt."${pivot.rowField}"`;
+  ${joinQuery} ORDER BY qt.${processColumnReference(`${rowField}`, databaseType)}`;
 }
-function createAggregationValuePivot(pivot, itemQueries) {
-    let aggregationType = processAggType(pivot.aggregationType);
-    if (pivot.aggregationType === 'count') {
-        aggregationType = 'COUNT';
-    }
+function createAggregationValuePivot(pivot, itemQueries, databaseType) {
+    const valueField = pivot.valueField;
+    const aggregationType = processAggType(pivot.aggregationType);
     if (!pivot.valueField)
         return undefined;
     const compareCTE = itemQueries[1]
         ? `, quill_ct as (${itemQueries[1]?.replaceAll(';', '')})`
         : '';
     const compareAggregation = itemQueries[1]
-        ? `, quill_ct_cw as (SELECT ${aggregationType}(${pivot.valueField}) as comparison_${pivot.valueField} FROM quill_ct)`
+        ? `, quill_ct_cw as (SELECT ${aggregationType}(${processColumnReference(`${valueField}`, databaseType)}) as ${processColumnReference(`comparison_${valueField}`, databaseType)} FROM quill_ct)`
         : '';
     const joinQuery = itemQueries[1] ? `CROSS JOIN quill_ct_cw ct` : '';
     return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-      quill_qt_agg AS (SELECT ${aggregationType}(${pivot.valueField}) as ${pivot.valueField} FROM quill_qt)
+      quill_qt_agg AS (SELECT ${aggregationType}(${processColumnReference(`${valueField}`, databaseType)}) as ${processColumnReference(`${valueField}`, databaseType)} FROM quill_qt)
       ${compareCTE} ${compareAggregation}
       SELECT * FROM quill_qt_agg qt 
       ${joinQuery}`;

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=queryConstructor.uspec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"queryConstructor.uspec.d.ts","sourceRoot":"","sources":["../../../src/utils/queryConstructor.uspec.ts"],"names":[],"mappings":""}

package/dist/esm/utils/queryConstructor.uspec.js

@@ -0,0 +1,223 @@
+import { generatePivotQuery } from './queryConstructor';
+const removeExtraSpacesAndNewLines = (str) => {
+    return str.replace(/\s+/g, ' ').trim();
+};
+describe('queryConstructor', () => {
+    const default2DPivot = {
+        rowField: 'merchant',
+        rowFieldType: 'string',
+        columnField: 'user',
+        valueField: 'amount',
+        aggregationType: 'sum',
+    };
+    const nonComparisonQuery = ['select * from transactions'];
+    const comparisonQueries = [
+        `select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'`,
+        `select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01'`,
+    ];
+    describe('bigquery - generatePivotQuery', () => {
+        const databaseType = 'bigquery';
+        it('should return a 2d string pivot query', async () => {
+            const query = generatePivotQuery(default2DPivot, nonComparisonQuery, databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_cw AS (SELECT \`merchant\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` 
+      FROM quill_qt GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, nonComparisonQuery, databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS (select * from transactions), 
+      quill_qt_agg as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(CASE WHEN qt.\`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN qt.\`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` FROM quill_query_table qt 
+      GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) 
+      SELECT * FROM quill_qt_agg qt ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+                columnField: undefined,
+            }, nonComparisonQuery, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_agg AS (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(\`amount\`) as \`amount\` FROM quill_qt GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) 
+      SELECT * FROM quill_qt_agg qt ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d string pivot query', async () => {
+            const query = generatePivotQuery({ ...default2DPivot, columnField: undefined }, nonComparisonQuery, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_cw AS (SELECT \`merchant\`, sum(\`amount\`) as \`amount\` 
+      FROM quill_qt GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a value aggregation query', async () => {
+            const query = generatePivotQuery(
+            // @ts-ignore
+            { ...default2DPivot, columnField: undefined, rowField: undefined }, nonComparisonQuery, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_agg AS (SELECT sum(\`amount\`) as \`amount\` FROM quill_qt) SELECT * FROM quill_qt_agg qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d string pivot query with comparison', async () => {
+            const query = generatePivotQuery(default2DPivot, comparisonQueries, databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_qt AS 
+      (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_cw AS (SELECT \`merchant\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` FROM quill_qt GROUP BY \`merchant\`) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT \`merchant\` as \`comparison_merchant\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`comparison_value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`comparison_value2\` FROM quill_ct GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt JOIN quill_ct_cw ct ON ct.\`comparison_merchant\` = qt.\`merchant\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query with comparison', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, comparisonQueries, databaseType, '90', ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(CASE WHEN qt.\`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`value1\`, 
+      sum(CASE WHEN qt.\`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`value2\` 
+      FROM quill_query_table qt GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`comparison_created_at\`, 
+      sum(CASE WHEN \`user\` = 'value1' THEN \`amount\` ELSE 0 END) AS \`comparison_value1\`, 
+      sum(CASE WHEN \`user\` = 'value2' THEN \`amount\` ELSE 0 END) AS \`comparison_value2\` 
+      FROM quill_ct GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) 
+      SELECT * FROM quill_qt_agg qt 
+      LEFT JOIN quill_ct_cw \`ct\` ON qt.\`created_at\` = TIMESTAMP_TRUNC(TIMESTAMP_ADD(\`ct\`.\`comparison_created_at\`, INTERVAL 90 ), month) 
+      ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d date pivot query with comparison', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+                columnField: undefined,
+            }, comparisonQueries, databaseType, '3 month');
+            const expected = `WITH quill_qt AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg AS (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`created_at\`, 
+      sum(\`amount\`) as \`amount\` FROM quill_qt GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month)) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT TIMESTAMP_TRUNC(\`created_at\`, month) as \`comparison_created_at\`, 
+      sum(\`amount\`) as \`comparison_amount\` FROM quill_ct GROUP BY TIMESTAMP_TRUNC(\`created_at\`, month))
+      SELECT * FROM quill_qt_agg qt LEFT JOIN quill_ct_cw \`ct\` ON qt.\`created_at\` = TIMESTAMP_TRUNC(TIMESTAMP_ADD(\`ct\`.\`comparison_created_at\`, INTERVAL 3 month ), month) 
+      ORDER BY qt.\`created_at\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d string pivot query with comparison', async () => {
+            const query = generatePivotQuery({ ...default2DPivot, columnField: undefined }, comparisonQueries, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_cw AS (SELECT \`merchant\`, sum(\`amount\`) as \`amount\` FROM quill_qt GROUP BY \`merchant\`) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT \`merchant\` as \`comparison_merchant\`, sum(\`amount\`) as \`comparison_amount\` FROM quill_ct GROUP BY \`merchant\`) 
+      SELECT * FROM quill_qt_cw qt JOIN quill_ct_cw ct ON ct.\`comparison_merchant\` = qt.\`merchant\``;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a value aggregation query', async () => {
+            const query = generatePivotQuery(
+            // @ts-ignore
+            { ...default2DPivot, columnField: undefined, rowField: undefined }, comparisonQueries, databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg AS (SELECT sum(\`amount\`) as \`amount\` FROM quill_qt) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT sum(\`amount\`) as \`comparison_amount\` FROM quill_ct) 
+      SELECT * FROM quill_qt_agg qt CROSS JOIN quill_ct_cw ct`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+    });
+    describe('postgresql - generatePivotQuery', () => {
+        const databaseType = 'postgresql';
+        it('should return a 2d string pivot query', async () => {
+            const query = generatePivotQuery(default2DPivot, ['select * from transactions'], databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_qt AS (select * from transactions),
+      quill_qt_cw AS 
+      (SELECT "merchant", sum(CASE WHEN "user" = 'value1' THEN "amount" ELSE 0 END) AS "value1", 
+      sum(CASE WHEN "user" = 'value2' THEN "amount" ELSE 0 END) AS "value2" FROM quill_qt GROUP BY "merchant")
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, ['select * from transactions'], databaseType, undefined, ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS (select * from transactions),
+      quill_qt_agg as (SELECT date_trunc('month', "created_at") as "created_at", 
+      sum(CASE WHEN qt."user" = 'value1' THEN "amount" ELSE 0 END) AS "value1", 
+      sum(CASE WHEN qt."user" = 'value2' THEN "amount" ELSE 0 END) AS "value2" 
+      FROM quill_query_table qt 
+      GROUP BY date_trunc('month', "created_at"))
+      SELECT * FROM quill_qt_agg qt ORDER BY qt."created_at"`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d date pivot query', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+                columnField: undefined,
+            }, ['select * from transactions'], databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions),
+      quill_qt_agg AS (SELECT date_trunc('month', "created_at") as "created_at", sum("amount") as "amount"
+      FROM quill_qt 
+      GROUP BY date_trunc('month', "created_at"))
+      SELECT * FROM quill_qt_agg qt ORDER BY qt."created_at"`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 1d string pivot query', async () => {
+            const query = generatePivotQuery({ ...default2DPivot, columnField: undefined }, ['select * from transactions'], databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions),
+      quill_qt_cw AS (SELECT "merchant", sum("amount") as "amount"
+      FROM quill_qt 
+      GROUP BY "merchant")
+      SELECT * FROM quill_qt_cw qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a value aggregation query', async () => {
+            const query = generatePivotQuery(
+            // @ts-ignore
+            { ...default2DPivot, columnField: undefined, rowField: undefined }, ['select * from transactions'], databaseType, undefined);
+            const expected = `WITH quill_qt AS (select * from transactions), 
+      quill_qt_agg AS (SELECT sum("amount") as "amount" FROM quill_qt) SELECT * FROM quill_qt_agg qt`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+        it('should return a 2d date pivot query with comparison', async () => {
+            const query = generatePivotQuery({
+                ...default2DPivot,
+                rowFieldType: 'MMM_DD_YYY',
+                rowField: 'created_at',
+            }, comparisonQueries, databaseType, '90 DAY', ['value1', 'value2']);
+            const expected = `WITH quill_query_table AS 
+      (select * from transactions where created_at BETWEEN '2024-06-01' AND '2024-07-01'), 
+      quill_qt_agg as (SELECT date_trunc('month', "created_at") as "created_at", 
+      sum(CASE WHEN qt."user" = 'value1' THEN "amount" ELSE 0 END) AS "value1", 
+      sum(CASE WHEN qt."user" = 'value2' THEN "amount" ELSE 0 END) AS "value2" FROM quill_query_table qt GROUP BY date_trunc('month', "created_at")) , 
+      quill_ct as (select * from transactions where created_at BETWEEN '2024-05-01' AND '2024-06-01') , 
+      quill_ct_cw as (SELECT date_trunc('month', "created_at") as "comparison_created_at", 
+      sum(CASE WHEN "user" = 'value1' THEN "amount" ELSE 0 END) AS "comparison_value1", 
+      sum(CASE WHEN "user" = 'value2' THEN "amount" ELSE 0 END) AS "comparison_value2" FROM quill_ct GROUP BY date_trunc('month', "created_at")) 
+      SELECT * FROM quill_qt_agg qt LEFT JOIN quill_ct_cw "ct" ON qt."created_at" = date_trunc('month', ("ct"."comparison_created_at" + INTERVAL '90 DAY')) 
+      ORDER BY qt."created_at"`;
+            expect(removeExtraSpacesAndNewLines(query)).toEqual(removeExtraSpacesAndNewLines(expected));
+        });
+    });
+});

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

@@ -0,0 +1,7 @@
+import { AdditionalProcessing } from './tableProcessing';
+export declare function fetchReport(reportId: string, client: any, useReportTask?: boolean, filters?: any[], additionalProcessing?: AdditionalProcessing, dateBucket?: string, customFields?: any): Promise<{
+    report: any;
+    error?: string;
+}>;
+export declare const formatRowsFromReport: (report: any) => any;
+//# sourceMappingURL=report.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/utils/report.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,GAAG,EACX,aAAa,UAAO,EACpB,OAAO,GAAE,GAAG,EAAO,EACnB,oBAAoB,CAAC,EAAE,oBAAoB,EAC3C,UAAU,CAAC,EAAE,MAAM,EACnB,YAAY,CAAC,EAAE,GAAG,GACjB,OAAO,CAAC;IAAE,MAAM,EAAE,GAAG,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAsF1C;AAED,eAAO,MAAM,oBAAoB,WAAY,GAAG,QAe/C,CAAC"}

package/dist/esm/utils/report.ispec.d.ts

@@ -0,0 +1,2 @@
+export declare function getClient(publicKey: string): Promise<any>;
+//# sourceMappingURL=report.ispec.d.ts.map

package/dist/esm/utils/report.ispec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.ispec.d.ts","sourceRoot":"","sources":["../../../src/utils/report.ispec.ts"],"names":[],"mappings":"AAIA,wBAAsB,SAAS,CAAC,SAAS,EAAE,MAAM,gBAqBhD"}

package/dist/esm/utils/report.ispec.js

@@ -0,0 +1,46 @@
+import { fetchReport } from './report';
+const QUERY_ENDPOINT = 'https://quill-344421.uc.r.appspot.com/cloud';
+export async function getClient(publicKey) {
+    const response = await fetch(QUERY_ENDPOINT, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            metadata: {
+                clientId: publicKey,
+                publicKey,
+                task: 'client',
+            },
+        }),
+    });
+    const result = await response.json();
+    return {
+        ...result.data.client,
+        publicKey: result.data.client._id,
+        customerId: result.data.client.adminCustomerId,
+        queryEndpoint: QUERY_ENDPOINT,
+    };
+}
+describe('report', () => {
+    let client = undefined;
+    beforeAll(async () => {
+        const publicKey = '65d65b57cdd8ae70a5648d9c';
+        client = await getClient(publicKey);
+    });
+    describe('fetchReport', () => {
+        it('should fetch report', async () => {
+            const reportId = '669167e392533d0c68bfe002';
+            const report = await fetchReport(reportId, client);
+            expect(report.report).toBeDefined();
+            expect(report.report.pivot).toBeDefined();
+            expect(report.report.rows).toBeDefined();
+        });
+        it('should fetch the broken report and return an error', async () => {
+            const reportId = '66a3d7ef28ca14000c51f498';
+            const report = await fetchReport(reportId, client);
+            expect(report.report).toBeDefined();
+            expect(report.report.error).toBeDefined();
+        });
+    });
+});