@quillsql/react 2.12.30 → 2.12.31

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

@@ -1 +1 @@
-{"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"}
+{"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;AAED,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,UAoBzD"}

package/dist/esm/utils/dates.js

@@ -72,3 +72,24 @@ export function parseDateByDatabaseType(date, databaseType) {
         return new Date(date);
     }
 }
+export function getDateFormatFromBucket(dateBucket) {
+    let format = 'MMM_yyyy';
+    switch (dateBucket) {
+        case 'day':
+            format = 'MMM_dd';
+            break;
+        case 'week':
+            format = 'MMM_dd-MMM_dd';
+            break;
+        case 'month':
+            format = 'MMM_yyyy';
+            break;
+        case 'year':
+            format = 'yyyy';
+            break;
+        default:
+            format = 'MMM_yyyy';
+            break;
+    }
+    return format;
+}

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

@@ -1,4 +1,10 @@
+import { Filter } from '../models/Filter';
 export declare function findAndProcessDateFilter(filters: any[]): any;
-export declare function processFilterFromBackend(filter: any, rows: any[]): any;
+export declare function processFilterFromBackend(filter: any): any;
 export declare function updateFilter(filter: any, value?: any, comparison?: any): any;
+export declare const getType: (t: string) => "string" | "boolean" | "numeric" | "date";
+/**
+ * Returns a sentence to describe a Filter
+ */
+export declare function filterSentence(filter: Filter): string;
 //# 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":"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"}
+{"version":3,"file":"filterProcessing.d.ts","sourceRoot":"","sources":["../../../src/utils/filterProcessing.ts"],"names":[],"mappings":"AAOA,OAAO,EAAgB,MAAM,EAAe,MAAM,kBAAkB,CAAC;AAGrE,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,GAAG,CAoB5D;AAMD,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,GAAG,OAkBnD;AAED,wBAAgB,YAAY,CAC1B,MAAM,EAAE,GAAG,EACX,KAAK,GAAE,GAAU,EACjB,UAAU,GAAE,GAAU,OAuGvB;AAGD,eAAO,MAAM,OAAO,MAAO,MAAM,8CAwDhC,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAwBrD"}

package/dist/esm/utils/filterProcessing.js

@@ -1,4 +1,6 @@
 import { COMPARISON_RANGE, PRIMARY_RANGE, defaultOptionsV2, getRangeFromPresetOptions, } from '../DateRangePicker/dateRangePickerUtils';
