@quillsql/react 2.13.48 → 2.13.49

package/dist/esm/Context.js

@@ -1,11 +1,11 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { jsx as _jsx } from "react/jsx-runtime";
 import equal from 'fast-deep-equal';
 import { createContext, useEffect, useMemo, useReducer, useRef, useState, } from 'react';
-import { defaultOptionsV2, PRIMARY_RANGE, } from './DateRangePicker/dateRangePickerUtils';
+import { convertPresetOptionsToSelectableList, defaultOptionsV2, } from './DateRangePicker/dateRangePickerUtils';
 import { InternalFilterType, } from './models/Filter';
 import { fetchClient } from './utils/client';
 import { getDashboard as requestGetDashboard } from './utils/dashboard';
-import { getData } from './utils/dataFetcher';
+import { quillFetch, parseFetchResponse } from './utils/dataFetcher';
 import { createDefaultDateFilter, mergeCustomFilters, } from './utils/filterProcessing';
 import { processReportResponse } from './utils/report';
 import { getSchemaInfo } from './utils/schema';
@@ -313,8 +313,12 @@ export const DashboardFiltersContext = createContext({
     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')
@@ -365,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) {
@@ -437,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 (!filterOptionsAbortController.signal.aborted) {
-                            reportFiltersDispatch({
-                                type: 'UPDATE_REPORT_FILTER',
-                                id: reportId,
-                                data: {
-                                    filter: {
-                                        ...filter,
-                                        options: filterOptions,
-                                    },
-                                    loading: false,
-                                },
-                            });
-                        }
-                    });
+                        });
+                    }
                 }
                 catch (error) {
                     if (error instanceof Error && error.name === 'AbortError') {
@@ -509,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;
         }
@@ -531,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;
@@ -593,6 +575,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                     dateBucket,
                     additionalProcessing,
                     customFields,
+                    getToken: getAuthorizationToken,
                 });
             reportsDispatch({
                 type: 'ADD_REPORT',
@@ -604,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',
@@ -622,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;
@@ -690,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') {
@@ -854,15 +855,12 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                             sectionOrder: newSectionOrder,
                         };
                         try {
-                            await fetch(client.queryEndpoint, {
-                                method: 'POST',
-                                headers: {
-                                    ...client.queryHeaders,
-                                    'Content-Type': 'application/json',
-                                },
-                                body: JSON.stringify({ metadata: body }),
-                                credentials: client.withCredentials ? 'include' : 'omit',
-                            }).then((res) => res.json());
+                            await quillFetch({
+                                client,
+                                task: 'set-section-order',
+                                metadata: body,
+                                getToken: getAuthorizationToken,
+                            });
                         }
                         catch (e) {
                             console.error(e);
@@ -900,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({
@@ -948,6 +946,7 @@ export const ContextProvider = ({ children, initialTheme, publicKey, queryEndpoi
                 tenants,
                 caller,
                 abortSignal: fetchSchemaAbortController.current.signal,
+                getToken: getAuthorizationToken,
             });
             if (currentProcessId === fetchSchemaProcessId.current) {
                 setSchemaData({
@@ -981,62 +980,100 @@ 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] = {};
                     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,
@@ -1067,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 &&
@@ -1074,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({
@@ -1090,78 +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(() => {
-        // 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' });
-        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' });
-    }, [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,
-                                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?.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 }) }) }) }) }) }) }) }) }) }));
 };