@quillsql/react 2.15.2 → 2.15.4

package/dist/esm/hooks/useDashboard.js

@@ -1,876 +0,0 @@
-import { useContext, useEffect, useMemo, useRef } from 'react';
-import { ClientContext, DashboardConfigContext, DashboardContext, DashboardFiltersContext, EventTrackingContext, FetchContext, ReportFiltersContext, ReportsContext, TenantContext, } from '../Context';
-import { convertPresetOptionsToSelectableList, PRIMARY_RANGE, } from '../DateRangePicker/dateRangePickerUtils';
-import { convertCustomFilter, InternalDashboardFilterType, StringFilterType, convertInternalDashboardFilterToDashboardFilter, } from '../models/Filter';
-import { createDefaultDateFilter } from '../utils/filterProcessing';
-import { convertInternalReportToReport, fetchReport } from '../utils/report';
-import { mergeComparisonRange } from '../utils/merge';
-import { quillFetch } from '../utils/dataFetcher';
-export const useDashboardInternal = (dashboardName, customFilters) => {
-    const [dashboard] = useContext(DashboardContext);
-    const { dashboardConfig, isLoading: isDashboardsLoading, loadDashboard, dashboardConfigDispatch, } = useContext(DashboardConfigContext);
-    const { dashboardFilters, loadFiltersForDashboard } = useContext(DashboardFiltersContext);
-    //TODO: handle error states
-    // const [error, setError] = useState<any>(null);
-    const [client, isClientLoading] = useContext(ClientContext);
-    const { quillFetchWithToken } = useContext(FetchContext);
-    const { eventTracking } = useContext(EventTrackingContext);
-    const loading = useMemo(() => {
-        return (!dashboardName ||
-            isClientLoading ||
-            isDashboardsLoading ||
-            dashboardConfig[dashboardName]?.loading);
-    }, [isClientLoading, dashboardConfig, dashboardName, isDashboardsLoading]);
-    const populatedDashboardFilters = useMemo(() => {
-        return dashboardName && dashboardFilters[dashboardName] !== undefined
-            ? Object.values(dashboardFilters[dashboardName] ?? {}).map((f) => f.filter)
-            : null;
-    }, [dashboardFilters, dashboardName]);
-    const handleReload = async (overrideDashboardName, fetchFromServer = false, reportAction, overrideFilters) => {
-        if (!dashboardName)
-            return;
-        if (overrideFilters) {
-            // Pull the date filter out of the override filters, process it, and prepend it to the filters
-            const dateFilter = overrideFilters.filters.find((f) => f.filterType === 'date_range');
-            loadFiltersForDashboard(dashboardName, [
-                ...(dateFilter
-                    ? [
-                        {
-                            ...dateFilter,
-                            dateField: [
-                                ...new Map(Object.values(dashboardConfig[overrideDashboardName ?? dashboardName]
-                                    ?.config.sections ?? {})
-                                    .flat()
-                                    .map((report) => {
-                                    const key = JSON.stringify(report.dateField);
-                                    return [key, report.dateField];
-                                })).values(),
-                            ],
-                        },
-                    ]
-                    : []),
-                ...(overrideFilters.filters.filter((f) => f.filterType !== 'date_range') ?? []),
-            ], overrideFilters.editedFilterLabel, customFilters);
-            if (!overrideFilters.refetchReports)
-                return;
-        }
-        const updatedDashboard = await loadDashboard(overrideDashboardName ?? dashboardName, fetchFromServer, reportAction);
-        if (!fetchFromServer &&
-            Object.keys(dashboardFilters[dashboardName] ?? {}).length &&
-            // there exists no non date filter that has undefined options
-            Object.values(dashboardFilters[dashboardName] ?? {}).every((filter) => filter.filter.filterType === InternalDashboardFilterType.Date ||
-                filter.filter.options)) {
-            return;
-        }
-        if (overrideFilters)
-            return;
-        const dateFilter = updatedDashboard?.dateFilter
-            ? createDefaultDateFilter(updatedDashboard.dateFilter, Object.values(dashboard?.sections ?? {}).flat(), dashboardName)
-            : undefined;
-        // Append dateFilter to the filters unless it's undefined
-        loadFiltersForDashboard(dashboardName, [
-            ...(dateFilter ? [dateFilter] : []),
-            ...(updatedDashboard?.filters?.map((filter) => ({
-                ...filter,
-                query: undefined,
-            })) ?? []),
-        ], undefined, customFilters);
-    };
-    const setSectionOrder = async (sectionOrder) => {
-        if (!client || !dashboardName)
-            return;
-        if (dashboardConfig[dashboardName]) {
-            const newSections = sectionOrder.reduce((acc, section) => {
-                acc[section.section] = section.reportOrder
-                    .map((id, index) => {
-                    return dashboard?.[dashboardName]?.[id]
-                        ? { ...dashboard[dashboardName][id], id: id, order: index }
-                        : null;
-                })
-                    .filter((r) => r);
-                return acc;
-            }, {});
-            dashboardConfigDispatch({
-                type: 'UPDATE_DASHBOARD',
-                id: dashboardName,
-                data: {
-                    config: {
-                        ...dashboardConfig[dashboardName].config,
-                        sections: newSections,
-                        sectionOrder: sectionOrder?.map((section) => ({
-                            ...section,
-                            _id: section._id ?? 'temp_section_id_' + Date.now().toString(),
-                        })) ?? [],
-                    },
-                    loading: false,
-                },
-            });
-            const body = {
-                task: 'set-section-order',
-                clientId: client.clientId,
-                dashboardName,
-                sectionOrder,
-            };
-            try {
-                const response = await quillFetchWithToken({
-                    client,
-                    task: 'set-section-order',
-                    metadata: body,
-                });
-                Object.entries(response?.data?.newIds ?? {}).forEach(([section, newId]) => {
-                    dashboardConfigDispatch({
-                        type: 'UPDATE_DASHBOARD',
-                        id: dashboardName,
-                        data: {
-                            config: {
-                                ...dashboardConfig[dashboardName]?.config,
-                                sections: newSections,
-                                sectionOrder: sectionOrder.map((s) => {
-                                    return {
-                                        ...s,
-                                        _id: s.section === section ? newId : s._id,
-                                    };
-                                }),
-                            },
-                            loading: false,
-                        },
-                    });
-                });
-            }
-            catch (e) {
-                console.error(e);
-                eventTracking?.logError?.({
-                    type: 'bug', // TODO: determine type
-                    severity: 'high',
-                    message: 'Error setting section order',
-                    errorMessage: e.message,
-                    errorStack: e.stack,
-                    errorData: {
-                        caller: 'useDashboard',
-                        function: 'setSectionOrder',
-                    },
-                });
-            }
-        }
-    };
-    function isDashboardFilterLoading(filterName) {
-        if (!dashboardName)
-            return true;
-        return dashboardFilters[dashboardName]?.[filterName]?.loading;
-    }
-    return {
-        data: loading || !dashboardName
-            ? null
-            : (dashboardConfig[dashboardName]?.config ?? null),
-        dashboardFilters: populatedDashboardFilters,
-        isLoading: loading,
-        isDashboardFilterLoading,
-        reload: handleReload,
-        setSectionOrder,
-    };
-};
-export const useDashboardReports = (dashboardName) => {
-    const [dashboard, dispatch] = useContext(DashboardContext);
-    const { reportsDispatch } = useContext(ReportsContext);
-    const dashboardReports = dashboardName ? dashboard[dashboardName] : {};
-    const updateReport = (data) => {
-        if (!dashboardName)
-            throw new Error('No dashboard name provided for updateReport');
-        if (!data.id)
-            throw new Error('No report id provided for updateReport');
-        dispatch({
-            type: 'UPDATE_DASHBOARD_ITEM',
-            id: data.id,
-            dashboard: dashboardName,
-            data,
-        });
-        reportsDispatch({
-            type: 'UPDATE_REPORT',
-            id: data.id,
-            data,
-        });
-    };
-    const addReport = (data) => {
-        if (!dashboardName)
-            throw new Error('No dashboard name provided for addReport');
-        dispatch({
-            type: 'ADD_DASHBOARD_ITEM',
-            id: data.id,
-            dashboard: dashboardName,
-            data,
-        });
-        reportsDispatch({
-            type: 'ADD_REPORT',
-            id: data.id,
-            data,
-        });
-    };
-    return {
-        dashboardReports: dashboardReports ?? {},
-        updateReport,
-        addReport,
-    };
-};
-export const useAllReports = () => {
-    const { reports } = useContext(ReportsContext);
-    const [dashboard] = useContext(DashboardContext);
-    const allReportsById = useMemo(() => {
-        const reportMap = Object.values(dashboard).reduce((acc, d) => {
-            Object.values(d).forEach((report) => {
-                acc[report.id] = report;
-            });
-            return acc;
-        }, {});
-        Object.values(reports).forEach((report) => {
-            reportMap[report.id] = report;
-        });
-        return reportMap;
-    }, [reports, dashboard]);
-    return {
-        allReportsById,
-    };
-};
-export const useDashboards = () => {
-    const [dashboardReports, dashboardDispatch] = useContext(DashboardContext);
-    const { dashboardConfig, isLoading: isDashboardsLoading, dashboardConfigDispatch, } = useContext(DashboardConfigContext);
-    const { dashboardFilters, loadFiltersForDashboard, dispatch: dashboardFiltersDispatch, } = useContext(DashboardFiltersContext);
-    const { reportsDispatch } = useContext(ReportsContext);
-    const { reportFiltersDispatch } = useContext(ReportFiltersContext);
-    const [client, isLoading] = useContext(ClientContext);
-    const { quillFetchWithToken } = useContext(FetchContext);
-    const { eventTracking } = useContext(EventTrackingContext);
-    const dashboards = useMemo(() => {
-        return Object.values(dashboardConfig)
-            .map((dashboard) => {
-            return {
-                name: dashboard.config.name,
-                id: dashboard.config.dashboardId,
-                reports: Object.values(dashboard.config.sections ?? {}).flat(),
-                tenantKeys: dashboard.config.tenantKeys,
-                createdAt: dashboard.config.createdAt,
-                sectionOrder: dashboard.config.sectionOrder,
-            };
-        })
-            .sort((a, b) => (a.createdAt?.getTime() ?? 0) - (b.createdAt?.getTime() ?? 0));
-    }, [dashboardConfig]);
-    const createDashboard = async ({ name, filters, dateFilter, dashboardOwners, }) => {
-        if (!client)
-            return;
-        if (dashboardOwners?.some((key) => !key)) {
-            throw new Error('Dashboard owners cannot be empty or undefined');
-        }
-        dashboardConfigDispatch({
-            type: 'UPDATE_DASHBOARD',
-            id: name,
-            data: {
-                config: {
-                    tenantKeys: dashboardOwners,
-                    dashboardId: name,
-                    name,
-                    filters,
-                    dateFilter,
-                },
-                loading: true,
-            },
-        });
-        const body = {
-            newDashboardName: name.trim(),
-            filters,
-            dateFilter,
-            name: name.trim(),
-            task: 'edit-dashboard',
-            clientId: client.clientId,
-            tenantKeys: dashboardOwners,
-        };
-        try {
-            const updated = await quillFetchWithToken({
-                client,
-                task: 'edit-dashboard',
-                metadata: body,
-            });
-            eventTracking?.logEvent?.('create-dashboard', {
-                dashboardName: name,
-            });
-            if (filters.length > 0 || dateFilter) {
-                eventTracking?.logEvent?.('update-dashboard-filters', {
-                    dashboardName: name,
-                    numFilters: filters.length + (dateFilter ? 1 : 0),
-                });
-            }
-            dashboardConfigDispatch({
-                type: 'UPDATE_DASHBOARD',
-                id: name,
-                data: {
-                    config: {
-                        ...updated.data.dashboard,
-                        createdAt: new Date(updated.data.dashboard.createdAt),
-                    },
-                    loading: false,
-                },
-            });
-        }
-        catch (e) {
-            console.error(e);
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error creating dashboard',
-                errorMessage: e.message,
-                errorStack: e.stack,
-                errorData: {
-                    caller: 'useDashboards',
-                    function: 'createDashboard',
-                },
-            });
-        }
-    };
-    const updateDashboard = async (name, { newName, filters, dateFilter, customFilters, tenantKeys, }) => {
-        if (!client)
-            return;
-        if (tenantKeys?.some((key) => !key)) {
-            throw new Error('Tenant keys cannot be empty or undefined');
-        }
-        const dashboard = dashboardConfig[name]?.config;
-        dashboardConfigDispatch({
-            type: 'DELETE_DASHBOARD',
-            id: name,
-        });
-        const oldFilters = dashboardFilters[name];
-        dashboardFiltersDispatch({
-            type: 'DELETE_DASHBOARD_FILTERS',
-            dashboardName: name,
-        });
-        const body = {
-            newDashboardName: newName.trim(),
-            filters,
-            dateFilter: dateFilter ?? null,
-            name: name.trim(),
-            task: 'edit-dashboard',
-            clientId: client.clientId,
-            tenantKeys,
-        };
-        try {
-            const updated = await quillFetchWithToken({
-                client,
-                task: 'edit-dashboard',
-                metadata: body,
-            });
-            eventTracking?.logEvent?.('update-dashboard', {
-                dashboardName: updated.data.dashboard.name,
-                dashboardId: updated.data.dashboard.dashboardId,
-            });
-            if (filters.length > 0 || dateFilter) {
-                eventTracking?.logEvent?.('update-dashboard-filters', {
-                    dashboardName: name,
-                    numFilters: filters.length + (dateFilter ? 1 : 0),
-                });
-            }
-            dashboardConfigDispatch({
-                type: 'UPDATE_DASHBOARD',
-                id: updated.data.dashboard.name,
-                data: {
-                    config: {
-                        ...dashboard,
-                        ...updated.data.dashboard,
-                        dateFilter: updated.data.dashboard.dateFilter
-                            ? {
-                                ...updated.data.dashboard.dateFilter,
-                                presetOptions: updated.data.dashboard.dateFilter.presetOptions?.map((preset) => ({
-                                    ...preset,
-                                    loopStart: preset.loopStart
-                                        ? new Date(preset.loopStart)
-                                        : undefined,
-                                    loopEnd: preset.loopEnd
-                                        ? new Date(preset.loopEnd)
-                                        : undefined,
-                                })),
-                                defaultPresetRanges: updated.data.dashboard.dateFilter.defaultPresetRanges?.map((preset) => ({
-                                    ...preset,
-                                    loopStart: preset.loopStart
-                                        ? new Date(preset.loopStart)
-                                        : undefined,
-                                    loopEnd: preset.loopEnd
-                                        ? new Date(preset.loopEnd)
-                                        : undefined,
-                                })),
-                            }
-                            : undefined,
-                        createdAt: new Date(updated.data.dashboard.createdAt),
-                    },
-                    loading: false,
-                },
-            });
-            // For each report in the updated.dashboard.sections, set the filterMap
-            Object.values(updated.data.dashboard.sections ?? {})
-                .flat()
-                .forEach((report) => {
-                dashboardDispatch({
-                    type: 'ADD_DASHBOARD_ITEM',
-                    id: report._id,
-                    dashboard: newName,
-                    data: {
-                        ...dashboardReports[report._id],
-                        id: report._id,
-                        filterMap: report.filterMap,
-                        dashboardName: newName,
-                        rows: undefined,
-                    },
-                });
-                dashboardDispatch({
-                    type: 'REMOVE_DASHBOARD_ITEM',
-                    id: report._id,
-                });
-                reportsDispatch({
-                    type: 'DELETE_REPORT',
-                    id: report._id,
-                });
-                reportFiltersDispatch({
-                    type: 'CLEAR_REPORT_FILTERS',
-                    id: report._id,
-                });
-            });
-            if (dashboardFilters[name])
-                dashboardFiltersDispatch({
-                    type: 'ADD_DASHBOARD_FILTERS',
-                    dashboardName: newName,
-                    data: dashboardFilters[name],
-                });
-            const range = convertPresetOptionsToSelectableList(updated.data.dashboard.dateFilter?.presetOptions ?? [], updated.data.dashboard.dateFilter?.defaultPresetRanges ?? []).find((option) => option.value ===
-                updated.data.dashboard.dateFilter?.primaryRange?.value) ??
-                PRIMARY_RANGE[updated.data.dashboard.dateFilter?.primaryRange?.value ??
-                    'LAST_30_DAYS'] ??
-                PRIMARY_RANGE['LAST_30_DAYS'];
-            const updatedDateFilter = updated.data.dashboard.dateFilter
-                ? {
-                    ...updated.data.dashboard.dateFilter,
-                    presetOptions: updated.data.dashboard.dateFilter.presetOptions?.map((preset) => ({
-                        ...preset,
-                        loopStart: preset.loopStart
-                            ? new Date(preset.loopStart)
-                            : undefined,
-                        loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : undefined,
-                    })),
-                    defaultPresetRanges: updated.data.dashboard.dateFilter.defaultPresetRanges?.map((preset) => ({
-                        ...preset,
-                        loopStart: preset.loopStart
-                            ? new Date(preset.loopStart)
-                            : undefined,
-                        loopEnd: preset.loopEnd
-                            ? new Date(preset.loopEnd)
-                            : undefined,
-                    })),
-                    dashboardName: updated.data.dashboard.name,
-                    preset: updated.data.dashboard.dateFilter.primaryRange,
-                    filterType: InternalDashboardFilterType.Date,
-                    dateField: [
-                        ...new Map(Object.values(dashboardConfig[updated.data.dashboard.name]?.config
-                            .sections ?? {})
-                            .flat()
-                            .map((report) => {
-                            const key = JSON.stringify(report.dateField);
-                            return [key, report.dateField];
-                        })).values(),
-                    ],
-                    startDate: !range.startDate || range.startDate instanceof Date
-                        ? range.startDate
-                        : new Date(range.startDate), // when range.startDate is a string
-                    endDate: !range.endDate || range.endDate instanceof Date
-                        ? range.endDate
-                        : new Date(range.endDate), // when range.endDate is a string
-                }
-                : undefined;
-            const newFilters = [
-                ...(updatedDateFilter ? [updatedDateFilter] : []),
-                ...(updated.data.dashboard.filters.map((f) => ({
-                    ...f,
-                    selectedValue: oldFilters?.[f.label]?.filter
-                        ?.selectedValue,
-                    values: oldFilters?.[f.label]?.filter?.values,
-                    operator: oldFilters?.[f.label]?.filter?.operator,
-                })) ?? []),
-            ].map((f) => {
-                if (f.filterType === InternalDashboardFilterType.Date) {
-                    return {
-                        ...f,
-                        startDate: dashboardFilters[name]?.[f.label]
-                            ?.filter?.startDate,
-                        endDate: dashboardFilters[name]?.[f.label]
-                            ?.filter?.endDate,
-                        preset: dashboardFilters[name]?.[f.label]
-                            ?.filter?.preset,
-                    };
-                }
-                else {
-                    return {
-                        ...f,
-                        selectedValue: dashboardFilters[name]?.[f.label]
-                            ?.filter?.selectedValue,
-                    };
-                }
-            });
-            dashboardFiltersDispatch({
-                type: 'DELETE_DASHBOARD_FILTERS',
-                dashboardName: name,
-            });
-            loadFiltersForDashboard(updated.data.dashboard.name, newFilters, undefined, customFilters);
-        }
-        catch (e) {
-            console.error(e);
-            eventTracking?.logError?.({
-                type: 'bug', // TODO: determine type
-                severity: 'high',
-                message: 'Error updating dashboard',
-                errorMessage: e.message,
-                errorStack: e.stack,
-                errorData: {
-                    caller: 'useDashboards',
-                    function: 'updateDashboard',
-                },
-            });
-        }
-    };
-    const deleteDashboard = async (name) => {
-        if (!client)
-            return;
-        await quillFetchWithToken({
-            client,
-            task: 'delete-dashboard',
-            metadata: {
-                clientId: client.clientId,
-                databaseType: client.databaseType,
-                name,
-            },
-        });
-        dashboardConfigDispatch({
-            type: 'DELETE_DASHBOARD',
-            id: name,
-        });
-    };
-    return {
-        dashboards: isLoading || isDashboardsLoading ? null : dashboards,
-        isLoading: isLoading || isDashboardsLoading,
-        createDashboard,
-        updateDashboard,
-        deleteDashboard,
-    };
-};
-// Dev facing
-export const useDashboard = (dashboardName) => {
-    const { data, dashboardFilters, reload, isLoading } = useDashboardInternal(dashboardName);
-    const { customFilterDispatch } = useContext(DashboardFiltersContext);
-    const { reportsDispatch, reportsLoadingStateDispatch } = useContext(ReportsContext);
-    const initialLoad = useRef(true);
-    const fetchedInitialReports = useRef(false);
-    const [client] = useContext(ClientContext);
-    const { tenants, flags } = useContext(TenantContext);
-    const { getToken } = useContext(FetchContext);
-    const { customReportFilters } = useContext(ReportFiltersContext);
-    const { eventTracking } = useContext(EventTrackingContext);
-    const customFiltersRef = useRef(customReportFilters);
-    // Keep ref updated with latest filters
-    useEffect(() => {
-        customFiltersRef.current = customReportFilters;
-    }, [customReportFilters]);
-    // If useDashboard is being used before Dashboard Context is set, we need to
-    // actively load the dashboard
-    useEffect(() => {
-        if (!isLoading && !data && initialLoad.current) {
-            initialLoad.current = false;
-            reload();
-        }
-    }, [isLoading, data]);
-    const { allReportsById } = useAllReports();
-    const sections = useMemo(() => {
-        if (!data?.sections)
-            return null;
-        return Object.entries(data.sections).reduce((acc, [name, reports]) => {
-            acc[name] = reports
-                .map((report) => allReportsById[report.id])
-                .filter((v) => v !== undefined);
-            return acc;
-        }, {});
-    }, [data?.sections, allReportsById]);
-    const filters = useMemo(() => {
-        if (!dashboardFilters)
-            return [];
-        return dashboardFilters.map(convertInternalDashboardFilterToDashboardFilter);
-    }, [dashboardFilters]);
-    useEffect(() => {
-        if (!fetchedInitialReports.current && data) {
-            fetchedInitialReports.current = true;
-            fetchReports([], dashboardFilters ?? []);
-        }
-    }, [fetchedInitialReports, data, dashboardFilters]);
-    const applyDashboardFilters = (filtersToUpdate) => {
-        const newFilters = (dashboardFilters ?? []).map((f) => {
-            const update = filtersToUpdate.find((u) => u.label === f.label);
-            if (!update)
-                return f;
-            if (f.filterType === InternalDashboardFilterType.String) {
-                if (f.stringFilterType === StringFilterType.Multiselect) {
-                    return {
-                        ...f,
-                        values: update.value,
-                    };
-                }
-                else {
-                    return {
-                        ...f,
-                        selectedValue: update.value,
-                    };
-                }
-            }
-            else if (f.filterType === InternalDashboardFilterType.Date) {
-                // Try to match a preset if possible, otherwise just update start/end
-                const presetOptions = convertPresetOptionsToSelectableList(f.presetOptions ?? [], f.defaultPresetRanges ?? []);
-                const value = update.value;
-                const preset = presetOptions.find((p) => {
-                    const pStart = p.startDate
-                        ? new Date(p.startDate).toISOString()
-                        : undefined;
-                    const vStart = value.startDate
-                        ? new Date(value.startDate).toISOString()
-                        : undefined;
-                    const pEnd = p.endDate
-                        ? new Date(p.endDate).toISOString()
-                        : undefined;
-                    const vEnd = value.endDate
-                        ? new Date(value.endDate).toISOString()
-                        : undefined;
-                    return pStart === vStart && pEnd === vEnd;
-                });
-                if (!preset) {
-                    return { ...f, startDate: value.startDate, endDate: value.endDate };
-                }
-                else {
-                    return {
-                        ...f,
-                        preset: preset,
-                        startDate: value.startDate,
-                        endDate: value.endDate,
-                    };
-                }
-            }
-            return f;
-        });
-        reload(dashboardName, true, undefined, {
-            filters: newFilters,
-        });
-        return newFilters;
-    };
-    // Apply developer facing filters to the dashbaord
-    const applyCustomFilters = (filters) => {
-        const internalFilters = filters
-            .map((f) => {
-            try {
-                const internalFilter = convertCustomFilter(f);
-                return internalFilter;
-            }
-            catch (e) {
-                console.error(e);
-                return null;
-            }
-        })
-            .filter((f) => f !== null);
-        customFilterDispatch({
-            type: 'ADD_CUSTOM_DASHBOARD_FILTERS',
-            dashboardName,
-            data: internalFilters,
-        });
-        return internalFilters;
-    };
-    const isFilter = (f) => {
-        // Filter never has an 'id' property, but always has a 'filterType' property
-        return f && typeof f === 'object' && 'filterType' in f && !('id' in f);
-    };
-    const isDashboardFilter = (f) => {
-        return f && typeof f === 'object' && 'label' in f;
-    };
-    const applyFilters = (filters) => {
-        const dashboardFilters = filters.filter(isDashboardFilter);
-        const customFilters = filters.filter(isFilter);
-        const newCustomFilters = applyCustomFilters(customFilters);
-        const newDashboardFilters = applyDashboardFilters(dashboardFilters);
-        fetchReports(newCustomFilters, newDashboardFilters);
-    };
-    // In case useDashboardReport set initial custom filters
-    const waitForCustomFilters = async (reportId) => {
-        let attempts = 0;
-        const maxAttempts = 10; // Prevent infinite loops
-        while (attempts < maxAttempts) {
-            const filters = customFiltersRef.current[reportId];
-            if (filters && filters.length > 0) {
-                return filters;
-            }
-            await new Promise((resolve) => setTimeout(resolve, 100)); // Wait 100ms between checks
-            attempts++;
-        }
-        return [];
-    };
-    const fetchReports = async (customFilters, dashboardFilters) => {
-        if (!client || !sections)
-            return;
-        const allReportIds = Object.values(sections).flatMap((reports) => reports.map((report) => report.id));
-        await Promise.all(allReportIds.map(async (reportId) => {
-            reportsLoadingStateDispatch({
-                type: 'SET_REPORT_LOADING',
-                id: reportId,
-                data: true,
-            });
-            const customReportFiltersArray = await waitForCustomFilters(reportId);
-            const { report, error } = await fetchReport({
-                reportId,
-                client,
-                tenants,
-                flags,
-                filters: dashboardFilters
-                    .concat(customFilters)
-                    .concat(customReportFiltersArray),
-                getToken,
-                eventTracking,
-            });
-            if (error) {
-                console.error(error);
-                return null;
-            }
-            reportsDispatch({
-                type: 'UPDATE_REPORT',
-                id: reportId,
-                data: report,
-            });
-            reportsLoadingStateDispatch({
-                type: 'SET_REPORT_LOADING',
-                id: reportId,
-                data: false,
-            });
-            return report;
-        }));
-    };
-    return {
-        isLoading: !!isLoading || !sections,
-        sections: isLoading ? null : sections,
-        filters,
-        applyFilters,
-    };
-};
-// useDashboard accompanying hook
-export const useDashboardReport = (reportId, config) => {
-    const { reports, reportsLoadingState, reportsDispatch, reportsLoadingStateDispatch, } = useContext(ReportsContext);
-    const { dashboardFilters } = useContext(DashboardFiltersContext);
-    const { tenants, flags } = useContext(TenantContext);
-    const [client] = useContext(ClientContext);
-    const { getToken } = useContext(FetchContext);
-    const { eventTracking } = useContext(EventTrackingContext);
-    const { customReportFiltersDispatch } = useContext(ReportFiltersContext);
-    const { dashboardCustomFilters } = useContext(DashboardFiltersContext);
-    const { data: dashboardData, dashboardFilters: dashboardFiltersInternal, reload: reloadDashboard, } = useDashboardInternal(reports[reportId]?.dashboardName ?? null);
-    // Add initial custom filters to context
-    useEffect(() => {
-        if (config?.initialFilters) {
-            customReportFiltersDispatch({
-                type: 'ADD_CUSTOM_REPORT_FILTERS',
-                reportId,
-                data: config.initialFilters.map(convertCustomFilter),
-            });
-        }
-    }, []);
-    const processedReport = useMemo(() => {
-        if (!reports[reportId])
-            return null;
-        const dashboardName = reports[reportId].dashboardName;
-        return convertInternalReportToReport(mergeComparisonRange(reports[reportId]), Object.values(dashboardFilters[dashboardName] ?? {}).map((f) => f.filter), eventTracking, 'useDashboardReport');
-    }, [reports, reportId, dashboardFilters]);
-    const setReportFilters = (filters) => {
-        updateReport(filters);
-    };
-    const updateReport = async (filters) => {
-        if (!client)
-            return;
-        reportsLoadingStateDispatch({
-            type: 'SET_REPORT_LOADING',
-            id: reportId,
-            data: true,
-        });
-        customReportFiltersDispatch({
-            type: 'ADD_CUSTOM_REPORT_FILTERS',
-            reportId,
-            data: filters.map(convertCustomFilter),
-        });
-        const dashboardFiltersArray = dashboardFiltersInternal ?? [];
-        const dashboardCustomFiltersArray = dashboardCustomFilters[processedReport?.dashboardName ?? ''] ?? [];
-        const requestFilters = filters
-            .map(convertCustomFilter)
-            .concat(dashboardCustomFiltersArray)
-            .concat(dashboardFiltersArray);
-        const { report, error } = await fetchReport({
-            reportId,
-            client,
-            tenants,
-            flags,
-            filters: requestFilters,
-            getToken,
-            eventTracking,
-        });
-        if (error) {
-            console.error(error);
-            return null;
-        }
-        reportsDispatch({
-            type: 'UPDATE_REPORT',
-            id: reportId,
-            data: report,
-        });
-        reportsLoadingStateDispatch({
-            type: 'SET_REPORT_LOADING',
-            id: reportId,
-            data: false,
-        });
-    };
-    const deleteReport = () => {
-        // check if current tenant has access to the report
-        // console.log('processedReport', processedReport);
-        const report = reports[reportId];
-        if (!report) {
-            throw new Error('Report not found');
-        }
-        const dashboardOwners = dashboardData?.tenantKeys;
-        // TODO: may need changing with multiple dashboard owners
-        const tenantField = dashboardOwners?.[0] ?? null;
-        if (!tenantField || dashboardOwners?.length !== 1) {
-            throw new Error('Could not determine dashboard owner');
-        }
-        const reportFlags = report.flags?.[tenantField];
-        if (!reportFlags || reportFlags === 'QUILL_ALL_TENANTS') {
-            throw new Error('Cannot delete global report');
-        }
-        handleDeleteRequest(reportId);
-    };
-    const handleDeleteRequest = async (reportId) => {
-        if (!client)
-            return;
-        const { status, error } = await quillFetch({
-            client,
-            task: 'delete',
-            metadata: {
-                dashboardItemId: reportId,
-                tenants,
-            },
-            getToken,
-        });
-        if (status !== 'success') {
-            throw new Error(`Error deleting report: ${error}`);
-        }
-        else {
-            reloadDashboard(undefined, true, {
-                report: { id: reportId },
-                action: 'delete',
-            });
-        }
-    };
-    return {
-        report: reportsLoadingState[reportId] ? null : processedReport,
-        loading: !!reportsLoadingState[reportId],
-        applyFilters: setReportFilters,
-        deleteReport,
-    };
-};