+import { DateOperator, FilterNames } from '../models/Filter';
+import { snakeAndCamelCaseToTitleCase } from './textProcessing';
 export function findAndProcessDateFilter(filters) {
     let dateFilter = filters.find((filter) => filter.filterType === 'date_range');
     if (dateFilter) {
@@ -20,7 +22,7 @@ export function findAndProcessDateFilter(filters) {
 function isValidDate(date) {
     return !isNaN(Date.parse(date));
 }
-export function processFilterFromBackend(filter, rows) {
+export function processFilterFromBackend(filter) {
     if (filter.filterType === 'date_range') {
         return {
             ...filter,
@@ -29,20 +31,12 @@ export function processFilterFromBackend(filter, rows) {
             options: defaultOptionsV2,
             comparisonRange: {
                 ...filter.comparisonRange,
-                value: filter.defaultComparisonRange,
+                value: 'PREV_PERIOD',
             },
         };
     }
     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;
     }
     return filter;
 }
@@ -51,7 +45,7 @@ export function updateFilter(filter, value = null, comparison = null) {
     const { ...filterWithoutSelectedValue } = filter;
     if (filter.filterType === 'string') {
         let selectedValue = {};
-        if (value) {
+        if (value || value === '') {
             if (filter.stringFilterType === 'multiselect') {
                 const parsedValue = value;
                 if (parsedValue.length === 0) {
@@ -145,3 +139,94 @@ export function updateFilter(filter, value = null, comparison = null) {
         }
     }
 }
+// Function to translate field type to "string", "numeric", or "date"
+export const getType = (t) => {
+    // strip any size numbers at the end
+    // TODO: 'max' data types, e.g. varchar(max)
+    t = t.replace(/\d+$/, '');
+    switch (t) {
+        case 'string':
+        case 'char':
+        case 'varchar':
+        case 'nchar':
+        case 'nvarchar':
+        case 'ntext':
+        case 'binary':
+        case 'varbinary':
+        case 'tinyblob':
+        case 'tinytext':
+        case 'blob':
+        case 'mediumtext':
+        case 'mediumblob':
+        case 'longtext':
+        case 'longblob':
+        case 'text':
+            return 'string';
+        case 'numeric':
+        case 'bit':
+        case 'tinybit':
+        case 'smallint':
+        case 'mediumint':
+        case 'int':
+        case 'tinyint':
+        case 'integer':
+        case 'bigint':
+        case 'float':
+        case 'double':
+        case 'double precision':
+        case 'decimal':
+        case 'dec':
+        case 'smallmoney':
+        case 'money':
+        case 'real':
+            return 'numeric';
+        case 'date':
+        case 'datetime':
+        case 'datetime2':
+        case 'smalldatetime':
+        case 'datetimeoffset':
+        case 'timestamp':
+        case 'timestamptz':
+        case 'time':
+        case 'year':
+            return 'date';
+        case 'bool':
+        case 'boolean':
+            return 'boolean';
+        default:
+            return 'string';
+    }
+};
+/**
+ * Returns a sentence to describe a Filter
+ */
+export function filterSentence(filter) {
+    let value = '';
+    if (filter.name == FilterNames.NullFilter) {
+        return `${snakeAndCamelCaseToTitleCase(filter.field)} ${filter.operator}`;
+    }
+    else if (filter.value === null || filter.value === undefined) {
+        return 'Error: filter missing value';
+    }
+    if (typeof filter.value === 'string' || typeof filter.value === 'number') {
+        value = filter.value.toString();
+    }
+    else if (filter.value === false || filter.value === true) {
+        value = filter.value.toString();
+    }
+    else if ('unit' in filter.value) {
+        if (filter.operator === DateOperator.InTheCurrent) {
+            value = `${filter.value.unit}`;
+        }
+        else {
+            value = `${filter.value.value} ${filter.value.unit}${filter.value.value === 1 ? '' : 's'}`;
+        }
+    }
+    else if ('startDate' in filter.value) {
+        value = `from ${filter.value.startDate}`;
+    }
+    else if (filter.value.length > 0) {
+        value = filter.value.join(', ');
+    }
+    return `${snakeAndCamelCaseToTitleCase(filter.field)} ${filter.operator}${filter.operator === 'is' || filter.operator === 'is not' ? ' one of' : ''} ${value}`;
+}

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

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

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

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

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

@@ -0,0 +1,245 @@
+import { BoolOperator, DateOperator, FieldTypes, FilterNames, NullOperator, NumberOperator, StringOperator, } from '../models/Filter';
+import { filterSentence } from './filterProcessing';
+describe('filterSentence', () => {
+    it('should handle null filters', () => {
+        const isNullFilter = {
+            name: FilterNames.NullFilter,
+            operator: NullOperator.IsNull,
+            field: 'field',
+            type: FieldTypes.Null,
+            value: null,
+        };
+        const isNotNullFilter = {
+            name: FilterNames.NullFilter,
+            operator: NullOperator.IsNotNull,
+            field: 'field',
+            type: FieldTypes.Null,
+            value: null,
+        };
+        expect(filterSentence(isNullFilter)).toEqual('Field is null');
+        expect(filterSentence(isNotNullFilter)).toEqual('Field is not null');
+    });
+    it('should handle string filters', () => {
+        const stringExactlyFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.IsExactly,
+            field: 'field',
+            type: FieldTypes.String,
+            value: 'this',
+        };
+        const stringNotExactlyFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.IsNotExactly,
+            field: 'field',
+            type: FieldTypes.String,
+            value: 'this',
+        };
+        const stringContainsFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.Contains,
+            field: 'field',
+            type: FieldTypes.String,
+            value: 'this',
+        };
+        expect(filterSentence(stringExactlyFilter)).toEqual('Field is exactly this');
+        expect(filterSentence(stringNotExactlyFilter)).toEqual('Field is not exactly this');
+        expect(filterSentence(stringContainsFilter)).toEqual('Field contains this');
+    });
+    it('should handle number filters', () => {
+        const numberEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.EqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberNotEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.NotEqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberGreaterThanFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.GreaterThan,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberLessThanFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.LessThan,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberGreaterThanOrEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.GreaterThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        const numberLessThanOrEqualToFilter = {
+            name: FilterNames.NumericFilter,
+            operator: NumberOperator.LessThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Numeric,
+            value: 0,
+        };
+        expect(filterSentence(numberEqualToFilter)).toEqual('Field equal to 0');
+        expect(filterSentence(numberNotEqualToFilter)).toEqual('Field not equal to 0');
+        expect(filterSentence(numberGreaterThanFilter)).toEqual('Field greater than 0');
+        expect(filterSentence(numberLessThanFilter)).toEqual('Field less than 0');
+        expect(filterSentence(numberGreaterThanOrEqualToFilter)).toEqual('Field greater than or equal to 0');
+        expect(filterSentence(numberLessThanOrEqualToFilter)).toEqual('Field less than or equal to 0');
+    });
+    it('should handle boolean filters', () => {
+        const booleanEqualToFilter = {
+            name: FilterNames.BooleanFilter,
+            operator: BoolOperator.EqualTo,
+            field: 'field',
+            type: FieldTypes.Boolean,
+            value: true,
+        };
+        const booleanNotEqualToFilter = {
+            name: FilterNames.BooleanFilter,
+            operator: BoolOperator.NotEqualTo,
+            field: 'field',
+            type: FieldTypes.Boolean,
+            value: true,
+        };
+        expect(filterSentence(booleanEqualToFilter)).toEqual('Field equal to true');
+        expect(filterSentence(booleanNotEqualToFilter)).toEqual('Field not equal to true');
+    });
+    it('should handle date filters', () => {
+        const dateInTheLastFilter = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InTheLast,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 10, unit: 'day' },
+        };
+        const dateInTheLastFilterSingular = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InTheLast,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 1, unit: 'day' },
+        };
+        const dateInTheCurrentFilter = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InTheCurrent,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 1, unit: 'day' },
+        };
+        const dateInThePreviousFilter = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InThePrevious,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 10, unit: 'day' },
+        };
+        const dateInThePreviousFilterSingular = {
+            name: FilterNames.DateFilter,
+            operator: DateOperator.InThePrevious,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { value: 1, unit: 'day' },
+        };
+        expect(filterSentence(dateInTheLastFilter)).toEqual('Field in the last 10 days');
+        expect(filterSentence(dateInTheLastFilterSingular)).toEqual('Field in the last 1 day');
+        expect(filterSentence(dateInTheCurrentFilter)).toEqual('Field in the current day');
+        expect(filterSentence(dateInThePreviousFilter)).toEqual('Field in the previous 10 days');
+        expect(filterSentence(dateInThePreviousFilterSingular)).toEqual('Field in the previous 1 day');
+    });
+    it('should handle date comparison filters', () => {
+        const dateEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.EqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateNotEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.NotEqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateGreaterThanFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.GreaterThan,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateLessThanFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.LessThan,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateGreaterThanOrEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.GreaterThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        const dateLessThanOrEqualToFilter = {
+            name: FilterNames.DateComparisonFilter,
+            operator: DateOperator.LessThanOrEqualTo,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: '2021-01-01',
+        };
+        expect(filterSentence(dateEqualToFilter)).toEqual('Field equal to 2021-01-01');
+        expect(filterSentence(dateNotEqualToFilter)).toEqual('Field not equal to 2021-01-01');
+        expect(filterSentence(dateGreaterThanFilter)).toEqual('Field greater than 2021-01-01');
+        expect(filterSentence(dateLessThanFilter)).toEqual('Field less than 2021-01-01');
+        expect(filterSentence(dateGreaterThanOrEqualToFilter)).toEqual('Field greater than or equal to 2021-01-01');
+        expect(filterSentence(dateLessThanOrEqualToFilter)).toEqual('Field less than or equal to 2021-01-01');
+    });
+    it('should handle custom date filters', () => {
+        const dateCustomFilter = {
+            name: FilterNames.DateCustomFilter,
+            operator: DateOperator.Custom,
+            field: 'field',
+            type: FieldTypes.Date,
+            value: { startDate: '2021-01-01', endDate: '2021-12-31' },
+        };
+        expect(filterSentence(dateCustomFilter)).toEqual('Field custom from 2021-01-01');
+    });
+    it('should handle string in filters', () => {
+        const stringIsFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.Is,
+            field: 'field',
+            type: FieldTypes.String,
+            value: ['this', 'that'],
+        };
+        const stringIsNotFilter = {
+            name: FilterNames.StringFilter,
+            operator: StringOperator.IsNot,
+            field: 'field',
+            type: FieldTypes.String,
+            value: ['this', 'that'],
+        };
+        expect(filterSentence(stringIsFilter)).toEqual('Field is one of this, that');
+        expect(filterSentence(stringIsNotFilter)).toEqual('Field is not one of this, that');
+    });
+    it('should throw an error for invalid filters', () => {
+        const invalidFilter = {
+            name: 'filter',
+            operator: '=',
+            field: 'field',
+            type: 'string',
+        };
+        expect(filterSentence(invalidFilter)).toEqual('Error: filter missing value');
+    });
+});

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

