@quillsql/react 2.12.35 → 2.12.37

package/dist/esm/utils/pivotProcessing.js

@@ -1,132 +0,0 @@
-import { isIdColumn } from '../components/ReportBuilder/util';
-import { DATE_FORMAT_TYPES, NUMBER_FORMAT_TYPES } from './valueFormatter';
-export function pivotToSql(pivot, query, columns) {
-    const processedAggType = pivot.aggregationType?.toLowerCase() === 'average'
-        ? 'avg'
-        : pivot.aggregationType?.toLowerCase();
-    if ((!pivot.rowField && pivot.valueField && processedAggType) ||
-        (!pivot.valueField && pivot.rowField && processedAggType === 'count')) {
-        // table aggregation
-        return `with
-    original_query as (${query})
-    SELECT ${processedAggType}(${pivot.valueField ?? pivot.rowField}) FROM original_query`;
-    }
-    else if (!pivot.columnField &&
-        processedAggType &&
-        pivot.rowField &&
-        pivot.valueField) {
-        // 1-d pivot
-        return `with
-    original_query as (${query})
-    SELECT ${pivot.rowField}, ${processedAggType}(${pivot.valueField}) FROM original_query GROUP BY ${pivot.rowField}`;
-    }
-    else if (pivot.columnField &&
-        pivot.rowField &&
-        pivot.valueField &&
-        processedAggType) {
-        // 2-d pivot
-        const sqlQuery = generateTwoDPivotQuery({ ...pivot, aggregationType: processedAggType }, query, columns);
-        return sqlQuery;
-    }
-    return query;
-}
-function generateTwoDPivotQuery(pivot, query, columns) {
-    const caseWhens = columns.map((column) => {
-        return `${pivot.aggregationType}(
-      CASE WHEN ${pivot.columnField} = '${column.field}' THEN ${pivot.valueField} ELSE 0 END
-    ) AS "${column.field}"`;
-    });
-    return `WITH
-    original_query as (${query})
-  SELECT ${pivot.rowField}, ${caseWhens.join(', ')}
-  FROM original_query GROUP BY ${pivot.rowField}`;
-}
-export function isValidPivot(pivot) {
-    if (pivot.rowField && pivot.aggregationType === 'count') {
-        return true;
-    }
-    else if (pivot.rowField &&
-        pivot.valueField &&
-        pivot.aggregationType &&
-        !pivot.columnField) {
-        return true;
-    }
-    else if (pivot.valueField &&
-        pivot.aggregationType &&
-        !pivot.columnField &&
-        !pivot.rowField) {
-        return true;
-    }
-    else if (pivot.rowField &&
-        pivot.columnField &&
-        pivot.valueField &&
-        pivot.aggregationType) {
-        return true;
-    }
-    return false;
-}
-export function getPossiblePivotFieldOptions(columns, uniqueValues) {
-    const rowFields = [];
-    const columnFields = [];
-    const valueFields = [];
-    for (const column of columns) {
-        // row fields can be dates or strings
-        if (DATE_FORMAT_TYPES.includes(column.format)) {
-            rowFields.push(column.field);
-        }
-        // column fields can be strings
-        if (column.jsType === 'string') {
-            const possibleValues = uniqueValues ? uniqueValues[column.field] : 0;
-            const isNullValuesOnly = !possibleValues ||
-                (Object.keys(possibleValues).length === 1 &&
-                    Object.keys(possibleValues)[0] === 'null');
-            if (!isNullValuesOnly && Object.keys(possibleValues).length <= 36) {
-                columnFields.push(column.field);
-            }
-            if (!isNullValuesOnly && Object.keys(possibleValues).length <= 36) {
-                rowFields.push(column.field);
-            }
-        }
-        // value fields can be numbers
-        if (NUMBER_FORMAT_TYPES.includes(column.format)) {
-            if (!isIdColumn(column.field)) {
-                valueFields.push(column.field);
-            }
-        }
-    }
-    return {
-        rowFields,
-        columnFields,
-        valueFields,
-    };
-}
-export function cleanPivot(pivot, possibleColumns) {
-    if (possibleColumns.columnFields.length === 0 &&
-        possibleColumns.rowFields.length === 0 &&
-        possibleColumns.valueFields.length === 0) {
-        return pivot;
-    }
-    // Swap row field and column field if the AI put a date field as the column field
-    if (pivot.columnField &&
-        !possibleColumns.columnFields.includes(pivot.columnField)) {
-        if (possibleColumns.rowFields.includes(pivot.columnField)) {
-            const rowField = pivot.rowField;
-            pivot.rowField = pivot.columnField;
-            pivot.columnField = possibleColumns.columnFields.includes(rowField)
-                ? rowField
-                : undefined;
-        }
-    }
-    if (pivot.rowField && !possibleColumns.rowFields.includes(pivot.rowField)) {
-        pivot.rowField = '';
-    }
-    if (pivot.valueField &&
-        !possibleColumns.valueFields.includes(pivot.valueField)) {
-        pivot.valueField = '';
-    }
-    if (pivot.columnField &&
-        !possibleColumns.columnFields.includes(pivot.columnField)) {
-        pivot.columnField = undefined;
-    }
-    return pivot;
-}

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

