@quillsql/react 2.14.16 → 2.15.0

package/dist/esm/hooks/useReportBuilder.js

@@ -0,0 +1,1490 @@
+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,
+        },
+    };
+};