@@ -1,5 +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<{
+import { QuillReportInternal } from '../models/Report';
+export declare function generatePivotWithSQL(pivot: Pivot, report: QuillReportInternal, client: any, dateBucket?: string, dateFilter?: any, distinctStrings?: any): Promise<{
     rows: any;
     columns: any;
 } | undefined>;

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

@@ -1 +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;;;eAkLtB"}
+{"version":3,"file":"pivotConstructor.d.ts","sourceRoot":"","sources":["../../../src/utils/pivotConstructor.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAiB,MAAM,uCAAuC,CAAC;AAC7E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAOvD,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,mBAAmB,EAC3B,MAAM,EAAE,GAAG,EACX,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,GAAG,EAChB,eAAe,CAAC,EAAE,GAAG;;;eAyLtB"}

package/dist/esm/utils/pivotConstructor.js

@@ -24,13 +24,16 @@ export async function generatePivotWithSQL(pivot, report, client, dateBucket, da
     }
     if (pivot.rowField && !pivot.rowFieldType) {
         const rowColumn = report.columns.find((column) => column.field === pivot.rowField);
-        pivot.rowFieldType = rowColumn.format;
+        pivot.rowFieldType = rowColumn?.format || 'string';
     }
     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());
     }
+    if (!report.itemQuery) {
+        return undefined;
+    }
     const sqlQuery = generatePivotQuery(pivot, report.itemQuery, client.databaseType, comparisonInterval, distinctStrings ? distinctStrings : distinctStringValues, dateBucket);
     if (sqlQuery && report.rows.length > 0) {
         const hostedBody = {
@@ -67,6 +70,9 @@ export async function generatePivotWithSQL(pivot, report, client, dateBucket, da
             .map((field) => ({
             field: processColumnName(field.name),
             label: snakeCaseToTitleCase(processColumnName(field.name.replace('comparison_', 'comparison '))),
+            format: field.name === pivot.rowField
+                ? 'string'
+                : pivot.valueFieldType ?? 'whole_number',
         }))
             .filter((field, index) => field.field !== 'comparison_' + pivot.rowField || index === 0)
             .sort((a, b) => {

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

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

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

@@ -1 +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"}
+{"version":3,"file":"report.d.ts","sourceRoot":"","sources":["../../../src/utils/report.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AASpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,eAAO,MAAM,YAAY,EAAE,WAkB1B,CAAC;AAEF,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,mBAAmB,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CA2F1D;AAED,eAAO,MAAM,oBAAoB,WAAY,GAAG,QAkB/C,CAAC;AAEF,wBAAgB,6BAA6B,CAC3C,MAAM,EAAE,mBAAmB,GAC1B,WAAW,CAsDb"}

package/dist/esm/utils/report.js

@@ -1,10 +1,31 @@
+import { getYAxisFields } from './columnProcessing';
 import { cleanDashboardItem } from './dashboard';
 import { getData } from './dataFetcher';
 import { DataLoadError } from './error';
 import { processFilterErrorList } from './errorProcessing';
 import { internalLog } from './logging';
 import { mergeComparisonRange } from './merge';
+import { isValidPivot } from './pivotProcessing';
 import { quillFormat } from './valueFormatter';
+export const EMPTY_REPORT = {
+    id: '',
+    name: '',
+    dashboardName: '',
+    rows: [],
+    columns: [],
+    chartType: '',
+    dateField: null,
+    pivot: null,
+    xAxisLabel: '',
+    xAxisField: '',
+    xAxisFormat: 'string',
+    yAxisFields: [],
+    order: -1,
+    compareRows: [],
+    filtersApplied: [],
+    queryString: '',
+    rowCount: 0,
+};
 export async function fetchReport(reportId, client, useReportTask = true, filters = [], additionalProcessing, dateBucket, customFields) {
     let reportInfo = undefined;
     let errorMessage = undefined;
@@ -53,12 +74,18 @@ export async function fetchReport(reportId, client, useReportTask = true, filter
                 errorMessage = error;
             }
             else {
-                reportInfo = {
-                    ...error.data.data,
-                    id: error.data.data._id,
-                    error: error.message,
-                    adminError: error.data.adminErrorMessage,
-                };
+                if (!error.data.data) {
+                    errorMessage = "Couln't find report";
+                    reportInfo = EMPTY_REPORT;
+                }
+                else {
+                    reportInfo = {
+                        ...error.data.data,
+                        id: error.data.data._id,
+                        error: error.message,
+                        adminError: error.data.adminErrorMessage,
+                    };
+                }
                 errorMessage = error.message;
             }
         }
@@ -74,6 +101,9 @@ export async function fetchReport(reportId, client, useReportTask = true, filter
     return { report: reportInfo, error: errorMessage };
 }
 export const formatRowsFromReport = (report) => {
+    if (!report.rows || !report.columns) {
+        return [];
+    }
     return report.rows.map((row) => {
         return report.columns.reduce((formattedRow, column) => {
             // Apply the format function to each field in the row
@@ -86,3 +116,59 @@ export const formatRowsFromReport = (report) => {
         }, {});
     });
 };
+export function convertInternalReportToReport(report) {
+    try {
+        if (!report) {
+            return EMPTY_REPORT;
+        }
+        const formattedReport = {
+            ...report,
+        };
+        if (formattedReport.pivot && isValidPivot(formattedReport.pivot)) {
+            let columns = report.pivotColumns ?? report.columns;
+            let rows = report.pivotRows ?? report.rows;
+            if (report.chartType === 'table') {
+                columns =
+                    report.pivotColumns?.map((col, index) => {
+                        if (index === 0) {
+                            return {
+                                ...col,
+                                format: col.format || 'string',
+                            };
+                        }
+                        return {
+                            ...col,
+                            format: report.pivot?.valueFieldType || 'whole_number',
+                        };
+                    }) ?? report.columns;
+                rows = formatRowsFromReport({ rows, columns });
+            }
+            else if (report.chartType === 'metric') {
+                columns =
+                    report.pivotColumns?.map((col) => {
+                        return { ...col, format: report.xAxisFormat };
+                    }) ?? report.columns;
+                rows = formatRowsFromReport({ rows, columns });
+            }
+            return {
+                ...formattedReport,
+                rows: rows,
+                yAxisFields: getYAxisFields(report),
+                columns: columns,
+                rowCount: rows ? rows.length : 0,
+            };
+        }
+        let rows = report.rows;
+        if (report.chartType === 'metric' || report.chartType === 'table') {
+            rows = formatRowsFromReport(report);
+        }
+        return {
+            ...formattedReport,
+            rows: rows,
+            yAxisFields: getYAxisFields(report),
+        };
+    }
+    catch (error) {
+        return EMPTY_REPORT;
+    }
+}

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

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

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

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