@quillsql/react 2.13.47 → 2.13.49

package/dist/esm/Context.js

@@ -1,14 +1,14 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useState, createContext, useEffect, useReducer, useRef, useMemo, } from 'react';
-import { getSchemaInfo } from './utils/schema';
-import { fetchClient } from './utils/client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import equal from 'fast-deep-equal';
+import { createContext, useEffect, useMemo, useReducer, useRef, useState, } from 'react';
+import { convertPresetOptionsToSelectableList, defaultOptionsV2, } from './DateRangePicker/dateRangePickerUtils';
 import { InternalFilterType, } from './models/Filter';
+import { fetchClient } from './utils/client';
 import { getDashboard as requestGetDashboard } from './utils/dashboard';
-import equal from 'fast-deep-equal';
-import { defaultOptionsV2, PRIMARY_RANGE, } from './DateRangePicker/dateRangePickerUtils';
-import { processReportResponse } from './utils/report';
+import { quillFetch, parseFetchResponse } from './utils/dataFetcher';
 import { createDefaultDateFilter, mergeCustomFilters, } from './utils/filterProcessing';
-import { getData } from './utils/dataFetcher';
+import { processReportResponse } from './utils/report';
+import { getSchemaInfo } from './utils/schema';
 const dummySetter = () => { };
 export const SchemaDataContext = createContext([
     {
@@ -176,6 +176,8 @@ const reportsReducer = (state = {}, action) => {
                     ...action.data,
                 },
             };
+        case 'CLEAR_REPORTS':
+            return {};
         default:
             return state;
     }
@@ -185,6 +187,24 @@ export const ReportsContext = createContext({
     reportsDispatch: dummySetter,
     fetchIndividualReport: async () => { },
 });
+const customReportFiltersReducer = (state, action) => {
+    switch (action.type) {
+        case 'ADD_CUSTOM_REPORT_FILTERS':
+            if (!action.data) {
+                const newState = { ...state };
+                delete newState[action.reportId];
+                return newState;
+            }
+            return {
+                ...state,
+                [action.reportId]: action.data,
+            };
+        case 'DELETE_CUSTOM_REPORT_FILTERS':
+            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.reportId));
+        default:
+            return state;
+    }
+};
 const reportFiltersReducer = (state = {}, action) => {
     switch (action.type) {
         case 'ADD_REPORT_FILTERS':
@@ -224,10 +244,30 @@ const reportFiltersReducer = (state = {}, action) => {
 };
 export const ReportFiltersContext = createContext({
     reportFilters: {},
+    customReportFilters: {},
     reportFiltersDispatch: dummySetter,
+    customReportFiltersDispatch: dummySetter,
     loadFiltersForReport: async () => { },
     abortLoadingFilters: () => { },
 });
+const customDashboardFiltersReducer = (state, action) => {
+    switch (action.type) {
+        case 'ADD_CUSTOM_DASHBOARD_FILTERS':
+            if (!action.data) {
+                const newState = { ...state };
+                delete newState[action.dashboardName];
+                return newState;
+            }
+            return {
+                ...state,
+                [action.dashboardName]: action.data,
+            };
+        case 'DELETE_CUSTOM_DASHBOARD_FILTERS':
+            return Object.fromEntries(Object.entries(state).filter(([key]) => key !== action.dashboardName));
+        default:
+            return state;
+    }
+};
 const dashboardFiltersReducer = (state, action) => {
     switch (action.type) {
         case 'SET_INITIAL_DASHBOARD_FILTERS':
@@ -267,12 +307,18 @@ const dashboardFiltersReducer = (state, action) => {
 };
 export const DashboardFiltersContext = createContext({
     dashboardFilters: {},
+    dashboardCustomFilters: {},
     dispatch: dummySetter,
+    customFilterDispatch: dummySetter,
     loadFiltersForDashboard: async () => { },
 });
 export const TenantContext = createContext({});
+export const FetchContext = createContext({
+    getToken: async () => '',
+    quillFetchWithToken: async () => ({ data: null }),
+});
 // TODO: track errors per dashboard in the same way as loading state
-export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoint, queryHeaders, withCredentials, tenants, flags, }) => {
+export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoint, queryHeaders, withCredentials, tenants, flags, isAdmin, getAuthorizationToken = async () => '', }) => {
     // get client from session storage
     const [client, setClient] = useState(typeof window !== 'undefined' && sessionStorage
         ? JSON.parse(sessionStorage.getItem('quill-client') ?? 'null')
@@ -314,6 +360,8 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
     const [dashboard, dispatch] = useReducer(dashboardReducer, {});
     const [dashboardConfig, dashboardConfigDispatch] = useReducer(dashboardConfigReducer, {});
     const [dashboardFilters, dashboardFiltersDispatch] = useReducer(dashboardFiltersReducer, {});
+    const [dashboardCustomFilters, customFilterDispatch] = useReducer(customDashboardFiltersReducer, {});
+    const [customReportFilters, customReportFiltersDispatch] = useReducer(customReportFiltersReducer, {});
     const filterOptionsAbortControllers = useRef(new Set());
     const [reportFilters, reportFiltersDispatch] = useReducer(reportFiltersReducer, {});
     const reportFilterOptionsAbortControllers = useRef({});
@@ -321,6 +369,8 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
     const reportsAbortControllers = useRef({});
     const fetchSchemaAbortController = useRef(null);
     const fetchSchemaProcessId = useRef(0);
+    const currentTenant = useRef(null);
+    const currentPublicKey = useRef(null);
     // SETS INITIAL THEME
     useEffect(() => {
         if (!theme) {
@@ -348,7 +398,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
         //   id: reportId,
         // });
     }
-    async function loadFiltersForReport(reportId, initiator, filters, updatedFilterLabel, customFilters, filterMap, dashboardName) {
+    async function loadFiltersForReport(reportId, initiator, filters, updatedFilterLabel, customFilters, dashboardName) {
         // Abort all previous fetch requests
         reportFilterOptionsAbortControllers.current[reportId]?.requests.forEach((controller) => controller.abort());
         reportFilterOptionsAbortControllers.current[reportId] = {
@@ -393,56 +443,54 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 const filterOptionsAbortController = new AbortController();
                 reportFilterOptionsAbortControllers.current[reportId]?.requests.add(filterOptionsAbortController);
                 try {
-                    const response = await fetch(`${queryEndpoint}?filterOptions`, {
-                        method: 'POST',
-                        headers: {
-                            ...queryHeaders,
-                            'Content-Type': 'application/json',
+                    const result = await quillFetch({
+                        client: {
+                            clientId: publicKey,
+                            queryEndpoint,
+                            queryHeaders,
+                            withCredentials: !!withCredentials,
+                        },
+                        task: 'filter-options',
+                        metadata: {
+                            clientId: publicKey,
+                            publicKey: publicKey,
+                            reportId: dashboardName ? undefined : reportId,
+                            name: dashboardName,
+                            useNewNodeSql: true,
+                            filter: {
+                                ...filter,
+                                query: undefined,
+                                options: undefined,
+                            },
+                            appliedFilters: filters
+                                .filter((f) => f.label !== filter.label)
+                                .map((f) => ({
+                                ...f,
+                                query: undefined,
+                                options: undefined,
+                            })),
+                            customFilters: customFilters?.filter((f) => f.filterType !== InternalFilterType.DateCustomFilter &&
+                                f.filterType !== InternalFilterType.DateFilter &&
+                                f.filterType !== InternalFilterType.DateComparisonFilter),
+                            tenants,
                         },
-                        body: JSON.stringify({
-                            metadata: {
-                                clientId: populatedClient?.publicKey,
-                                publicKey: populatedClient?.publicKey,
-                                reportId: dashboardName ? undefined : reportId,
-                                name: dashboardName,
-                                task: 'filter-options',
-                                useNewNodeSql: true,
+                        abortSignal: filterOptionsAbortController?.signal,
+                        getToken: getAuthorizationToken,
+                    });
+                    const filterOptions = result.data?.filters[0]?.options ?? [];
+                    if (!filterOptionsAbortController.signal.aborted) {
+                        reportFiltersDispatch({
+                            type: 'UPDATE_REPORT_FILTER',
+                            id: reportId,
+                            data: {
                                 filter: {
                                     ...filter,
-                                    options: undefined,
+                                    options: filterOptions,
                                 },
-                                appliedFilters: filters
-                                    .filter((f) => f.label !== filter.label)
-                                    .map((f) => ({
-                                    ...f,
-                                    query: undefined,
-                                    options: undefined,
-                                })),
-                                customFilters: customFilters?.filter((f) => f.filterType !== InternalFilterType.DateCustomFilter &&
-                                    f.filterType !== InternalFilterType.DateFilter &&
-                                    f.filterType !== InternalFilterType.DateComparisonFilter),
-                                tenants,
+                                loading: false,
                             },
-                        }),
-                        signal: filterOptionsAbortController?.signal,
-                        credentials: withCredentials ? 'include' : 'omit',
-                    });
-                    return response.json().then((result) => {
-                        const filterOptions = result.data?.filters[0]?.options ?? [];
-                        if (reportFilters[reportId]?.[filter.label]) {
-                            reportFiltersDispatch({
-                                type: 'UPDATE_REPORT_FILTER',
-                                id: reportId,
-                                data: {
-                                    filter: {
-                                        ...filter,
-                                        options: filterOptions,
-                                    },
-                                    loading: false,
-                                },
-                            });
-                        }
-                    });
+                        });
+                    }
                 }
                 catch (error) {
                     if (error instanceof Error && error.name === 'AbortError') {
@@ -465,7 +513,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
             delete reportFilterOptionsAbortControllers.current[reportId];
         }
     }
-    async function fetchIndividualReport({ reportId, initiator, fetchRows = true, dashboardFilters, customFilters, additionalProcessing, dateBucket, reportAbortController, customFields, propogateChanges, }) {
+    async function fetchIndividualReport({ reportId, initiator, fetchRows = true, dashboardFilters, customFilters, additionalProcessing, dateBucket, reportAbortController, customFields, propagateChanges, }) {
         if (!populatedClient) {
             return;
         }
@@ -473,7 +521,8 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
         const currentRequest = reportsAbortControllers.current[reportId];
         if (currentRequest) {
             // Chart requests override useQuill and useExport requests
-            if (initiator === 'Chart') {
+            if (initiator === 'Chart' ||
+                (currentRequest.initiator !== 'Chart' && initiator === 'Table')) {
                 currentRequest.request.abort();
             }
             else {
@@ -486,55 +535,33 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
             request: abortController,
         };
         try {
-            const hostedBody = {
+            const resp = await quillFetch({
+                client: {
+                    clientId: publicKey,
+                    queryEndpoint,
+                    queryHeaders,
+                    withCredentials: !!withCredentials,
+                },
+                task: fetchRows ? 'report' : 'report-info',
                 metadata: {
                     reportId,
-                    dashboardItemId: reportId,
                     clientId: populatedClient.publicKey,
-                    task: 'report',
-                    databaseType: populatedClient.databaseType,
-                    filters: filters.map((filter) => ({ ...filter, options: undefined })),
-                    additionalProcessing,
                     useNewNodeSql: true,
-                    getDefaultDashboardFilters: !filters.length,
+                    filters: filters?.map((f) => ({ ...f, options: undefined })),
+                    additionalProcessing,
+                    dateBucket,
+                    databaseType: populatedClient.databaseType,
                     tenants,
                     flags,
                     customFields,
                 },
-            };
-            const cloudBody = {
-                id: reportId,
-                filters: filters,
-                useNewNodeSql: true,
-            };
-            const resp = fetchRows
-                ? await getData(populatedClient, 'itempost', 'omit', hostedBody, cloudBody, 'POST', 'fetch-data', abortController.signal)
-                : await fetch(`${queryEndpoint}`, {
-                    method: 'POST',
-                    headers: {
-                        'Content-Type': 'application/json',
-                        ...queryHeaders,
-                    },
-                    body: JSON.stringify({
-                        metadata: {
-                            task: fetchRows ? 'report' : 'report-info',
-                            reportId,
-                            clientId: populatedClient.publicKey,
-                            useNewNodeSql: true,
-                            filters: filters?.map((f) => ({ ...f, options: undefined })),
-                            getDefaultDashboardFilters: !filters.length,
-                            additionalProcessing,
-                            dateBucket,
-                            databaseType: populatedClient.databaseType,
-                            tenants,
-                            flags,
-                            customFields,
-                        },
-                    }),
-                    signal: abortController.signal,
-                    credentials: withCredentials ? 'include' : 'omit',
-                });
-            const results = fetchRows ? resp : await resp.json();
+                abortSignal: abortController.signal,
+                getToken: getAuthorizationToken,
+                urlParameters: `caller=fetchReport&task=report`,
+            });
+            const results = fetchRows
+                ? await parseFetchResponse(populatedClient, 'report', resp, getAuthorizationToken)
+                : resp;
             if (results.error) {
                 console.error('Error fetching report:', results.error);
                 return;
@@ -548,6 +575,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                     dateBucket,
                     additionalProcessing,
                     customFields,
+                    getToken: getAuthorizationToken,
                 });
             reportsDispatch({
                 type: 'ADD_REPORT',
@@ -559,7 +587,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 },
             });
             // If the report matches the active dashboard, update the dashboard state
-            if (propogateChanges) {
+            if (propagateChanges) {
                 if (dashboard[report.dashboardName]) {
                     dispatch({
                         type: 'UPDATE_DASHBOARD_ITEM',
@@ -577,7 +605,26 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 const returnedFilters = !fetchRows
                     ? results.data.filters
                     : results.filters;
-                const dateFilterTemplate = returnedFilters.find((f) => f.filterType === 'date_range');
+                let dateFilterTemplate = returnedFilters.find((f) => f.filterType === 'date_range');
+                if (dateFilterTemplate) {
+                    dateFilterTemplate = {
+                        ...dateFilterTemplate,
+                        presetOptions: dateFilterTemplate?.presetOptions?.map((preset) => ({
+                            ...preset,
+                            loopStart: preset.loopStart
+                                ? new Date(preset.loopStart)
+                                : undefined,
+                            loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : undefined,
+                        })),
+                        defaultPresetRanges: dateFilterTemplate?.defaultPresetRanges?.map((preset) => ({
+                            ...preset,
+                            loopStart: preset.loopStart
+                                ? new Date(preset.loopStart)
+                                : undefined,
+                            loopEnd: preset.loopEnd ? new Date(preset.loopEnd) : undefined,
+                        })),
+                    };
+                }
                 const dateFilter = dateFilterTemplate
                     ? createDefaultDateFilter(dateFilterTemplate, [report], report.dashboardName)
                     : undefined;
@@ -586,14 +633,6 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                     ...(dateFilter ? [dateFilter] : []),
                     ...stringFilters,
                 ];
-                reportFiltersDispatch({
-                    type: 'ADD_REPORT_FILTERS',
-                    id: reportId,
-                    data: allFilters.map((filter) => ({
-                        filter,
-                        loading: filter.filterType !== 'date_range',
-                    })),
-                });
                 loadFiltersForReport(reportId, initiator, allFilters, undefined, customFilters);
             }
         }
@@ -653,64 +692,63 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
             const filterOptionsAbortController = new AbortController();
             filterOptionsAbortControllers.current.add(filterOptionsAbortController);
             try {
-                const response = await fetch(`${queryEndpoint}?filterOptions`, {
-                    method: 'POST',
-                    headers: {
-                        ...queryHeaders,
-                        'Content-Type': 'application/json',
+                const result = await quillFetch({
+                    client: {
+                        clientId: publicKey,
+                        queryEndpoint,
+                        queryHeaders,
+                        withCredentials: !!withCredentials,
                     },
-                    body: JSON.stringify({
-                        metadata: {
-                            clientId: populatedClient?.publicKey,
-                            publicKey: populatedClient?.publicKey,
-                            name: dashboardName,
-                            task: 'filter-options',
-                            useNewNodeSql: true,
-                            filter: {
-                                ...filter,
-                                options: undefined,
-                            },
-                            appliedFilters: filters
-                                .filter((f) => f.label !== filter.label)
-                                .map((f) => ({
-                                ...f,
-                                query: undefined,
-                                options: undefined,
-                            })),
-                            customFilters,
-                            tenants: tenants,
+                    task: 'filter-options',
+                    metadata: {
+                        clientId: publicKey,
+                        publicKey,
+                        name: dashboardName,
+                        useNewNodeSql: true,
+                        filter: {
+                            ...filter,
+                            query: undefined,
+                            options: undefined,
                         },
-                    }),
-                    signal: filterOptionsAbortController?.signal,
-                    credentials: withCredentials ? 'include' : 'omit',
+                        appliedFilters: filters
+                            .filter((f) => f.label !== filter.label)
+                            .map((f) => ({
+                            ...f,
+                            query: undefined,
+                            options: undefined,
+                        })),
+                        customFilters,
+                        tenants,
+                    },
+                    abortSignal: filterOptionsAbortController?.signal,
+                    getToken: getAuthorizationToken,
                 });
-                return response.json().then((result) => {
-                    const filterOptions = result.data?.filters[0]?.options ?? [];
-                    dashboardFiltersDispatch({
-                        type: 'UPDATE_DASHBOARD_FILTER',
-                        dashboardName,
-                        filterName: filter.label,
-                        data: {
-                            filter: {
-                                ...filter,
-                                options: filterOptions,
-                            },
-                            loading: false,
+                const filterOptions = result.data?.filters[0]?.options ?? [];
+                dashboardFiltersDispatch({
+                    type: 'UPDATE_DASHBOARD_FILTER',
+                    dashboardName,
+                    filterName: filter.label,
+                    data: {
+                        filter: {
+                            ...filter,
+                            options: filterOptions,
                         },
-                    });
-                    // Should we be updating the filters for all attached reports when the dashboard filters change?
-                    // reportFiltersDispatch({
-                    //   type: 'UPDATE_REPORT_FILTER',
-                    //   id: filter.label,
-                    //   data: {
-                    //     filter: {
-                    //       ...filter,
-                    //       options: filterOptions,
-                    //     },
-                    //     loading: false,
-                    //   },
-                    // });
+                        loading: false,
+                    },
+                });
+                // Should we be updating the filters for all attached reports when the dashboard filters change?
+                reportFiltersDispatch({
+                    type: 'UPDATE_REPORT_FILTER',
+                    id: filter.label,
+                    data: {
+                        filter: {
+                            ...filter,
+                            options: filterOptions,
+                        },
+                        loading: false,
+                    },
                 });
+                return null;
             }
             catch (error) {
                 if (error instanceof Error && error.name === 'AbortError') {
@@ -733,6 +771,8 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
         }));
     }
     async function loadDashboard(dashboardName, fetchFromServer = false, reportAction) {
+        if (!client)
+            return;
         let curDashboardConfig = dashboardConfig[dashboardName]?.config;
         if (!fetchFromServer && curDashboardConfig?.sections) {
             if (reportAction?.action === 'delete') {
@@ -750,7 +790,6 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 });
                 dispatch({
                     type: 'REMOVE_DASHBOARD_ITEM',
-                    dashboard: dashboardName,
                     id: reportAction.report.id,
                 });
             }
@@ -767,12 +806,75 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                         },
                     });
                 }
+                let newSectionOrder = curDashboardConfig.sectionOrder;
+                if (newSectionOrder) {
+                    newSectionOrder = newSectionOrder.map((section) => {
+                        if (section.section === report.section &&
+                            !section.reportOrder.includes(report.id)) {
+                            section.reportOrder.push(report.id);
+                        }
+                        else if (section.section !== report.section &&
+                            section.reportOrder.includes(report.id)) {
+                            section.reportOrder = section.reportOrder.filter((id) => id !== report.id);
+                        }
+                        return section;
+                    });
+                    const newSections = newSectionOrder.reduce((acc, section) => {
+                        acc[section.section] = section.reportOrder
+                            .map((id, index) => {
+                            if (id === report.id) {
+                                return { ...report, id: id, order: 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: {
+                                ...curDashboardConfig,
+                                sections: newSections,
+                                sectionOrder: newSectionOrder?.map((section) => ({
+                                    ...section,
+                                    _id: section._id ?? 'temp_section_id_' + Date.now().toString(),
+                                })) ?? [],
+                            },
+                            loading: false,
+                        },
+                    });
+                    if ((curDashboardConfig.sectionOrder?.find((section) => section.reportOrder?.includes(report?.id ?? ''))?.section ?? '') !== report.section) {
+                        const body = {
+                            task: 'set-section-order',
+                            clientId: client?.clientId,
+                            dashboardName,
+                            sectionOrder: newSectionOrder,
+                        };
+                        try {
+                            await quillFetch({
+                                client,
+                                task: 'set-section-order',
+                                metadata: body,
+                                getToken: getAuthorizationToken,
+                            });
+                        }
+                        catch (e) {
+                            console.error(e);
+                        }
+                    }
+                }
+            }
+            if (reportAction?.action !== 'upsert') {
+                dashboardConfigDispatch({
+                    type: 'UPDATE_DASHBOARD',
+                    id: dashboardName,
+                    data: { config: curDashboardConfig, loading: false },
+                });
             }
-            dashboardConfigDispatch({
-                type: 'UPDATE_DASHBOARD',
-                id: dashboardName,
-                data: { config: curDashboardConfig, loading: false },
-            });
             return curDashboardConfig;
         }
         if (!fetchFromServer &&
@@ -796,7 +898,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 id: dashboardName,
                 data: true,
             });
-            const resp = await requestGetDashboard(dashboardName, populatedClient, tenants, flags);
+            const resp = await requestGetDashboard(dashboardName, populatedClient, getAuthorizationToken, tenants, flags);
             // if dashboard has changed
             if (!equal(resp, curDashboardConfig)) {
                 dashboardConfigDispatch({
@@ -844,6 +946,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 tenants,
                 caller,
                 abortSignal: fetchSchemaAbortController.current.signal,
+                getToken: getAuthorizationToken,
             });
             if (currentProcessId === fetchSchemaProcessId.current) {
                 setSchemaData({
@@ -877,74 +980,112 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
         fetchDashboardsAbortController.current = new AbortController();
         dashboardConfigDispatch({ type: 'CLEAR_DASHBOARDS' });
         try {
-            const response = await fetch(`${queryEndpoint}?dashboards`, {
-                method: 'POST',
-                headers: {
-                    ...queryHeaders,
-                    'Content-Type': 'application/json',
+            const result = await quillFetch({
+                client: {
+                    clientId: publicKey,
+                    queryEndpoint,
+                    queryHeaders,
+                    withCredentials: !!withCredentials,
                 },
-                body: JSON.stringify({
-                    metadata: {
-                        clientId: publicKey,
-                        publicKey: publicKey,
-                        task: 'dashboards',
-                        getSections: true,
-                    },
-                }),
-                credentials: withCredentials ? 'include' : 'omit',
-                signal: fetchDashboardsAbortController.current.signal,
+                task: 'dashboards',
+                metadata: {
+                    clientId: publicKey,
+                    // getSections: true, // skip fetching reports since 'dashboard' always does anyway
+                },
+                abortSignal: fetchDashboardsAbortController.current.signal,
+                getToken: getAuthorizationToken,
             });
-            const result = await response.json();
             dashboardConfigDispatch({
                 type: 'SET_DASHBOARD_DATA',
                 data: result.data.dashboards.map((dashboard) => ({
                     ...dashboard,
+                    dateFilter: dashboard.dateFilter
+                        ? {
+                            ...dashboard.dateFilter,
+                            presetOptions: dashboard.dateFilter.presetOptions?.map((preset) => ({
+                                ...preset,
+                                loopStart: preset.loopStart
+                                    ? new Date(preset.loopStart)
+                                    : undefined,
+                                loopEnd: preset.loopEnd
+                                    ? new Date(preset.loopEnd)
+                                    : undefined,
+                            })),
+                            defaultPresetRanges: 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(dashboard.createdAt),
                 })),
             });
             dashboardFiltersDispatch({
                 type: 'SET_INITIAL_DASHBOARD_FILTERS',
                 data: result.data.dashboards.reduce((acc, dashboard) => {
-                    let presetsOptions = defaultOptionsV2;
-                    if (dashboard.dateFilter?.presetRanges) {
-                        presetsOptions = dashboard.dateFilter.presetRanges.map((elem) => {
-                            if (!elem.isStatic) {
-                                return {
-                                    label: elem.label,
-                                    value: elem.value,
-                                    startDate: (PRIMARY_RANGE[elem.value] ??
-                                        PRIMARY_RANGE['LAST_30_DAYS']).startDate,
-                                    endDate: (PRIMARY_RANGE[elem.value] ??
-                                        PRIMARY_RANGE['LAST_30_DAYS']).endDate,
-                                };
-                            }
-                            return {
-                                label: elem.label,
-                                value: elem.value,
-                                startDate: new Date(elem.startDate),
-                                endDate: new Date(elem.endDate),
-                            };
-                        });
+                    let presetOptions = defaultOptionsV2;
+                    if (dashboard.dateFilter?.presetOptions ||
+                        dashboard.dateFilter?.defaultPresetRanges) {
+                        presetOptions = convertPresetOptionsToSelectableList((dashboard.dateFilter.presetOptions ?? []).map((preset) => ({
+                            ...preset,
+                            loopStart: preset.loopStart
+                                ? new Date(preset.loopStart)
+                                : undefined,
+                            loopEnd: preset.loopEnd
+                                ? new Date(preset.loopEnd)
+                                : undefined,
+                        })), (dashboard.dateFilter.defaultPresetRanges ?? []).map((preset) => ({
+                            ...preset,
+                            loopStart: preset.loopStart
+                                ? new Date(preset.loopStart)
+                                : undefined,
+                            loopEnd: preset.loopEnd
+                                ? new Date(preset.loopEnd)
+                                : undefined,
+                        })));
                     }
-                    acc[dashboard.name] = dashboard.filters.reduce((acc, filter) => {
-                        acc[filter.label] = {
-                            filter: { ...filter, options: undefined },
-                            loading: true,
-                        };
-                        return acc;
-                    }, {});
+                    acc[dashboard.name] = {};
                     if (dashboard.dateFilter) {
                         dashboard.dateFilter = {
                             ...dashboard.dateFilter,
-                            startDate: presetsOptions.find((elem) => elem.value === dashboard.dateFilter.primaryRange?.value)?.startDate,
-                            endDate: presetsOptions.find((elem) => elem.value === dashboard.dateFilter.primaryRange?.value)?.endDate,
+                            startDate: presetOptions.find((elem) => elem.value === dashboard.dateFilter.primaryRange?.value)?.startDate,
+                            endDate: presetOptions.find((elem) => elem.value === dashboard.dateFilter.primaryRange?.value)?.endDate,
                             filterType: 'date_range',
+                            presetOptions: dashboard.dateFilter.presetOptions?.map((preset) => ({
+                                ...preset,
+                                loopStart: preset.loopStart
+                                    ? new Date(preset.loopStart)
+                                    : undefined,
+                                loopEnd: preset.loopEnd
+                                    ? new Date(preset.loopEnd)
+                                    : undefined,
+                            })),
+                            defaultPresetRanges: dashboard.dateFilter.defaultPresetRanges?.map((preset) => ({
+                                ...preset,
+                                loopStart: preset.loopStart
+                                    ? new Date(preset.loopStart)
+                                    : undefined,
+                                loopEnd: preset.loopEnd
+                                    ? new Date(preset.loopEnd)
+                                    : undefined,
+                            })),
                         };
                         acc[dashboard.name][dashboard.dateFilter.label] = {
                             filter: dashboard.dateFilter,
                             loading: true,
                         };
                     }
+                    dashboard.filters.forEach((filter) => {
+                        acc[dashboard.name][filter.label] = {
+                            filter: { ...filter, options: undefined },
+                            loading: true,
+                        };
+                    });
                     return acc;
                 }, {}),
             });
@@ -963,6 +1104,33 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
             }
         }
     }
+    async function quillFetchWithToken({ client, task, method = 'POST', metadata, abortSignal, credentials = 'omit', urlParameters, includeFlags = false, includeTenants = false, adminMode, }) {
+        try {
+            const result = await quillFetch({
+                client,
+                task,
+                method,
+                metadata: {
+                    flags: includeFlags ? flags : undefined,
+                    tenants: includeTenants ? tenants : undefined,
+                    adminMode,
+                    ...metadata,
+                },
+                abortSignal,
+                credentials,
+                urlParameters,
+                getToken: getAuthorizationToken,
+            });
+            return result;
+        }
+        catch (e) {
+            if (e instanceof Error && e.name === 'AbortError') {
+                throw e;
+            }
+            console.error('Failed to fetch:', e);
+            return { error: 'Failed to fetch data' };
+        }
+    }
     useEffect(() => {
         async function updateClientAndSchema(publicKey) {
             if (populatedClient?.clientId === publicKey &&
@@ -970,8 +1138,8 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 return;
             setIsClientLoading(true);
             setSchemaData({ ...schemaData, isSchemaLoading: true });
-            const newClient = await fetchClient(publicKey, queryEndpoint, withCredentials, queryHeaders);
-            if (!newClient.allTenantTypes?.every((t) => t.defaultId)) {
+            const newClient = await fetchClient(publicKey, queryEndpoint, withCredentials, getAuthorizationToken, queryHeaders, isAdmin);
+            if (!newClient.allTenantTypes?.every((t) => t.defaultId || t.scope === 'database')) {
                 console.error('Default organization not found. Please select a default organization for ', newClient.allTenantTypes?.find((t) => !t.defaultId));
             }
             setClient({
@@ -986,69 +1154,89 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 featureFlags: newClient.featureFlags,
                 domainName: newClient.domainName,
                 allTenantTypes: newClient.allTenantTypes,
-                // @ts-ignore
-                maintenanceMode: newClient?.maintenanceMode || false,
             });
             setIsClientLoading(false);
         }
         updateClientAndSchema(publicKey);
     }, [publicKey]);
     useEffect(() => {
-        if (populatedClient) {
-            fetchSchema({ client: populatedClient, tenants, caller: 'context' });
-        }
-        if (typeof window !== 'undefined' && sessionStorage) {
-            sessionStorage.setItem('quill-client', JSON.stringify({
-                ...populatedClient,
-                allTenantTypes: undefined,
-            }));
+        if (populatedClient?.publicKey &&
+            currentPublicKey.current !== populatedClient?.publicKey) {
+            // CLEAR ALL DASHBOARD DATA AND REPORTS AND THEIR FILTERS
+            dispatch({ type: 'CLEAR_DASHBOARDS' });
+            dashboardFiltersDispatch({ type: 'CLEAR_DASHBOARD_FILTERS' });
+            reportFiltersDispatch({ type: 'CLEAR_REPORT_FILTERS' });
+            reportsDispatch({ type: 'CLEAR_REPORTS' });
+            // TODO: this is yet another unfortunate hack where the answer is to unify the admin and react state
+            // currently, we fetch the dashboards twice if both the client and default org change
+            // because if we didn't, we would fetch 0 times if the client changed but the org didn't
+            if (isAdmin) {
+                setIsDashboardsLoading(true);
+                fetchDashboards(populatedClient?.publicKey);
+            }
+            else {
+                setIsDashboardsLoading(false);
+            }
+            if (typeof window !== 'undefined' && sessionStorage) {
+                sessionStorage.setItem('quill-client', JSON.stringify({
+                    ...populatedClient,
+                    allTenantTypes: undefined,
+                }));
+            }
+            currentPublicKey.current = publicKey;
         }
-    }, [populatedClient?.publicKey, tenants]);
-    // FIXME: fetchDashboards needs to rerun every time the tenant changes so that we filter reports on their flags
+    }, [populatedClient?.publicKey]);
     useEffect(() => {
-        // Clear context
-        setIsDashboardsLoading(true);
-        // TODO: this is yet another unfortunate hack where the answer is to unify the admin and react state
-        // currently, we fetch the dashboards twice if both the client and default org change
-        // because if we didn't, we would fetch 0 times if the client changed but the org didn't
-        fetchDashboards(publicKey);
-        dashboardFiltersDispatch({ type: 'CLEAR_DASHBOARD_FILTERS' });
-        reportFiltersDispatch({ type: 'CLEAR_REPORT_FILTERS' });
-        dispatch({ type: 'CLEAR_DASHBOARDS', dashboard: null });
-    }, [publicKey]);
+        if (populatedClient?.currentTenants &&
+            !equal(currentTenant.current, populatedClient?.currentTenants)) {
+            dispatch({ type: 'CLEAR_DASHBOARDS' });
+            dashboardFiltersDispatch({ type: 'CLEAR_DASHBOARD_FILTERS' });
+            reportFiltersDispatch({ type: 'CLEAR_REPORT_FILTERS' });
+            reportsDispatch({ type: 'CLEAR_REPORTS' });
+            if (populatedClient) {
+                fetchSchema({
+                    client: populatedClient,
+                    tenants: populatedClient.currentTenants,
+                    caller: 'context',
+                });
+            }
+            currentTenant.current = populatedClient?.currentTenants ?? null;
+        }
+    }, [populatedClient?.currentTenants]);
     if (!theme) {
         return null;
     }
     if (!tenants) {
         throw new Error('Quill Error: QuillProvider prop organizationId is deprecated. Please use QuillProvider tenants prop instead');
     }
-    if (populatedClient?.maintenanceMode) {
-        return (_jsxs("div", { children: [_jsx("h1", { children: "Dashboard is currently in maintenance mode" }), _jsx("p", { children: "Please check back later or contact your administrator for more information." })] }));
-    }
     return (_jsx(ClientContext.Provider, { value: [
             isClientLoading || !populatedClient ? null : populatedClient,
             isClientLoading,
             setClient,
-        ], children: _jsx(ThemeContext.Provider, { value: [theme, setTheme], children: _jsx(SchemaDataContext.Provider, { value: [schemaData, setSchemaData], children: _jsx(DashboardContext.Provider, { value: [dashboard, dispatch], children: _jsx(DashboardConfigContext.Provider, { value: {
-                            dashboardConfig: isDashboardsLoading ? {} : dashboardConfig,
-                            isLoading: isDashboardsLoading,
-                            dashboardConfigDispatch,
-                            loadDashboard,
-                        }, children: _jsx(DashboardFiltersContext.Provider, { value: {
-                                dashboardFilters,
-                                dispatch: dashboardFiltersDispatch,
-                                loadFiltersForDashboard,
-                            }, children: _jsx(ReportFiltersContext.Provider, { value: {
-                                    reportFilters,
-                                    reportFiltersDispatch,
-                                    loadFiltersForReport,
-                                    abortLoadingFilters,
-                                }, children: _jsx(ReportsContext.Provider, { value: {
-                                        reports,
-                                        reportsDispatch,
-                                        fetchIndividualReport,
-                                    }, children: _jsx(TenantContext.Provider, { value: {
-                                            tenants: populatedClient?.currentFlags ?? tenants,
-                                            flags: populatedClient?.currentFlags ?? flags,
-                                        }, children: children }) }) }) }) }) }) }) }) }));
+        ], children: _jsx(ThemeContext.Provider, { value: [theme, setTheme], children: _jsx(FetchContext.Provider, { value: { getToken: getAuthorizationToken, quillFetchWithToken }, children: _jsx(SchemaDataContext.Provider, { value: [schemaData, setSchemaData], children: _jsx(DashboardContext.Provider, { value: [dashboard, dispatch], children: _jsx(DashboardConfigContext.Provider, { value: {
+                                dashboardConfig: isDashboardsLoading ? {} : dashboardConfig,
+                                isLoading: isDashboardsLoading,
+                                dashboardConfigDispatch,
+                                loadDashboard,
+                            }, children: _jsx(DashboardFiltersContext.Provider, { value: {
+                                    dashboardFilters,
+                                    dashboardCustomFilters,
+                                    customFilterDispatch,
+                                    dispatch: dashboardFiltersDispatch,
+                                    loadFiltersForDashboard,
+                                }, children: _jsx(ReportFiltersContext.Provider, { value: {
+                                        reportFilters,
+                                        customReportFilters,
+                                        reportFiltersDispatch,
+                                        customReportFiltersDispatch,
+                                        loadFiltersForReport,
+                                        abortLoadingFilters,
+                                    }, children: _jsx(ReportsContext.Provider, { value: {
+                                            reports,
+                                            reportsDispatch,
+                                            fetchIndividualReport,
+                                        }, children: _jsx(TenantContext.Provider, { value: {
+                                                tenants: populatedClient?.currentTenants ?? tenants,
+                                                flags: populatedClient?.currentFlags ?? flags,
+                                            }, children: children }) }) }) }) }) }) }) }) }) }));
 };