@quillsql/react 2.15.2 → 2.15.4

package/dist/esm/hooks/useReportBuilder.js

@@ -1,1490 +0,0 @@
-import { useContext, useEffect, useMemo, useState } from 'react';
-import { TEMP_REPORT_ID } from '../models/Report';
-import { EMPTY_INTERNAL_REPORT, fetchReportBuilderDataFromAST, formatRowsFromReport, } from '../utils/report';
-import { fetchResultsByQuery, fetchTableByAST, getUniqueStringValuesByTable, } from '../utils/tableProcessing';
-import { EMPTY_REPORT_BUILDER_STATE, } from '../models/ReportBuilder';
-import { SchemaDataContext, FetchContext, EventTrackingContext, TenantContext, ClientContext, } from '../Context';
-import { SINGLE_TENANT } from '../utils/constants';
-import { useAllReports, useDashboards, useDashboardInternal, } from './useDashboard';
-import { convertCustomFilter, convertInternalFilterToFilter, } from '../models/Filter';
-import { createSelectStarFromAst, fetchAndProcessASTFromPrompt, fetchASTFromQuillReport, } from '../utils/astProcessing';
-import { cleanDashboardItem } from '../utils/dashboard';
-import { fetchSqlQuery } from '../utils/dataFetcher';
-import { filterSentence } from '../utils/filterProcessing';
-import { shouldFetchMore } from '../utils/paginationProcessing';
-import { isValidPivot, pivotFormData } from '../utils/pivotProcessing';
-import { validatedReportBuilderState, setTypesOnPivot, formatRows, reportBuilderStateToAst, isValidPivotForReport, astToReportBuilderState, } from '../utils/reportBuilder';
-import { getSchemaForeignKeyMapping } from '../utils/schema';
-import { useLongLoading } from './useLongLoading';
-import { convertQueryToSelectStar } from '../components/ReportBuilder/convert';
-export const useReportBuilderInternal = ({ reportId, initialTableName, destinationDashboard, pivotRecommendationsEnabled, onSaveChanges, rowsPerPage, rowsPerRequest, }) => {
-    const { allReportsById } = useAllReports();
-    const [schemaData] = useContext(SchemaDataContext);
-    const { dashboards } = useDashboards();
-    const { data, isLoading: dashboardIsLoading, reload, } = useDashboardInternal(destinationDashboard);
-    const { getToken } = useContext(FetchContext);
-    const { eventTracking } = useContext(EventTrackingContext);
-    const destinationDashboardConfig = useMemo(() => {
-        return dashboards?.find((d) => d.name === destinationDashboard);
-    }, [dashboards, destinationDashboard]);
-    const filteredSchema = useMemo(() => {
-        return schemaData.schemaWithCustomFields?.filter((table) => {
-            return (destinationDashboardConfig?.tenantKeys?.[0] === SINGLE_TENANT ||
-                !table.ownerTenantFields ||
-                table.ownerTenantFields?.length === 0 ||
-                table.ownerTenantFields?.includes(destinationDashboardConfig?.tenantKeys?.[0] ?? ''));
-        });
-    }, [
-        schemaData.schemaWithCustomFields,
-        destinationDashboardConfig?.tenantKeys,
-    ]);
-    const { tenants } = useContext(TenantContext);
-    const [client] = useContext(ClientContext);
-    const _rowsPerRequest = rowsPerRequest ?? 100;
-    const _rowsPerPage = Math.min(rowsPerPage ?? 20, _rowsPerRequest);
-    // Consts
-    const REPORT_BUILDER_PAGINATION = {
-        page: 0,
-        rowsPerPage: _rowsPerPage,
-        rowsPerRequest: _rowsPerRequest,
-    };
-    // ReportBuilder UI States
-    const [openPopover, setOpenPopover] = useState(null);
-    const [aiPrompt, setAiPrompt] = useState('');
-    const [reportBuilderLoading, setReportBuilderLoading] = useState(false);
-    const [tableLoading, setTableLoading] = useState(false);
-    const [errorMessage, setErrorMessage] = useState('');
-    const [unresolvedReportMessage, setUnresolvedReportMessage] = useState('');
-    // Core Report states
-    // Table order matters for joins. For now, assumed to have one 'primary' table (the first one)
-    const [tables, setTables] = useState([]);
-    const [columns, setColumns] = useState([]);
-    const [filterStack, setFilterStack] = useState([]);
-    const [pivot, setPivot] = useState(null);
-    const [sort, setSort] = useState([]);
-    const [limit, setLimit] = useState(null);
-    const reportBuilderState = useMemo(() => {
-        return {
-            tables,
-            columns,
-            filterStack,
-            pivot,
-            sort,
-            limit,
-        };
-    }, [columns, filterStack, limit, pivot, sort, tables]);
-    // For undo/redo
-    const [stateStack, setStateStack] = useState([]);
-    const [poppedStateStack, setPoppedStateStack] = useState([]);
-    // Other Report states
-    const [activeQuery, setActiveQuery] = useState('');
-    const [queryOutOfSync, setQueryOutOfSync] = useState(false);
-    const [unfilteredUniqueValues, setUnfilteredUniqueValues] = useState({}); // unique values before filtering
-    const [unfilteredUniqueValuesIsLoading, setUnfilteredUniqueValuesIsLoading] = useState(false);
-    const [filteredUniqueValues, setFilteredUniqueValues] = useState(null); // unique values after filtering
-    const [filteredUniqueValuesIsLoading, setFilteredUniqueValuesIsLoading] = useState(false);
-    const [columnUniqueValues, setColumnUniqueValues] = useState({});
-    const [dateRanges, setDateRanges] = useState(null);
-    const [tempReport, setTempReport] = useState({
-        ...EMPTY_INTERNAL_REPORT,
-        pagination: REPORT_BUILDER_PAGINATION,
-    });
-    const [currentProcessing, setCurrentProcessing] = useState({
-        page: REPORT_BUILDER_PAGINATION,
-    });
-    const [previousPage, setPreviousPage] = useState(0);
-    // Table display states
-    const [reportColumns, setReportColumns] = useState([]);
-    const [reportRows, setReportRows] = useState([]);
-    const [formattedRows, setFormattedRows] = useState([]);
-    const [pivotData, setPivotData] = useState(null);
-    const [numberOfRows, setNumberOfRows] = useState(0);
-    const [rowCountIsLoading, setRowCountIsLoading] = useState(false);
-    const reportColumnsToStateColumns = useMemo(() => {
-        const positionMap = {};
-        columns.forEach((column, index) => {
-            positionMap[column.field] = index;
-            if (column.alias) {
-                positionMap[column.alias] = index;
-            }
-        });
-        // Sort reportColumns based on the position in columns
-        return [...reportColumns]
-            .filter((reportColumn) => positionMap[reportColumn.field] !== undefined)
-            .sort((a, b) => {
-            const posA = positionMap[a.field];
-            const posB = positionMap[b.field];
-            if (posA !== undefined && posB !== undefined) {
-                return posA - posB;
-            }
-            else {
-                return 0;
-            }
-        });
-    }, [columns, reportColumns]);
-    // Pivot form states
-    const [pivotRowField, setPivotRowField] = useState(undefined);
-    const [pivotColumnField, setPivotColumnField] = useState(undefined);
-    const [pivotAggregations, setPivotAggregations] = useState([]);
-    const [pivotLimit, setPivotLimit] = useState(undefined);
-    const [pivotSort, setPivotSort] = useState(undefined);
-    const [pivotHint, setPivotHint] = useState('');
-    const [pivotError, setPivotError] = useState('');
-    const [createdPivots, setCreatedPivots] = useState([]);
-    const [recommendedPivots, setRecommendedPivots] = useState([]);
-    const [pivotPopUpTitle, setPivotPopUpTitle] = useState('Add pivot');
-    const [showPivotPopover, setShowPivotPopover] = useState(false);
-    const [isEditingPivot, setIsEditingPivot] = useState(false);
-    const [selectedPivotIndex, setSelectedPivotIndex] = useState(-1);
-    const [pivotRecommendationsEnabledState, setPivotRecommendationsEnabledState,] = useState(pivotRecommendationsEnabled);
-    // Ask AI
-    const [askAILoading, setAskAILoading] = useState(false);
-    const loading = reportBuilderLoading || tableLoading;
-    useLongLoading(reportBuilderLoading, {
-        origin: 'ReportBuilder',
-        loadDescription: 'Loading report builder',
-    });
-    useLongLoading(tableLoading, {
-        origin: 'ReportBuilder',
-        loadDescription: 'Loading table',
-    });
-    useLongLoading(askAILoading, {
-        origin: 'ReportBuilder',
-        loadDescription: 'Loading ask AI',
-    });
-    const isSelectStar = useMemo(() => {
-        if (tables.length === 1) {
-            // Check if all columns are selected
-            const totalColumnLength = tables.reduce((acc, table) => {
-                const tableColumns = filteredSchema.find((t) => t.name === table.name)?.columns.length ??
-                    0;
-                return acc + tableColumns;
-            }, 0);
-            return totalColumnLength === columns.length;
-        }
-        else {
-            // TODO: Implement this to work with joins
-            // SELECT * won't work if joined table has shared column name
-            return false;
-        }
-    }, [tables, columns, filteredSchema]);
-    const mssqlSortWarning = useMemo(() => {
-        if (!client || client?.databaseType !== 'mssql') {
-            return undefined;
-        }
-        else if (!pivot && !limit) {
-            return 'Please add a limit.';
-        }
-    }, [client, limit, pivot]);
-    const foreignKeyMap = useMemo(() => {
-        return getSchemaForeignKeyMapping(filteredSchema);
-    }, [filteredSchema]);
-    // State changing functions
-    const clearAllState = (resetStateStack = true) => {
-        setActiveQuery('');
-        setQueryOutOfSync(false);
-        handleMultiStateChange({
-            state: EMPTY_REPORT_BUILDER_STATE,
-            fetchData: false,
-            updateStateStack: true,
-        });
-        if (resetStateStack) {
-            setStateStack([]);
-            setPoppedStateStack([]);
-        }
-        setFilteredUniqueValues(null);
-        setUnfilteredUniqueValues({});
-        setColumnUniqueValues({});
-        setDateRanges(null);
-        setTempReport({
-            ...EMPTY_INTERNAL_REPORT,
-            pagination: REPORT_BUILDER_PAGINATION,
-        });
-        resetProcessing();
-        setReportColumns([]);
-        setReportRows([]);
-        setFormattedRows([]);
-        setPivotData(null);
-        setNumberOfRows(0);
-        setRowCountIsLoading(false);
-        setPivotRowField(undefined);
-        setPivotColumnField(undefined);
-        setPivotAggregations([]);
-        setCreatedPivots([]);
-        setRecommendedPivots([]);
-        setSelectedPivotIndex(-1);
-        setAskAILoading(false);
-        setReportBuilderLoading(false);
-        setTableLoading(false);
-        setPivotError('');
-        setErrorMessage('');
-        setUnresolvedReportMessage('');
-        setPivotHint('');
-    };
-    const handleTablesChange = (newTables, updateStateStack = true) => {
-        setTables(newTables);
-        if (updateStateStack) {
-            setStateStack((prevStack) => [
-                ...prevStack,
-                { ...reportBuilderState, tables: newTables },
-            ]);
-            setPoppedStateStack([]);
-        }
-    };
-    const handleColumnsChange = (newColumns, fetchData, updateStateStack = true, bypassConfirmation = false) => {
-        if (newColumns.length > 0) {
-            eventTracking?.addBreadcrumb?.({
-                message: 'Changed columns in ReportBuilder',
-                data: {
-                    columns: newColumns,
-                },
-                category: 'log',
-                level: 'info',
-                timestamp: Date.now(),
-            });
-        }
-        const validReportBuilderState = bypassConfirmation
-            ? { ...reportBuilderState, columns: newColumns }
-            : validatedReportBuilderState({
-                ...reportBuilderState,
-                columns: newColumns,
-            }, foreignKeyMap);
-        if (validReportBuilderState.tables.length === 0 && !bypassConfirmation) {
-            if (!confirm('Removing all columns will clear all state. Are you sure you want to continue?')) {
-                return;
-            }
-            else {
-                handleMultiStateChange({
-                    state: EMPTY_REPORT_BUILDER_STATE,
-                    fetchData: false,
-                    updateStateStack: true,
-                });
-                return;
-            }
-        }
-        const tablesAffected = tables.length - validReportBuilderState.tables.length >= 2;
-        const filtersAffected = validReportBuilderState.filterStack.length !== filterStack.length;
-        const deletedTables = tables
-            .filter((table) => {
-            return !validReportBuilderState.tables.some((t) => t.name === table.name);
-        })
-            .map((table) => table.name);
-        const deletedFilters = filterStack
-            .filter((filter) => filter.value)
-            .filter((filter) => {
-            return deletedTables.some((table) => table === filter.value.table);
-        })
-            .map((filter) => filterSentence(filter.value));
-        if (tablesAffected && filtersAffected) {
-            if (!confirm(`Removing this column will remove the following table${deletedTables.length > 1 ? 's' : ''}:
-          ${deletedTables.join(', ')}.
-          It will also remove the following filter${deletedFilters.length > 1 ? 's' : ''}:
-          ${deletedFilters.join(', ')}.
-          Are you sure you want to continue?
-          `
-                .replace(/\s+/g, ' ')
-                .trim())) {
-                return;
-            }
-        }
-        else if (tablesAffected) {
-            if (!confirm(`Removing this column will remove the following table${deletedTables.length > 1 ? 's' : ''}:
-          ${deletedTables.join(', ')}.
-          Are you sure you want to continue?
-          `
-                .replace(/\s+/g, ' ')
-                .trim())) {
-                return;
-            }
-        }
-        else if (filtersAffected) {
-            if (!confirm(`Removing this column will remove the following filter${deletedFilters.length > 1 ? 's' : ''}:
-          ${deletedFilters.join(', ')}.
-          Are you sure you want to continue?
-          `
-                .replace(/\s+/g, ' ')
-                .trim())) {
-                return;
-            }
-        }
-        if (validReportBuilderState.tables.length !== tables.length) {
-            handleTablesChange(validReportBuilderState.tables, false);
-            fetchData = true;
-        }
-        if (validReportBuilderState.filterStack.length !== filterStack.length) {
-            handleFilterStackChange(validReportBuilderState.filterStack, false, false);
-            fetchData = true;
-        }
-        if (validReportBuilderState.sort.length !== sort.length) {
-            handleSortChange(validReportBuilderState.sort, false, false);
-            fetchData = true;
-        }
-        if (pivot && !validReportBuilderState.pivot) {
-            handlePivotChange(validReportBuilderState.pivot, false, false);
-        }
-        setColumns(validReportBuilderState.columns);
-        if (updateStateStack) {
-            setStateStack((prevStack) => [...prevStack, validReportBuilderState]);
-            setPoppedStateStack([]);
-        }
-        if (fetchData) {
-            fetchDataFromReportBuilderState({ state: validReportBuilderState });
-        }
-        else {
-            setQueryOutOfSync(true);
-        }
-    };
-    const handleFilterInsertion = (newFilter) => {
-        const newFilterStack = [...filterStack];
-        eventTracking?.addBreadcrumb?.({
-            message: 'Inserted filter in ReportBuilder',
-            data: {
-                filter: newFilter,
-            },
-            category: 'log',
-            level: 'info',
-            timestamp: Date.now(),
-        });
-        if (newFilterStack.length > 0) {
-            const tabNode = {
-                leaf: false,
-                operator: 'and',
-                leftNode: null,
-                rightNode: null,
-            };
-            newFilterStack.push(tabNode);
-        }
-        const newItem = {
-            leaf: true,
-            operator: null,
-            leftNode: null,
-            rightNode: null,
-            value: newFilter,
-        };
-        newFilterStack.push(newItem);
-        handleFilterStackChange(newFilterStack, true);
-    };
-    const handleFilterStackChange = (newFilterStack, fetchData, updateStateStack = true) => {
-        if (newFilterStack.length > 0 || filterStack.length > 0) {
-            eventTracking?.addBreadcrumb?.({
-                message: 'Changed filter stack in ReportBuilder',
-                data: {
-                    filterStack: newFilterStack,
-                },
-                category: 'log',
-                level: 'info',
-                timestamp: Date.now(),
-            });
-        }
-        setFilterStack(newFilterStack);
-        if (newFilterStack.length === 0) {
-            setFilteredUniqueValues(null);
-        }
-        if (updateStateStack) {
-            setStateStack((prevStack) => [
-                ...prevStack,
-                { ...reportBuilderState, filterStack: newFilterStack },
-            ]);
-            setPoppedStateStack([]);
-        }
-        if (fetchData) {
-            fetchDataFromReportBuilderState({
-                state: {
-                    ...reportBuilderState,
-                    filterStack: newFilterStack,
-                },
-                filtersChanged: true,
-            });
-        }
-    };
-    const handlePivotChange = (newPivot, fetchData, updateStateStack = true) => {
-        if (newPivot || pivot) {
-            eventTracking?.addBreadcrumb?.({
-                message: 'Changed pivot in ReportBuilder',
-                data: {
-                    pivot: newPivot,
-                },
-                category: 'log',
-                level: 'info',
-                timestamp: Date.now(),
-            });
-        }
-        setPivot(newPivot ? setTypesOnPivot(newPivot, reportColumns) : null);
-        setPivotHint('');
-        setPivotError('');
-        if (!newPivot) {
-            setPivotData(null);
-            if (!fetchData) {
-                const formattedRows = formatRows(reportRows, reportColumns, false);
-                setFormattedRows(formattedRows);
-            }
-        }
-        if (updateStateStack) {
-            setStateStack((prevStack) => [
-                ...prevStack,
-                {
-                    ...reportBuilderState,
-                    pivot: newPivot,
-                },
-            ]);
-            setPoppedStateStack([]);
-        }
-        if (fetchData) {
-            fetchDataFromReportBuilderState({
-                state: {
-                    ...reportBuilderState,
-                    pivot: newPivot,
-                },
-            });
-        }
-    };
-    const updatePivot = async (changeField, fieldKey) => {
-        if (!client || !pivot) {
-            return;
-        }
-        let newPivot = { ...pivot };
-        setPivotError('');
-        if (fieldKey === 'sort') {
-            if (changeField &&
-                typeof changeField === 'object' &&
-                'sortField' in changeField &&
-                'sortDirection' in changeField) {
-                newPivot.sort = true;
-                newPivot.sortField = changeField.sortField;
-                newPivot.sortDirection = changeField.sortDirection;
-            }
-            else {
-                newPivot.sort = false;
-                newPivot.sortField = undefined;
-                newPivot.sortDirection = undefined;
-            }
-        }
-        else {
-            // @ts-ignore
-            newPivot[fieldKey] = changeField;
-        }
-        if (fieldKey === 'rowField') {
-            if (changeField === '' || changeField === undefined) {
-                setPivotColumnField(undefined);
-                // set all percentage aggregations to undefined
-                setPivotAggregations(pivotAggregations.map((agg) => ({
-                    ...agg,
-                    aggregationType: agg.aggregationType === 'percentage'
-                        ? undefined
-                        : agg.aggregationType,
-                })));
-            }
-        }
-        newPivot = setTypesOnPivot(newPivot, reportColumns);
-        if (newPivot.aggregations?.length === 0 ||
-            newPivot.aggregations?.some((agg) => !agg.aggregationType) ||
-            newPivot.aggregations?.some((agg) => !agg.valueField &&
-                agg.aggregationType !== 'count' &&
-                agg.aggregationType !== 'percentage')) {
-            return;
-        }
-        const { valid, reason } = isValidPivot(newPivot);
-        if (!valid) {
-            setPivotError(reason);
-            return;
-        }
-        handlePivotChange(newPivot, true);
-    };
-    const handleSortChange = (newSort, fetchData, updateStateStack = true) => {
-        if (newSort.length > 0 || sort.length > 0) {
-            eventTracking?.addBreadcrumb?.({
-                message: 'Changed sort in ReportBuilder',
-                data: {
-                    sort: newSort,
-                },
-                category: 'log',
-                level: 'info',
-                timestamp: Date.now(),
-            });
-        }
-        setSort(newSort);
-        if (updateStateStack) {
-            setStateStack((prevStack) => [
-                ...prevStack,
-                { ...reportBuilderState, sort: newSort },
-            ]);
-            setPoppedStateStack([]);
-        }
-        if (fetchData) {
-            fetchDataFromReportBuilderState({
-                state: {
-                    ...reportBuilderState,
-                    sort: newSort,
-                },
-            });
-        }
-    };
-    const handleLimitChange = (newLimit, fetchData, updateStateStack = true) => {
-        if (newLimit || limit) {
-            eventTracking?.addBreadcrumb?.({
-                message: 'Changed limit in ReportBuilder',
-                data: {
-                    limit: newLimit,
-                },
-                category: 'log',
-                level: 'info',
-                timestamp: Date.now(),
-            });
-        }
-        setLimit(newLimit);
-        if (updateStateStack) {
-            setStateStack((prevStack) => [
-                ...prevStack,
-                { ...reportBuilderState, limit: newLimit },
-            ]);
-            setPoppedStateStack([]);
-        }
-        if (fetchData) {
-            fetchDataFromReportBuilderState({
-                state: {
-                    ...reportBuilderState,
-                    limit: newLimit,
-                },
-                limitChanged: true,
-            });
-        }
-    };
-    const handleMultiStateChange = ({ state, fetchData, updateStateStack = true, report, skipPivotColumnFetch = false, }) => {
-        if (state.tables !== undefined) {
-            handleTablesChange(state.tables, false);
-        }
-        if (state.columns !== undefined) {
-            handleColumnsChange(state.columns, false, false, true);
-        }
-        if (state.filterStack !== undefined) {
-            handleFilterStackChange(state.filterStack, false, false);
-        }
-        if (state.pivot !== undefined) {
-            handlePivotChange(state.pivot, false, false);
-        }
-        if (state.sort !== undefined) {
-            handleSortChange(state.sort, false, false);
-        }
-        if (state.limit !== undefined) {
-            handleLimitChange(state.limit, false, false);
-        }
-        if (updateStateStack) {
-            setStateStack((prevStack) => [
-                ...prevStack,
-                { ...reportBuilderState, ...state },
-            ]);
-            setPoppedStateStack([]);
-        }
-        eventTracking?.addBreadcrumb?.({
-            message: 'Changed state in ReportBuilder',
-            data: {
-                state: { ...reportBuilderState, ...state },
-            },
-            category: 'log',
-            level: 'info',
-            timestamp: Date.now(),
-        });
-        if (fetchData) {
-            fetchDataFromReportBuilderState({
-                state: { ...reportBuilderState, ...state },
-                filtersChanged: !!state.filterStack,
-                limitChanged: !!state.limit,
-                tablesChanged: !!state.tables,
-                report,
-                skipPivotColumnFetch,
-            });
-        }
-    };
-    const handleUndo = () => {
-        if (stateStack.length <= 1) {
-            return;
-        }
-        const previousState = stateStack[stateStack.length - 2];
-        setPoppedStateStack((prevStack) => [
-            ...prevStack,
-            stateStack[stateStack.length - 1],
-        ]);
-        setStateStack((prevStack) => prevStack.slice(0, -1));
-        // Only fetch data if the previous state has columns
-        handleMultiStateChange({
-            state: previousState,
-            fetchData: previousState.columns.length > 0,
-            updateStateStack: false,
-        });
-    };
-    const handleRedo = () => {
-        if (poppedStateStack.length === 0) {
-            return;
-        }
-        const lastState = poppedStateStack[poppedStateStack.length - 1];
-        setStateStack((prevStack) => [...prevStack, lastState]);
-        setPoppedStateStack((prevStack) => prevStack.slice(0, -1));
-        // Only fetch data if the last state has columns
-        handleMultiStateChange({
-            state: lastState,
-            fetchData: lastState.columns.length > 0,
-            updateStateStack: false,
-        });
-    };
-    const fetchDataFromReportBuilderState = ({ state, filtersChanged, limitChanged, tablesChanged, report, skipPivotColumnFetch, }) => {
-        if (!client) {
-            return;
-        }
-        const ast = reportBuilderStateToAst(state, client.databaseType?.toLowerCase() || 'postgresql');
-        fetchReportFromASTHelper({
-            ast,
-            pivot: state.pivot,
-            previousReport: report,
-            requiresNewFilteredUniqueValues: filtersChanged || limitChanged,
-            requiresNewUnfilteredUniqueValues: tablesChanged,
-            skipPivotColumnFetch,
-        });
-    };
-    const fetchReportFromASTHelper = async ({ ast, pivot, previousReport = tempReport, requiresNewFilteredUniqueValues = false, requiresNewUnfilteredUniqueValues = false, skipPivotColumnFetch = false, }) => {
-        let reportBuilderInfo = undefined;
-        setErrorMessage('');
-        const schema = filteredSchema;
-        try {
-            if (!client || reportBuilderLoading) {
-                return;
-            }
-            setReportBuilderLoading(true);
-            reportBuilderInfo = await fetchReportBuilderDataFromAST({
-                baseAst: ast,
-                schema,
-                client,
-                tenants,
-                pivot: pivot ?? undefined,
-                skipPivotColumnFetch,
-                previousRelevant: {
-                    uniqueStringsByTable: unfilteredUniqueValues,
-                    dateRanges: dateRanges ?? {},
-                    uniqueStringsByColumn: requiresNewFilteredUniqueValues
-                        ? {}
-                        : columnUniqueValues,
-                },
-                requiresNewFilteredUniqueValues,
-                report: previousReport,
-                customFields: schemaData.customFields,
-                skipUniqueValues: true,
-                skipRowCount: true,
-                processing: { page: REPORT_BUILDER_PAGINATION },
-                dashboardName: destinationDashboard,
-                getToken,
-                eventTracking,
-            });
-            if (reportBuilderInfo.error) {
-                throw new Error(reportBuilderInfo.error);
-            }
-        }
-        catch (err) {
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching report',
-                errorMessage: err.message,
-                errorStack: err.stack,
-                errorData: {
-                    caller: 'ReportBuilder',
-                    function: 'fetchReportFromASTHelper',
-                },
-            });
-            if (err instanceof Error) {
-                setErrorMessage(err.message);
-                setReportBuilderLoading(false);
-                return { error: true, message: err.message, rows: [] };
-            }
-            setReportBuilderLoading(false);
-            setErrorMessage('Failed to fetch');
-            return { error: true, message: 'Failed to fetch', rows: [] };
-        }
-        if (!reportBuilderInfo) {
-            setReportBuilderLoading(false);
-            setErrorMessage('Failed to fetch');
-            return;
-        }
-        const cleanedReport = await cleanDashboardItem({
-            item: reportBuilderInfo.report,
-            dashboardFilters: [],
-            getToken,
-            client,
-            customFields: schemaData.customFields,
-            skipPivotFetch: true,
-            tenants,
-            eventTracking,
-        });
-        // set tempReport
-        setTempReport({
-            ...cleanedReport,
-            pagination: REPORT_BUILDER_PAGINATION,
-        });
-        setActiveQuery(reportBuilderInfo.query);
-        setQueryOutOfSync(false);
-        // table data
-        fetchRowCountFromAST(ast, ast.where);
-        setReportRows(reportBuilderInfo.rows);
-        setFormattedRows(reportBuilderInfo.formattedRows);
-        resetProcessing();
-        if (!(client.databaseType?.toLowerCase() === 'bigquery') ||
-            (reportBuilderInfo.rows && reportBuilderInfo.rows.length > 0)) {
-            setReportColumns(reportBuilderInfo.columns);
-        }
-        setPivotData(reportBuilderInfo.pivotData);
-        if (reportBuilderInfo.pivot) {
-            setPivotRowField(reportBuilderInfo.pivot.rowField);
-            setPivotColumnField(reportBuilderInfo.pivot.columnField);
-            setPivotAggregations(reportBuilderInfo.pivot.aggregations ?? [
-                {
-                    valueField: reportBuilderInfo.pivot.valueField,
-                    valueField2: reportBuilderInfo.pivot.valueField2,
-                    aggregationType: reportBuilderInfo.pivot.aggregationType,
-                },
-            ]);
-            setPivotLimit(reportBuilderInfo.pivot.rowLimit);
-            setPivotSort(reportBuilderInfo.pivot.sort &&
-                reportBuilderInfo.pivot.sortField &&
-                reportBuilderInfo.pivot.sortDirection
-                ? {
-                    sortField: reportBuilderInfo.pivot.sortField,
-                    sortDirection: reportBuilderInfo.pivot.sortDirection.toUpperCase(),
-                }
-                : undefined);
-        }
-        setPivot(reportBuilderInfo.pivot);
-        setPivotHint(reportBuilderInfo.pivotHint);
-        setDateRanges(reportBuilderInfo.dateRanges);
-        const tableNames = reportBuilderInfo.tables;
-        const columnInfo = tableNames.flatMap((table) => {
-            const tableInfo = schema.find((tableInfo) => tableInfo.name === table);
-            if (!tableInfo) {
-                return [];
-            }
-            return tableInfo.columns.map((col) => ({ ...col, table }));
-        });
-        setReportBuilderLoading(false);
-        // fetch unique values after everything else since it is the most expensive
-        try {
-            let uniqueStrings = filteredUniqueValues ?? unfilteredUniqueValues;
-            let uniqueValuesByColumn = columnUniqueValues;
-            if (requiresNewUnfilteredUniqueValues) {
-                fetchGlobalUniqueValues(columnInfo, tableNames);
-            }
-            if (requiresNewFilteredUniqueValues) {
-                if (reportBuilderInfo.pivot && !skipPivotColumnFetch) {
-                    // if there's a pivot, these values would have had to been fetched
-                    uniqueStrings = reportBuilderInfo.uniqueStringsByTable;
-                    uniqueValuesByColumn = reportBuilderInfo.uniqueStringsByColumn;
-                }
-                else {
-                    setFilteredUniqueValuesIsLoading(true);
-                    const starQuery = await fetchSqlQuery(createSelectStarFromAst(ast), client, getToken);
-                    uniqueStrings = await getUniqueStringValuesByTable({
-                        columns: columnInfo,
-                        tables: tableNames,
-                        client,
-                        tenants,
-                        customFields: schemaData.customFields ?? undefined,
-                        withExceededColumns: true,
-                        dashboardName: destinationDashboard,
-                        queryTemplate: starQuery.query,
-                        getToken,
-                        eventTracking,
-                    });
-                    uniqueValuesByColumn = {};
-                    reportBuilderInfo.reportBuilderColumns.forEach((col) => {
-                        uniqueValuesByColumn[col.alias || col.field] =
-                            uniqueStrings[col.table || '']?.[col.field] ?? [];
-                    });
-                }
-            }
-            setFilteredUniqueValues(uniqueStrings);
-            setFilteredUniqueValuesIsLoading(false);
-            setColumnUniqueValues(uniqueValuesByColumn);
-        }
-        catch (err) {
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching unique values',
-                errorMessage: err.message,
-                errorStack: err.stack,
-                errorData: {
-                    caller: 'ReportBuilder',
-                    function: 'fetchReportFromASTHelper',
-                },
-            });
-            if (err instanceof Error) {
-                setErrorMessage(err.message);
-                return { error: true, message: err.message, rows: [] };
-            }
-            setErrorMessage('Failed to fetch unique values');
-            return {
-                error: true,
-                message: 'Failed to fetch unique values',
-                rows: [],
-            };
-        }
-    };
-    const fetchRowCountFromAST = async (ast, where) => {
-        setRowCountIsLoading(true);
-        if (!client) {
-            return;
-        }
-        const tableData = await fetchTableByAST({ ...ast, where }, client, getToken, tenants, eventTracking, destinationDashboard, { page: REPORT_BUILDER_PAGINATION }, schemaData.customFields, false, true);
-        if (tableData.rowCount) {
-            setNumberOfRows(tableData.rowCount);
-            // @ts-ignore
-            setTempReport((tempReport) => ({
-                ...tempReport,
-                rowCount: tableData.rowCount,
-            }));
-        }
-        setRowCountIsLoading(false);
-    };
-    const fetchAstFromPromptHelper = async (overridePrompt) => {
-        let astInfo = {};
-        const prompt = overridePrompt || aiPrompt;
-        if (!client) {
-            return;
-        }
-        if (!prompt) {
-            setErrorMessage('Please supply a prompt.');
-            return;
-        }
-        try {
-            setReportBuilderLoading(true);
-            setAskAILoading(true);
-            setErrorMessage('');
-            astInfo = await fetchAndProcessASTFromPrompt({
-                aiPrompt: prompt,
-                schema: filteredSchema,
-                client,
-                prevPivot: pivot ?? undefined,
-                currentQuery: activeQuery,
-                prevTable: tables?.[0]?.name,
-                dashboardName: destinationDashboard,
-                tenants,
-                getToken,
-                eventTracking,
-            });
-            if (astInfo.error) {
-                throw new Error(astInfo.error);
-            }
-        }
-        catch (err) {
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching ast',
-                errorMessage: err.message,
-                errorStack: err.stack,
-                errorData: {
-                    caller: 'ReportBuilder',
-                    function: 'fetchAstFromPromptHelper',
-                },
-            });
-            if (err instanceof Error) {
-                setErrorMessage(err.message);
-            }
-            setReportBuilderLoading(false);
-            setAskAILoading(false);
-            return;
-        }
-        // check if pivot works with ReportBuilder constraints
-        if (Object.keys(columnUniqueValues).length > 0 &&
-            astInfo.pivot &&
-            !isValidPivotForReport(astInfo.pivot, columnUniqueValues, reportColumns)) {
-            astInfo.pivot = null;
-            astInfo.ast.groupby = null;
-        }
-        setAskAILoading(false);
-        const newState = astToReportBuilderState(astInfo.ast, client.databaseType || 'postgresql', filteredSchema);
-        handleMultiStateChange({
-            state: { ...newState, pivot: astInfo.pivot },
-            fetchData: true,
-        });
-    };
-    const fetchGlobalUniqueValues = async (columns, tables) => {
-        if (!client) {
-            return;
-        }
-        setUnfilteredUniqueValuesIsLoading(true);
-        const uniqueStrings = await getUniqueStringValuesByTable({
-            columns,
-            tables,
-            client,
-            getToken,
-            eventTracking,
-            tenants,
-            customFields: schemaData.customFields ?? undefined,
-            withExceededColumns: true,
-            dashboardName: destinationDashboard,
-        });
-        setUnfilteredUniqueValues(uniqueStrings);
-        setUnfilteredUniqueValuesIsLoading(false);
-    };
-    const fetchQueryFromReportBuilderState = async (state) => {
-        if (!client) {
-            return '';
-        }
-        const ast = reportBuilderStateToAst(state, client.databaseType?.toLowerCase() || 'postgresql');
-        const query = await fetchSqlQuery(ast, client, getToken);
-        setActiveQuery(query.query);
-        return query.query;
-    };
-    const resetProcessing = () => {
-        setCurrentProcessing({ page: REPORT_BUILDER_PAGINATION });
-        setPreviousPage(0);
-    };
-    const handlePagination = async (processing) => {
-        try {
-            if (!client) {
-                return;
-            }
-            const isPivotPagination = !!(pivot && pivotData);
-            setErrorMessage('');
-            setTableLoading(true);
-            const tableInfo = await fetchResultsByQuery({
-                query: isPivotPagination ? pivotData.pivotQuery : activeQuery,
-                comparisonQuery: pivot && pivotData ? pivotData.comparisonPivotQuery : undefined,
-                client,
-                tenants,
-                processing,
-                customFields: schemaData.customFields,
-                rowsOnly: true,
-                dashboardName: destinationDashboard,
-                pivot: pivot,
-                getPivotRowCount: false,
-                getToken,
-                eventTracking,
-            });
-            if (tableInfo.error) {
-                throw new Error(tableInfo.error);
-            }
-            else if (tableInfo.rows.length === 0) {
-                throw new Error('No data found');
-            }
-            if (!isPivotPagination) {
-                const tempRows = [...reportRows, ...tableInfo.rows];
-                setReportRows(tempRows);
-                setFormattedRows(formatRowsFromReport({ rows: tempRows, columns: tableInfo.columns }));
-                setTempReport((tempReport) => ({
-                    ...tempReport,
-                    rows: tempRows,
-                    rowCount: tableInfo.rowCount ?? tempReport.rowCount,
-                }));
-            }
-            else {
-                const tempRows = [...pivotData.rows, ...tableInfo.rows];
-                setPivotData((oldPivotData) => {
-                    if (oldPivotData) {
-                        return {
-                            ...oldPivotData,
-                            rows: tempRows,
-                            columns: tableInfo.columns,
-                        };
-                    }
-                    return null;
-                });
-                setFormattedRows(formatRowsFromReport({ rows: tempRows, columns: tableInfo.columns }));
-            }
-            setTableLoading(false);
-        }
-        catch (e) {
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error fetching report',
-                errorMessage: e.message,
-                errorStack: e.stack,
-                errorData: {
-                    caller: 'ReportBuilder',
-                    function: 'handlePagination',
-                },
-            });
-            setTableLoading(false);
-            setErrorMessage('Failed to run SQL query: ' + e.message);
-            setReportRows([]);
-            setReportColumns([]);
-            return;
-        }
-    };
-    const onPageChange = (page) => {
-        const pagination = REPORT_BUILDER_PAGINATION;
-        if (currentProcessing.page &&
-            shouldFetchMore(pagination, page, previousPage, pivotData ? pivotData.rows.length : reportRows.length)) {
-            const newPagination = { ...currentProcessing.page, page };
-            const updatedProcessing = { ...currentProcessing, page: newPagination };
-            setCurrentProcessing(updatedProcessing);
-            handlePagination(updatedProcessing);
-        }
-        if (page > previousPage) {
-            setPreviousPage(page);
-        }
-    };
-    const onSortChange = (newSort, isPivotSort, isDelete) => {
-        if (!newSort.field) {
-            return;
-        }
-        if (pivot && isPivotSort) {
-            let newPivot = null;
-            if (isDelete) {
-                newPivot = {
-                    ...pivot,
-                    sort: undefined,
-                    sortField: undefined,
-                    sortDirection: undefined,
-                    sortFieldType: undefined,
-                };
-            }
-            else {
-                newPivot = {
-                    ...pivot,
-                    sort: true,
-                    sortField: newSort.field,
-                    sortDirection: newSort.direction,
-                    sortFieldType: reportColumns.find((col) => col.field === newSort.field)?.fieldType,
-                };
-            }
-            handlePivotChange(newPivot, true);
-        }
-        else {
-            const updatedSort = [...sort];
-            const existingSortIndex = updatedSort.findIndex((item) => item.field === newSort.field);
-            if (isDelete) {
-                if (existingSortIndex !== -1) {
-                    updatedSort.splice(existingSortIndex, 1);
-                }
-            }
-            else if (existingSortIndex !== -1) {
-                updatedSort[existingSortIndex] = {
-                    field: newSort.field,
-                    direction: newSort.direction,
-                };
-            }
-            else {
-                updatedSort.push({
-                    field: newSort.field,
-                    direction: newSort.direction,
-                });
-            }
-            handleSortChange(updatedSort, true);
-        }
-    };
-    const onLimitChange = (limit, isPivotLimit) => {
-        if (limit) {
-            if (pivot && isPivotLimit) {
-                const newPivot = { ...pivot, rowLimit: limit };
-                handlePivotChange(newPivot, true);
-            }
-            else {
-                handleLimitChange({ value: limit }, true);
-            }
-        }
-        else {
-            if (pivot && isPivotLimit) {
-                const newPivot = { ...pivot, rowLimit: undefined };
-                handlePivotChange(newPivot, true);
-            }
-            else {
-                handleLimitChange(null, true);
-            }
-        }
-    };
-    // Button events
-    const onSaveQuery = async () => {
-        let tempReportQuery = activeQuery;
-        if (queryOutOfSync) {
-            tempReportQuery =
-                await fetchQueryFromReportBuilderState(reportBuilderState);
-        }
-        const tempReportColumns = columns
-            .map((column) => {
-            return reportColumnsToStateColumns.find((col) => col.field === (column.alias || column.field));
-        })
-            .filter((col) => col !== undefined);
-        let customFieldColumns = [];
-        if (client && isSelectStar && schemaData.customFields) {
-            customFieldColumns = tables.flatMap((table) => {
-                return (schemaData.customFields?.[table.name || ''] || []).map((field) => field.field);
-            });
-        }
-        setTempReport({
-            ...tempReport,
-            ...(pivot
-                ? pivotFormData(pivot, reportColumnsToStateColumns, tempReport, tempReport.chartType, pivotData ?? undefined)
-                : {}),
-            id: TEMP_REPORT_ID,
-            dashboardName: destinationDashboard,
-            pivot: pivot,
-            yAxisFields: tempReport?.pivot && !pivot ? [] : tempReport?.yAxisFields,
-            columns: isSelectStar
-                ? // if SELECT *, filter out custom fields from tabular view
-                    // so Automatic Custom Fields can be applied
-                    tempReportColumns.filter((col) => {
-                        return !customFieldColumns.includes(col.field);
-                    })
-                : tempReportColumns,
-            columnInternal: isSelectStar
-                ? // if SELECT *, filter out custom fields from tabular view
-                    // so Automatic Custom Fields can be applied
-                    tempReportColumns.filter((col) => {
-                        return !customFieldColumns.includes(col.field);
-                    })
-                : tempReportColumns,
-            queryString: isSelectStar
-                ? convertQueryToSelectStar(tempReportQuery)
-                : tempReportQuery,
-            includeCustomFields: isSelectStar,
-            rows: reportRows,
-            pivotRows: pivotData?.rows,
-            pivotColumns: pivotData?.columns,
-            pivotRowCount: pivotData?.rowCount,
-            pivotQuery: pivotData?.pivotQuery,
-            comparisonPivotQuery: pivotData?.comparisonPivotQuery,
-            flags: tempReport?.flags,
-            chartType: 'table',
-        });
-    };
-    const onSaveReport = async () => {
-        let tempReportQuery = activeQuery;
-        if (queryOutOfSync) {
-            tempReportQuery =
-                await fetchQueryFromReportBuilderState(reportBuilderState);
-        }
-        onSaveChanges && onSaveChanges();
-        const tempReportColumns = columns
-            .map((column) => {
-            return reportColumnsToStateColumns.find((col) => col.field === (column.alias || column.field));
-        })
-            .filter((col) => col !== undefined);
-        let customFieldColumns = [];
-        if (client && isSelectStar && schemaData.customFields) {
-            customFieldColumns = tables.flatMap((table) => {
-                return (schemaData.customFields?.[table.name || ''] || []).map((field) => field.field);
-            });
-        }
-        setTempReport({
-            ...tempReport,
-            ...(pivot
-                ? pivotFormData(pivot, reportColumnsToStateColumns, tempReport, tempReport.chartType, pivotData ?? undefined)
-                : {}),
-            id: TEMP_REPORT_ID,
-            dashboardName: destinationDashboard,
-            pivot: pivot,
-            yAxisFields: tempReport?.pivot && !pivot ? [] : tempReport?.yAxisFields,
-            columns: isSelectStar
-                ? // if SELECT *, filter out custom fields from tabular view
-                    // so Automatic Custom Fields can be applied
-                    tempReportColumns.filter((col) => {
-                        return !customFieldColumns.includes(col.field);
-                    })
-                : tempReportColumns,
-            columnInternal: isSelectStar
-                ? // if SELECT *, filter out custom fields from tabular view
-                    // so Automatic Custom Fields can be applied
-                    tempReportColumns.filter((col) => {
-                        return !customFieldColumns.includes(col.field);
-                    })
-                : tempReportColumns,
-            queryString: isSelectStar
-                ? convertQueryToSelectStar(tempReportQuery)
-                : tempReportQuery,
-            includeCustomFields: isSelectStar,
-            rows: reportRows,
-            pivotRows: pivotData?.rows,
-            pivotColumns: pivotData?.columns,
-            pivotRowCount: pivotData?.rowCount,
-            pivotQuery: pivotData?.pivotQuery,
-            comparisonPivotQuery: pivotData?.comparisonPivotQuery,
-            flags: tempReport?.flags,
-        });
-    };
-    useEffect(() => {
-        if (!client) {
-            return;
-        }
-        if (client.featureFlags?.['recommendedPivotsDisabled'] !== undefined) {
-            setPivotRecommendationsEnabledState(!client.featureFlags?.['recommendedPivotsDisabled']);
-        }
-        if (!initialTableName && !reportId && client.publicKey) {
-            clearAllState();
-        }
-    }, [client]);
-    // Initialize ReportBuilder with a report
-    useEffect(() => {
-        const loadChart = async () => {
-            let report;
-            if (!client) {
-                return;
-            }
-            try {
-                if (!reportId) {
-                    throw new Error('Report ID is required');
-                }
-                report = allReportsById[reportId];
-                if (!report) {
-                    console.log('no report');
-                    throw new Error('Report not found');
-                }
-                const { ast: newAst, pivot: newPivot } = await fetchASTFromQuillReport(report, client, filteredSchema, getToken, eventTracking);
-                const initialState = astToReportBuilderState(newAst, client.databaseType || 'postgresql', filteredSchema);
-                setTempReport(report);
-                handleMultiStateChange({
-                    state: {
-                        ...initialState,
-                        pivot: newPivot ?? null,
-                    },
-                    fetchData: true,
-                    report,
-                    skipPivotColumnFetch: true,
-                });
-            }
-            catch (err) {
-                console.error(err);
-                eventTracking?.logError?.({
-                    type: 'bug', // TODO: determine type
-                    severity: 'high',
-                    message: 'Error fetching report',
-                    errorMessage: err.message,
-                    errorStack: err.stack,
-                    errorData: {
-                        caller: 'ReportBuilder',
-                        function: 'loadChart',
-                    },
-                });
-                setErrorMessage('Error when loading chart');
-            }
-        };
-        if (reportId && client) {
-            loadChart();
-        }
-    }, [allReportsById[reportId || ''], client]);
-    useEffect(() => {
-        if (initialTableName) {
-            const tableColumns = filteredSchema.find((table) => {
-                return table.name === initialTableName;
-            })?.columns ?? [];
-            if (tableColumns.length > 0) {
-                handleMultiStateChange({
-                    state: {
-                        ...EMPTY_REPORT_BUILDER_STATE,
-                        tables: [{ name: initialTableName }],
-                        columns: tableColumns.map((col) => ({
-                            field: col.field,
-                            table: initialTableName,
-                        })),
-                    },
-                    fetchData: true,
-                });
-            }
-        }
-    }, [filteredSchema, initialTableName]);
-    useEffect(() => {
-        if (!data && !dashboardIsLoading) {
-            // need dashboard to be in Context for filteredSchema
-            reload();
-        }
-    }, [data, dashboardIsLoading]);
-    return {
-        // Core state
-        columns,
-        tables,
-        sort,
-        limit,
-        filterStack,
-        state: reportBuilderState,
-        activeQuery,
-        tempReport,
-        stateStack,
-        poppedStateStack,
-        // UI state
-        openPopover,
-        setOpenPopover,
-        errorMessage,
-        unresolvedReportMessage,
-        loading,
-        tableLoading,
-        askAILoading,
-        rowCountIsLoading,
-        unfilteredUniqueValuesIsLoading,
-        filteredUniqueValuesIsLoading,
-        mssqlSortWarning,
-        // Data and results
-        reportColumnsToStateColumns,
-        reportRows,
-        formattedRows,
-        numberOfRows,
-        unfilteredUniqueValues,
-        filteredUniqueValues,
-        columnUniqueValues,
-        rowsPerPage: _rowsPerPage,
-        rowsPerRequest: _rowsPerRequest,
-        // Pivot state and handlers
-        pivot,
-        pivotData,
-        pivotRowField,
-        pivotColumnField,
-        pivotAggregations,
-        pivotLimit,
-        pivotSort,
-        pivotHint,
-        pivotError,
-        createdPivots,
-        recommendedPivots,
-        pivotPopUpTitle,
-        showPivotPopover,
-        isEditingPivot,
-        selectedPivotIndex,
-        pivotRecommendationsEnabledState,
-        setCreatedPivots,
-        setRecommendedPivots,
-        setPivotPopUpTitle,
-        setShowPivotPopover,
-        setIsEditingPivot,
-        setSelectedPivotIndex,
-        setPivotRowField,
-        setPivotColumnField,
-        setPivotAggregations,
-        setPivotLimit,
-        setPivotSort,
-        setPivotError,
-        handlePivotChange,
-        updatePivot,
-        // Schema and client info
-        filteredSchema,
-        foreignKeyMap,
-        schemaData,
-        client,
-        getToken,
-        reportId,
-        initialTableName,
-        destinationDashboard,
-        // AI features
-        aiPrompt,
-        setAiPrompt,
-        fetchAstFromPromptHelper,
-        // Action handlers
-        clearAllState,
-        handleMultiStateChange,
-        handleTablesChange,
-        handleColumnsChange,
-        handleFilterInsertion,
-        handleFilterStackChange,
-        handleUndo,
-        handleRedo,
-        onSortChange,
-        onLimitChange,
-        handleSortChange,
-        handleLimitChange,
-        onPageChange,
-        onSaveQuery,
-        onSaveReport,
-    };
-};
-export const useReportBuilder = ({ reportId, ownerDashboard, config, }) => {
-    const reportBuilder = useReportBuilderInternal({
-        reportId,
-        initialTableName: config?.initialTableName,
-        destinationDashboard: ownerDashboard,
-        pivotRecommendationsEnabled: config?.pivotRecommendationsEnabled,
-        onSaveChanges: config?.onSaveChanges,
-        rowsPerPage: config?.rowsPerPage,
-        rowsPerRequest: config?.rowsPerRequest,
-    });
-    // Column selection actions
-    const setColumns = (newColumns) => {
-        reportBuilder.handleColumnsChange(newColumns.map((col) => ({
-            field: col.field,
-            table: col.table,
-        })), true);
-    };
-    // // Filter actions
-    const setFilters = (filters) => {
-        const internalFilters = filters.map(convertCustomFilter);
-        // Create a filter tree with all filters chained with AND
-        const filterStack = internalFilters.reduce((stack, filter, index) => {
-            // Create leaf node for current filter
-            const filterNode = {
-                leaf: true,
-                operator: null,
-                leftNode: null,
-                rightNode: null,
-                value: filter,
-            };
-            // If not first filter, add an AND node
-            if (index > 0) {
-                stack.push({
-                    leaf: false,
-                    operator: 'and',
-                    leftNode: null,
-                    rightNode: null,
-                });
-            }
-            stack.push(filterNode);
-            return stack;
-        }, []);
-        reportBuilder.handleFilterStackChange(filterStack, true);
-    };
-    // // Pivot actions
-    const setPivot = (newPivot) => {
-        reportBuilder.handlePivotChange(newPivot, true);
-    };
-    const setSort = (sort) => {
-        reportBuilder.handleSortChange(sort, true);
-    };
-    // // Limit actions
-    const setLimit = (limit) => {
-        reportBuilder.handleLimitChange(limit, true);
-    };
-    // // AI actions
-    const applyAIPrompt = async (prompt) => {
-        reportBuilder.setAiPrompt(prompt);
-        await reportBuilder.fetchAstFromPromptHelper(prompt);
-    };
-    const cleanedSchema = useMemo(() => {
-        return reportBuilder.filteredSchema.reduce((acc, table) => {
-            acc[table.name] = table.columns;
-            return acc;
-        }, {});
-    }, [reportBuilder.filteredSchema]);
-    const cleanedFilterStack = useMemo(() => {
-        return reportBuilder.filterStack
-            .map((filter) => {
-            return filter.value
-                ? convertInternalFilterToFilter(filter.value)
-                : null;
-        })
-            .filter((filter) => filter !== null);
-    }, [reportBuilder.filterStack]);
-    return {
-        reportBuilder,
-        state: {
-            schema: cleanedSchema,
-            columns: reportBuilder.columns,
-            filters: cleanedFilterStack,
-            pivot: reportBuilder.pivot,
-            sort: reportBuilder.sort,
-            limit: reportBuilder.limit,
-            reportBuilderLoading: reportBuilder.loading,
-            tableLoading: reportBuilder.tableLoading,
-            tableRows: reportBuilder.formattedRows,
-            tableColumns: reportBuilder.pivot && reportBuilder.pivotData
-                ? reportBuilder.pivotData.columns
-                : reportBuilder.reportColumnsToStateColumns,
-            tableRowsCount: reportBuilder.pivot && reportBuilder.pivotData
-                ? reportBuilder.pivotData.rowCount
-                : reportBuilder.numberOfRows,
-            errorMessage: reportBuilder.errorMessage,
-        },
-        actions: {
-            setColumns,
-            setFilters,
-            setPivot,
-            setSort,
-            setLimit,
-            onPageChange: reportBuilder.onPageChange,
-            applyAIPrompt,
-        },
-    };
-};