@quillsql/react 2.15.2 → 2.15.4

package/dist/esm/utils/report.js

@@ -1,616 +0,0 @@
-import { createInitialFormData } from '../ChartBuilder';
-import { getTableNames } from '../components/ReportBuilder/ast';
-import { generatePivotTable } from '../internals/ReportBuilder/PivotModal';
-import { InternalFilterType, } from '../models/Filter';
-import { getYAxisFields } from './columnProcessing';
-import { cleanDashboardItem } from './dashboard';
-import { fetchSqlQuery, parseFetchResponse, quillFetch } from './dataFetcher';
-import { parseValueFromBigQueryDates } from './dataProcessing';
-import { getDateBucketFromRange } from './dates';
-import { DataLoadError } from './error';
-import { DEFAULT_PAGINATION } from './paginationProcessing';
-import { isPivotPossible, isValidPivot } from './pivotProcessing';
-import { fetchTableByAST, getQueryDateRangeByColumns, getRelevantInfoFromQuery, } from './tableProcessing';
-import { snakeAndCamelCaseToTitleCase } from './textProcessing';
-import { quillAutoFormat, quillFormat } from './valueFormatter';
-import { getFieldFromExpression } from './astFilterProcessing';
-import { isValidPivotForReport, makePivotValid, setTypesOnPivot, } from './reportBuilder';
-import { createSelectStarFromAst } from './astProcessing';
-export const EMPTY_REPORT = {
-    id: '',
-    name: '',
-    dashboardName: '',
-    rows: [],
-    columns: [],
-    chartType: '',
-    pivot: null,
-    xAxisLabel: '',
-    xAxisField: '',
-    xAxisFormat: 'string',
-    yAxisFields: [],
-    order: -1,
-    compareRows: [],
-    filtersApplied: [],
-    queryString: '',
-    rowCount: 0,
-};
-export const EMPTY_INTERNAL_REPORT = {
-    ...EMPTY_REPORT,
-    columnInternal: [],
-};
-function extractAllReportValuesFromQuillInternalReport(reportInternal) {
-    return {
-        id: reportInternal.id,
-        name: reportInternal.name,
-        dashboardName: reportInternal.dashboardName,
-        // section: reportInternal.section,
-        rows: reportInternal.rows,
-        columns: reportInternal.columns,
-        chartType: reportInternal.chartType,
-        dateField: reportInternal.dateField,
-        pivot: reportInternal.pivot,
-        xAxisLabel: reportInternal.xAxisLabel,
-        xAxisField: reportInternal.xAxisField,
-        xAxisFormat: reportInternal.xAxisFormat,
-        yAxisFields: reportInternal.yAxisFields,
-        order: reportInternal.order,
-        compareRows: reportInternal.compareRows,
-        filtersApplied: reportInternal.filtersApplied,
-        queryString: reportInternal.queryString,
-        rowCount: reportInternal.rowCount,
-        template: reportInternal.template,
-        referenceLineYValues: reportInternal.referenceLineYValues,
-        referenceLines: reportInternal.referenceLines,
-        includeCustomFields: reportInternal.includeCustomFields,
-        columnsWithCustomFields: reportInternal.columnsWithCustomFields,
-        pivotRows: reportInternal.pivotRows,
-        pivotColumns: reportInternal.pivotColumns,
-        pivotRowCount: reportInternal.pivotRowCount,
-    };
-}
-export async function fetchReport({ reportId, client, tenants, flags, useReportTask = true, filters = [], additionalProcessing, dateBucket, customFields, rowsOnly, rowCountOnly, abortSignal, getToken, eventTracking, }) {
-    let reportInfo = undefined;
-    let errorMessage = undefined;
-    try {
-        // Remove extra fields on each filter so we don't confuse the backend.
-        const fetchResp = await quillFetch({
-            client,
-            task: useReportTask ? 'report' : 'item',
-            metadata: {
-                reportId,
-                dashboardItemId: reportId,
-                clientId: client.publicKey,
-                databaseType: client.databaseType,
-                filters: filters.map((filter) => ({ ...filter, options: undefined })),
-                customFields,
-                additionalProcessing,
-                useNewNodeSql: true,
-                rowsOnly,
-                rowCountOnly,
-                tenants,
-                flags,
-            },
-            abortSignal,
-            getToken,
-        });
-        const resp = await parseFetchResponse(client, useReportTask ? 'report' : 'item', fetchResp, getToken);
-        reportInfo = await processReportResponse({
-            resp,
-            client,
-            filters,
-            dateBucket,
-            additionalProcessing,
-            customFields,
-            getToken,
-            eventTracking,
-            tenants,
-        });
-    }
-    catch (error) {
-        if (error instanceof Error && error.name === 'AbortError') {
-            throw error;
-        }
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching report',
-            errorMessage: error.message,
-            errorStack: error.stack,
-            errorData: {
-                caller: 'fetchReport',
-                function: 'fetchReport',
-            },
-        });
-        if (error instanceof DataLoadError) {
-            if (!error.data.data) {
-                errorMessage = error.message ?? 'Failed to fetch chart';
-                reportInfo = EMPTY_INTERNAL_REPORT;
-            }
-            else {
-                reportInfo = {
-                    ...(error.data?.data?.data || error.data?.data),
-                    id: error.data?.data?.data?._id || error.data?.data?._id,
-                    rows: [], // indicate loading finished
-                    error: error.message,
-                    adminError: error.data?.data?.data?.adminErrorMessage ||
-                        error.data?.data?.adminErrorMessage,
-                };
-                errorMessage = error.message;
-            }
-        }
-        else {
-            reportInfo = { ...EMPTY_INTERNAL_REPORT, id: reportId };
-            errorMessage = error.message;
-        }
-    }
-    return { report: reportInfo || EMPTY_INTERNAL_REPORT, error: errorMessage };
-}
-export async function processReportResponse({ resp, client, filters, dateBucket, additionalProcessing, customFields, getToken, eventTracking, tenants, }) {
-    const dashboardItem = {
-        ...resp,
-        filtersApplied: filters?.filter((filter) => filter.filterType in InternalFilterType),
-    };
-    if (resp.errorMessage) {
-        throw new DataLoadError(resp?.errorMessage, {
-            ...resp,
-            useReportTask: true,
-        });
-    }
-    if (client.databaseType && client.databaseType.toLowerCase() === 'bigquery') {
-        parseValueFromBigQueryDates(dashboardItem.rows, resp.fields);
-    }
-    if (dashboardItem.compareRows) {
-        if (client.databaseType &&
-            client.databaseType.toLowerCase() === 'bigquery') {
-            parseValueFromBigQueryDates(dashboardItem.compareRows, resp.fields);
-        }
-    }
-    const reportInfo = await cleanDashboardItem({
-        item: dashboardItem,
-        dashboardFilters: filters,
-        client,
-        dateBucket,
-        additionalProcessing,
-        customFields,
-        getToken,
-        tenants,
-        eventTracking,
-    });
-    if (additionalProcessing) {
-        reportInfo.pagination = additionalProcessing.page;
-        reportInfo.sort = additionalProcessing.sort;
-    }
-    //TODO: Revisit this code
-    // It's purpose is to filter out columns that are not present in the rows
-    // But it appears to be confusing dashboardItem and reportInfo
-    // Ensure the report columns don't reference any columns that aren't present in the rows
-    const observedColumns = reportInfo?.rows[0]
-        ? Object.keys(reportInfo.rows[0])
-        : null;
-    if (observedColumns &&
-        reportInfo &&
-        !reportInfo.pivot &&
-        !reportInfo.pivotColumns &&
-        !reportInfo.error &&
-        reportInfo.columns?.filter((col) => !observedColumns.includes(col.field))
-            ?.length > 0) {
-        reportInfo.columns = reportInfo.columns.filter((col) => observedColumns.includes(col.field));
-        reportInfo.columnInternal = reportInfo.columnInternal.filter((col) => observedColumns.includes(col.field));
-        await saveReport({
-            report: { ...reportInfo, query: reportInfo.queryString },
-            dashboardItemId: reportInfo.id,
-            client,
-            getToken,
-            eventTracking,
-        });
-    }
-    return reportInfo;
-}
-// Unused?
-export async function fetchReportInfo(reportId, client, getToken, tenants) {
-    const { data: resp } = await quillFetch({
-        client,
-        task: 'report-info',
-        metadata: {
-            reportId,
-            clientId: client.publicKey,
-            tenants,
-        },
-        getToken,
-    });
-    return { report: resp.report, filters: resp.filters };
-}
-export async function fetchReportRowCount(reportId, client, getToken, tenants, flags, useReportTask = true, filters = [], additionalProcessing, customFields, abortSignal) {
-    // Remove extra fields on each filter so we don't confuse the backend.
-    const fetchResp = await quillFetch({
-        client,
-        task: useReportTask ? 'report' : 'item',
-        metadata: {
-            reportId,
-            dashboardItemId: reportId,
-            clientId: client.publicKey,
-            databaseType: client.databaseType,
-            filters: filters.map((filter) => ({ ...filter, options: undefined })),
-            customFields,
-            additionalProcessing,
-            useNewNodeSql: true,
-            rowCountOnly: true,
-            tenants,
-            flags,
-        },
-        abortSignal,
-        getToken,
-    });
-    const resp = await parseFetchResponse(client, useReportTask ? 'report' : 'item', fetchResp, getToken);
-    return resp.rowCount;
-}
-export async function saveReport({ report, dashboardItemId, client, getToken, eventTracking, }) {
-    const { publicKey, databaseType } = client;
-    const { data } = await quillFetch({
-        client,
-        task: 'create',
-        metadata: {
-            ...report,
-            rows: undefined,
-            compareRows: undefined,
-            dashboardItemId,
-            useNewNodeSql: true,
-            clientId: publicKey,
-            databaseType: databaseType,
-        },
-        credentials: 'same-origin',
-        getToken,
-    });
-    if (dashboardItemId) {
-        eventTracking?.logEvent?.('save-report', {
-            reportId: data.id || data._id,
-        });
-    }
-    else {
-        eventTracking?.logEvent?.('create-report', {
-            reportId: data.id || data._id,
-        });
-    }
-    return data;
-}
-export const formatRowsFromReport = (report, xAxisField, xAxisFormat) => {
-    if (!report.rows || !report.columns) {
-        return [];
-    }
-    const columns = report.includeCustomFields &&
-        report.columnsWithCustomFields &&
-        !report.pivot
-        ? report.columnsWithCustomFields
-        : report.columns;
-    return report.rows.map((row) => {
-        return columns.reduce((formattedRow, column) => {
-            // Apply the format function to each field in the row
-            const formattedValue = column.inferFormat
-                ? quillAutoFormat(row[column.field])
-                : quillFormat({
-                    value: row[column.field],
-                    format: column.field === xAxisField && xAxisFormat
-                        ? xAxisFormat
-                        : column.format,
-                });
-            formattedRow[column.field] = formattedValue;
-            return formattedRow;
-        }, {});
-    });
-};
-export function formattedPivotRowsAndColumns(report) {
-    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: col.format ?? '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 {
-        rows,
-        columns,
-        rowCount: report.chartType === 'table'
-            ? (report.pivotRowCount ?? report.rowCount)
-            : rows
-                ? rows.length
-                : 0,
-    };
-}
-export function convertInternalReportToReport(report, dashboardFilters, eventTracking, initiator) {
-    try {
-        if (!report) {
-            return EMPTY_REPORT;
-        }
-        const formattedReport = {
-            ...report,
-        };
-        if (formattedReport.pivot &&
-            isValidPivot(formattedReport.pivot).valid &&
-            initiator !== 'useQuill' &&
-            initiator !== 'Table' &&
-            initiator !== 'useDashboardReport') {
-            return {
-                ...extractAllReportValuesFromQuillInternalReport(formattedReport),
-                yAxisFields: getYAxisFields(report, dashboardFilters),
-                ...formattedPivotRowsAndColumns(formattedReport),
-            };
-        }
-        let rows = report.rows;
-        if (report.chartType === 'metric') {
-            rows = formatRowsFromReport(report, report.xAxisField, report.xAxisFormat);
-        }
-        else if (report.chartType === 'table') {
-            rows = formatRowsFromReport(report);
-        }
-        return {
-            ...extractAllReportValuesFromQuillInternalReport(formattedReport),
-            rows: rows,
-            yAxisFields: getYAxisFields(report, dashboardFilters),
-        };
-    }
-    catch (error) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error converting internal report to report',
-            errorMessage: error.message,
-            errorStack: error.stack,
-            errorData: {
-                caller: 'convertInternalReportToReport',
-                function: 'convertInternalReportToReport',
-            },
-        });
-        return EMPTY_REPORT;
-    }
-}
-export const fetchReportBuilderDataFromAST = async ({ baseAst, schema, client, tenants, pivot, skipPivotColumnFetch, previousRelevant, requiresNewFilteredUniqueValues, report, customFields, skipUniqueValues, skipRowCount, processing, dashboardName, getToken, eventTracking, }) => {
-    let newRows = [];
-    let newColumns = [];
-    let newRowCount = 0;
-    let newPivot = null;
-    let newPivotData = null;
-    let pivotHint = '';
-    let formattedRows = [];
-    let curReport = report;
-    let error;
-    const relevantInfo = previousRelevant ?? {
-        uniqueStringsByTable: {},
-        dateRanges: {},
-        uniqueStringsByColumn: {},
-    };
-    let query = '';
-    let tables = [];
-    const reportBuilderColumns = [];
-    try {
-        tables = getTableNames(baseAst);
-        const astColumnsByTable = {};
-        baseAst.columns.forEach((col) => {
-            if (!astColumnsByTable[col.expr?.table ?? '']) {
-                astColumnsByTable[col.expr?.table ?? ''] = [];
-            }
-            const field = getFieldFromExpression(col.expr ?? col);
-            const table = tables.length === 1 ? tables[0] : col.expr?.table;
-            if (field) {
-                astColumnsByTable[table ?? '']?.push(field);
-                if (table) {
-                    reportBuilderColumns.push({ field, table, alias: col.as });
-                }
-            }
-        });
-        const columnInfo = tables.flatMap((table) => {
-            const tableInfo = schema.find((tableInfo) => tableInfo.name === table);
-            if (!tableInfo) {
-                return [];
-            }
-            return tableInfo.columns
-                .map((col) => ({ ...col, table }))
-                .filter((col) => {
-                return (astColumnsByTable[table]?.includes(col.field) ||
-                    astColumnsByTable['']?.includes(col.field));
-            });
-        });
-        const aliasedColumnInfo = tables.flatMap((table) => {
-            const tableInfo = schema.find((tableInfo) => tableInfo.name === table);
-            if (!tableInfo) {
-                return [];
-            }
-            return tableInfo.columns
-                .map((col) => ({ ...col, table }))
-                .filter((col) => {
-                return (astColumnsByTable[table]?.includes(col.field) ||
-                    astColumnsByTable['']?.includes(col.field));
-            })
-                .map((col) => {
-                const reportBuilderColumn = reportBuilderColumns.find((c) => c.field === col.field && c.table === col.table);
-                return {
-                    ...col,
-                    field: reportBuilderColumn?.alias ?? col.field,
-                };
-            });
-        });
-        const tableData = await fetchTableByAST(baseAst, client, getToken, tenants, eventTracking, dashboardName, processing ?? { page: DEFAULT_PAGINATION }, customFields, skipRowCount);
-        if (tableData.error) {
-            throw new Error(tableData.error);
-        }
-        const processedFormData = report && report.chartType
-            ? report
-            : createInitialFormData(tableData.columns);
-        curReport = {
-            id: report?.id ?? '',
-            dashboardName: report?.dashboardName ?? '',
-            order: report?.order ?? 1,
-            compareRows: report?.compareRows ?? [],
-            queryString: report?.queryString ?? '',
-            ...report,
-            ...processedFormData,
-            pivot: pivot ?? null,
-            itemQuery: tableData.itemQuery,
-            rowCount: tableData.rowCount ?? 0,
-            filtersApplied: [],
-            rows: tableData.rows,
-            columns: tableData.columns.map((col) => {
-                return {
-                    field: col.field,
-                    format: col.format,
-                    label: snakeAndCamelCaseToTitleCase(col.label),
-                };
-            }),
-            columnInternal: tableData.columns,
-            referenceLines: report?.referenceLines,
-            referenceLineYValues: report?.referenceLineYValues,
-        };
-        const queryResult = await fetchSqlQuery(baseAst, client, getToken);
-        if (queryResult.error) {
-            throw new Error(queryResult.error);
-        }
-        query = queryResult.query;
-        if (!skipUniqueValues ||
-            (pivot && requiresNewFilteredUniqueValues && !skipPivotColumnFetch)) {
-            const starQuery = await fetchSqlQuery(createSelectStarFromAst(baseAst), client, getToken);
-            const { uniqueStrings, dateRanges, columnUniqueValues } = await getRelevantInfoFromQuery({
-                tables,
-                columns: columnInfo,
-                aliasedColumns: aliasedColumnInfo,
-                reportBuilderColumns,
-                client,
-                getToken,
-                eventTracking,
-                tenants,
-                query: queryResult.query,
-                queryTemplate: starQuery.query,
-                customFields,
-                dashboardName,
-            });
-            relevantInfo.uniqueStringsByTable = uniqueStrings ?? {};
-            relevantInfo.dateRanges = dateRanges ?? {};
-            relevantInfo.uniqueStringsByColumn = columnUniqueValues ?? {};
-        }
-        else {
-            const dateColumns = aliasedColumnInfo.filter((column) => {
-                return column.fieldType === 'date';
-            });
-            if (dateColumns.length > 0) {
-                const dateRanges = await getQueryDateRangeByColumns(dateColumns, queryResult.query, client, getToken, tenants, eventTracking, customFields ?? [], dashboardName);
-                if (dateRanges === null) {
-                    throw new Error("Couldn't fetch date ranges");
-                }
-                relevantInfo.dateRanges = dateRanges ?? {};
-            }
-        }
-        if (!!relevantInfo.error) {
-            throw new Error(relevantInfo.error);
-        }
-        if (pivot &&
-            !skipPivotColumnFetch && // assume pivot is valid
-            !isValidPivotForReport(pivot, relevantInfo.uniqueStringsByColumn, tableData.columns)) {
-            const { pivot: newValidPivot, hint } = makePivotValid(pivot, relevantInfo.uniqueStringsByColumn, tableData.columns);
-            if (newValidPivot) {
-                pivot = newValidPivot;
-                pivotHint = hint;
-            }
-            else {
-                pivot = undefined;
-                pivotHint = 'Pivot no longer valid';
-            }
-        }
-        if (pivot) {
-            if (isPivotPossible(tableData.columns, pivot)) {
-                let dateBucket = undefined;
-                const rowFieldDateRange = relevantInfo.dateRanges[pivot.rowField ?? ''] ?? undefined;
-                if (rowFieldDateRange) {
-                    dateBucket = getDateBucketFromRange(rowFieldDateRange.dateRange);
-                }
-                newPivotData = await generatePivotTable({
-                    pivot,
-                    dateBucket,
-                    report: curReport,
-                    client,
-                    uniqueValues: relevantInfo.uniqueStringsByColumn,
-                    dashboardName,
-                    tenants,
-                    additionalProcessing: processing,
-                    caller: 'ReportBuilder',
-                    getToken,
-                    pivotQuery: skipPivotColumnFetch ? curReport?.pivotQuery : undefined,
-                    eventTracking,
-                });
-                newPivot = pivot;
-            }
-            if (!newPivotData) {
-                newPivot = null;
-                formattedRows = formatRowsFromReport({
-                    rows: tableData.rows,
-                    columns: tableData.columns,
-                });
-            }
-            else {
-                formattedRows = formatRowsFromReport({
-                    rows: newPivotData.rows,
-                    columns: newPivotData.columns,
-                });
-            }
-        }
-        else {
-            formattedRows = formatRowsFromReport({
-                rows: tableData.rows,
-                columns: tableData.columns,
-            });
-        }
-        newRowCount = tableData.rowCount ?? tableData.rows.length;
-        newRows = tableData.rows;
-        newColumns = tableData.columns;
-    }
-    catch (e) {
-        eventTracking?.logError?.({
-            type: 'bug', // TODO: determine type
-            severity: 'high',
-            message: 'Error fetching report builder data from AST',
-            errorMessage: e.message,
-            errorStack: e.stack,
-            errorData: {
-                caller: 'fetchReportBuilderDataFromAST',
-                function: 'fetchReportBuilderDataFromAST',
-            },
-        });
-        error = e.message;
-    }
-    if (newPivot) {
-        newPivot = setTypesOnPivot(newPivot, newColumns);
-    }
-    return {
-        rows: newRows,
-        columns: newColumns,
-        reportBuilderColumns,
-        rowCount: newRowCount,
-        pivot: newPivot,
-        pivotData: newPivotData,
-        formattedRows,
-        report: curReport ?? EMPTY_INTERNAL_REPORT,
-        tables,
-        uniqueStringsByTable: relevantInfo.uniqueStringsByTable,
-        uniqueStringsByColumn: relevantInfo.uniqueStringsByColumn,
-        dateRanges: relevantInfo.dateRanges,
-        query,
-        pivotHint,
-        error: error,
-        itemQuery: curReport?.itemQuery,
-    };
-};