@@ -1,7 +0,0 @@
-import { Pivot } from '../internals/ReportBuilder/PivotModal';
-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/esm/utils/queryConstructor.d.ts.map

@@ -1 +0,0 @@
-{"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;AAgDD,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"}

package/dist/esm/utils/queryConstructor.js

@@ -1,223 +0,0 @@
-import { isValidPivot } from './pivotProcessing';
-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 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
-        ? `${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, databaseType) {
-    const distinctQueries = stringFields.map((field) => {
-        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;
-}
-export function generateMinMaxRangeQueries(columnFields, query, databaseType) {
-    const distinctQueries = columnFields.map((field) => {
-        const wrappedField = ['postgresql', 'snowflake'].includes(databaseType.toLowerCase())
-            ? `"${field}"`
-            : field;
-        return `SELECT '${field}' AS field, MIN(${wrappedField}) AS min_range, MAX(${wrappedField}) AS max_range FROM querytable`;
-    });
-    const distinctQuery = distinctQueries.join(' UNION ALL ');
-    return `WITH querytable AS (${query.replace(';', '')}) ` + distinctQuery;
-}
-export function generatePivotQuery(pivot, itemQueries, databaseType, comparisonInterval, distinctStrings, dateBucket) {
-    if (!isValidPivot(pivot)) {
-        return undefined;
-    }
-    if (pivot.columnField) {
-        return create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, distinctStrings);
-    }
-    if (pivot.rowField) {
-        return create1DPivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
-    }
-    return createAggregationValuePivot(pivot, itemQueries, databaseType);
-}
-function create2DPivotQuery(pivot, itemQueries, databaseType, dateBucket, comparisonInterval, columnFieldValues) {
-    if (!pivot || !pivot.columnField) {
-        return undefined;
-    }
-    if (!columnFieldValues) {
-        return undefined;
-    }
-    if (['string', 'varchar'].includes(pivot.rowFieldType) ||
-        !pivot.rowFieldType) {
-        return create2DStringPivotQuery(pivot, itemQueries, columnFieldValues, databaseType);
-    }
-    return create2DDatePivotQuery(pivot, itemQueries, columnFieldValues, databaseType, dateBucket, comparisonInterval);
-}
-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 = 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 ${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.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(rowField, databaseType)}`
-        : '';
-    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  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, 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 = 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 ${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 ${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 ${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.${processColumnReference(`${rowField}`, databaseType)}`;
-}
-function create1DPivotQuery(pivot, itemQueries, dateBucket = 'month', databaseType, comparisonInterval) {
-    if (['string', 'varchar'].includes(pivot.rowFieldType) ||
-        !pivot.rowFieldType) {
-        return create1DStringPivotQuery(pivot, itemQueries, databaseType);
-    }
-    return create1DDatePivotQuery(pivot, itemQueries, dateBucket, databaseType, comparisonInterval);
-}
-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 ${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.${processColumnReference(`comparison_${rowField}`, databaseType)} = qt.${processColumnReference(`${rowField}`, databaseType)}`
-        : '';
-    return `WITH quill_qt AS (${itemQueries[0]?.replaceAll(';', '')}),
-  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
-  ${joinQuery}`;
-}
-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 ${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 ${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 ${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.${processColumnReference(`${rowField}`, databaseType)}`;
-}
-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}(${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}(${processColumnReference(`${valueField}`, databaseType)}) as ${processColumnReference(`${valueField}`, databaseType)} FROM quill_qt)
-      ${compareCTE} ${compareAggregation}
-      SELECT * FROM quill_qt_agg qt 
-      ${joinQuery}`;
-}

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

@@ -1,10 +0,0 @@
-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: 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 +0,0 @@
-{"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,174 +0,0 @@
-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;
-    try {
-        // Remove extra fields on each filter so we don't confuse the backend.
-        const hostedBody = {
-            metadata: {
-                reportId,
-                dashboardItemId: reportId,
-                orgId: client.customerId || '*',
-                clientId: client.publicKey,
-                task: useReportTask ? 'report' : 'item',
-                databaseType: client.databaseType,
-                filters: filters,
-                customFields,
-                additionalProcessing,
-                useNewNodeSql: true,
-            },
-        };
-        const cloudBody = {
-            id: reportId,
-            filters: filters,
-            useNewNodeSql: true,
-        };
-        const resp = await getData(client, 'itempost', 'omit', hostedBody, cloudBody, 'POST', 'fetch-data');
-        processFilterErrorList(resp);
-        const dashboardItem = { ...resp, filtersApplied: filters };
-        if (resp.errorMessage) {
-            throw new DataLoadError(resp?.errorMessage, { ...resp, useReportTask });
-        }
-        if (resp.compareRows) {
-            mergeComparisonRange(resp);
-        }
-        reportInfo = await cleanDashboardItem(dashboardItem, filters, client, dateBucket);
-        if (additionalProcessing) {
-            reportInfo.pagination = additionalProcessing.page;
-            reportInfo.sort = additionalProcessing.sort;
-        }
-    }
-    catch (error) {
-        if (error instanceof DataLoadError) {
-            if (error.data.useReportTask) {
-                internalLog('USING ITEM AS BACKUP');
-                const { report, error } = await fetchReport(reportId, client, false, filters, additionalProcessing, dateBucket, customFields);
-                reportInfo = report;
-                errorMessage = error;
-            }
-            else {
-                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;
-            }
-        }
-        else {
-            reportInfo = {
-                id: reportId,
-                rows: [],
-                columns: [],
-            };
-            errorMessage = error.message;
-        }
-    }
-    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
-            const formattedValue = quillFormat({
-                value: row[column.field],
-                format: column.format,
-            });
-            formattedRow[column.field] = formattedValue;
-            return formattedRow;
-        }, {});
-    });
-};
-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/schema.d.ts

@@ -1,6 +0,0 @@
-export declare const getCustomFieldInfo: (client: any, caller?: string) => Promise<any[]>;
-export declare const getSchemaInfoWithCustomFields: (client: any, caller?: string) => Promise<{
-    schemaData: any;
-    customFieldsByTable: any[];
-}>;
-//# sourceMappingURL=schema.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/utils/schema.ts"],"names":[],"mappings":"AAkDA,eAAO,MAAM,kBAAkB,WAAkB,GAAG,oCA+EnD,CAAC;AAEF,eAAO,MAAM,6BAA6B,WAChC,GAAG;;;EA6CZ,CAAC"}