@quillsql/admin 1.6.1 → 1.6.3

package/dist/esm/AdminProvider.js

@@ -1,55 +1,106 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useReducer, createContext, useEffect, useContext, useState, } from 'react';
-import { theme } from './Admin';
+import { useReducer, createContext, useEffect, useContext, useState, useMemo, } from 'react';
+import { defaultTheme as theme, } from './Admin';
 import { QuillProvider } from '@quillsql/react';
-import { QUILL_SERVER } from './utils/constants';
+import { ALL_TENANTS, QUILL_QUERY_ENDPOINT, QUILL_SERVER, SINGLE_TENANT, } from './utils/constants';
 import CreateEnvironment from './public_components/CreateEnvironment';
 import { getSchemaInfo } from './utils/schema';
+import { ButtonPrimitive, ModalPrimitive } from './primitives';
+import equal from 'fast-deep-equal';
+import { quillFetch, } from './utils/dataFetcher';
 const AdminContext = createContext(undefined);
 function reducer(state, action) {
     switch (action.type) {
-        case 'SET_QUERY_ENDPOINT':
-            return { ...state, queryEndpoint: action.payload };
-        case 'SET_QUERY_HEADERS':
-            return { ...state, queryHeaders: action.payload };
-        case 'SET_WITH_CREDENTIALS':
-            return { ...state, withCredentials: action.payload };
         case 'SET_CLIENT':
-            return { ...state, client: action.payload };
+            return {
+                ...state,
+                client: action.payload,
+            };
+        case 'SET_CLIENT_AND_TENANTS': {
+            const ownerTenant = action.payload?.allTenantTypes?.find((tenant) => tenant.tenantField === action.payload.ownerTenantFields?.[0]);
+            return {
+                ...state,
+                client: action.payload,
+                selectedDashboard: state.selectedDashboard ?? action.payload?.defaultDashboard?.name,
+                reportId: null,
+                selectedTenantField: action.payload?.defaultDashboard?.owner ?? ownerTenant?.tenantField,
+                selectedTenantValues: ownerTenant?.defaultId
+                    ? [
+                        ownerTenant.fieldType === 'number'
+                            ? Number(ownerTenant.defaultId)
+                            : ownerTenant.defaultId,
+                    ]
+                    : undefined,
+                selectedDashboardTenantIds: undefined,
+                mappableDashboardTenantIds: undefined,
+                mappableDashboardTenantIdsLoading: false,
+                currentTenantIdentity: ownerTenant
+                    ? [
+                        {
+                            tenantField: ownerTenant.tenantField,
+                            tenantIds: ownerTenant?.defaultId
+                                ? [
+                                    ownerTenant.fieldType === 'number'
+                                        ? Number(ownerTenant.defaultId)
+                                        : ownerTenant.defaultId,
+                                ]
+                                : [ALL_TENANTS],
+                        },
+                    ]
+                    : undefined,
+            };
+        }
         case 'SET_CLIENTS':
             return { ...state, clients: action.payload };
         case 'UPDATE_CLIENTS':
             return { ...state, clients: [...state.clients, action.payload] };
-        case 'SET_ENVIRONMENT':
-            return { ...state, environment: action.payload };
-        case 'SET_ORGANIZATIONS':
-            return { ...state, organizations: action.payload };
-        case 'SET_ORGANIZATION_ID':
-            return { ...state, organizationId: action.payload };
         case 'SET_ACTIVE_QUERY':
             return { ...state, activeQuery: action.payload };
+        case 'SET_ACTIVE_SAVED_QUERY_REPORT_ID':
+            return { ...state, activeSavedQueryReportId: action.payload };
         case 'SET_ACTIVE_EDIT_ITEM':
             return { ...state, activeEditItem: action.payload };
         case 'SET_TABLES':
             return { ...state, tables: action.payload };
-        case 'SET_SCHEMA':
-            return { ...state, schema: action.payload };
         case 'SET_ACTIVE_COMPONENT':
             return { ...state, activeComponent: action.payload };
         case 'SET_REPORT_ID':
             return { ...state, reportId: action.payload };
-        case 'SET_THEME':
-            return { ...state, theme: action.payload };
-        case 'SET_DASHBOARDS':
-            return { ...state, dashboards: action.payload };
-        case 'SET_SELECTED_DASHBOARD':
-            return { ...state, selectedDashboard: action.payload };
+        case 'SET_SELECTED_DASHBOARD_NAME':
+            return {
+                ...state,
+                selectedDashboard: action.payload?.dashboard ?? null,
+                reportId: action.payload?.reportId === null ? null : state.reportId,
+            };
         case 'SET_NAVIGATE_TO_DASHBOARD_MANAGER':
             return { ...state, navigateToDashboardManager: action.payload };
         case 'SET_NAVIGATE_TO_DASHBOARD_BUILDER':
             return { ...state, navigateToDashboardBuilder: action.payload };
+        case 'SET_NAVIGATE_TO_VIRTUAL_TABLE_BUILDER':
+            return { ...state, navigateToVirtualTableBuilder: action.payload };
         case 'SET_DATABASE_TYPE_MISMATCH':
             return { ...state, databaseTypeMismatch: action.payload };
+        case 'SET_DATABASE_SCHEMA':
+            return { ...state, databaseSchema: action.payload };
+        case 'SET_TEMPLATE_DASHBOARD':
+            return { ...state, templateDashboard: action.payload };
+        case 'SET_SELECTED_TENANT_FOREIGN_KEY':
+            return { ...state, selectedTenantField: action.payload };
+        case 'SET_SELECTED_TENANT_VALUES':
+            return { ...state, selectedTenantValues: action.payload };
+        case 'SET_SELECTED_DASHBOARD_TENANT_IDS':
+            return { ...state, selectedDashboardTenantIds: action.payload };
+        case 'SET_MAPPABLE_DASHBOARD_TENANT_IDS':
+            return { ...state, mappableDashboardTenantIds: action.payload };
+        case 'SET_MAPPABLE_DASHBOARD_TENANT_IDS_LOADING':
+            return { ...state, mappableDashboardTenantIdsLoading: action.payload };
+        case 'SET_CURRENT_TENANT_IDENTITY':
+            if (equal(state.currentTenantIdentity, action.payload)) {
+                return state;
+            }
+            return { ...state, currentTenantIdentity: action.payload };
+        case 'SET_QUERY_HEADERS':
+            return { ...state, queryHeaders: action.payload };
         default:
             return state;
     }
@@ -59,225 +110,304 @@ const useAdmin = () => {
     if (context === undefined) {
         throw new Error('useAdmin must be used within an AdminProvider');
     }
-    return context;
+    return { ...context, clientLoading: context.loading };
 };
-function AdminProvider({ children, publicKey, queryEndpoint, queryHeaders, withCredentials, customTheme, domainName, onOnboardComplete, }) {
-    const [loading, setLoading] = useState(true);
-    const loadState = () => {
-        try {
-            const serializedState = sessionStorage.getItem('adminState');
-            if (serializedState === null) {
-                return {};
-            }
-            const savedState = JSON.parse(serializedState);
-            if (savedState?.publicKey != publicKey) {
-                sessionStorage.removeItem('adminState');
-                return {};
+function AdminProvider({ children, publicKey, queryEndpoint = `${QUILL_SERVER}${QUILL_QUERY_ENDPOINT}`, queryHeaders, withCredentials, domainName, onOnboardComplete, flagsList, getAuthorizationToken = async () => '', }) {
+    const [clientLoading, setClientLoading] = useState(false);
+    const [currentFetchingClient, setCurrentFetchingClient] = useState(undefined);
+    const [schemaLoading, setSchemaLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const parsedSessionStorageAdminState = (adminState) => {
+        // We store things using JSON.strigify and then restore them with JSON.parse
+        // But certain objects, such as Dates, don't stringify/parse correctly
+        // So we need to manually restore them
+        if (adminState?.activeEditItem) {
+            if (adminState.activeEditItem?.filtersApplied) {
+                adminState.activeEditItem.filtersApplied.forEach((filter) => {
+                    if (filter.startDate) {
+                        filter.startDate = new Date(filter.startDate);
+                    }
+                    if (filter.endDate) {
+                        filter.endDate = new Date(filter.endDate);
+                    }
+                });
             }
-            return {
-                selectedDashboard: savedState.selectedDashboard || null,
-                organizationId: savedState.organizationId || null,
-                client: savedState.client || null,
-                publicKey: savedState.publicKey || null,
-            };
-        }
-        catch (err) {
-            return {};
         }
+        return adminState;
     };
-    const initialState = {
-        loading: true,
-        publicKey: publicKey || '',
-        queryEndpoint,
-        queryHeaders,
-        withCredentials,
-        client: null,
-        clients: [],
-        environment: 'PRODUCTION',
-        organization: null,
-        organizations: [],
-        organizationId: null,
-        activeQuery: '',
-        activeEditItem: null,
-        tables: [],
-        schema: [],
-        activeComponent: 'Dashboards',
-        dashboards: [],
-        selectedDashboard: null,
-        reportId: null,
-        theme: customTheme || theme,
-        organizationIdSet: false,
-        dateFilter: {},
-        domainName: domainName || '',
-        databaseTypeMismatch: { show: false, backendDatabaseType: '' },
-        ...loadState(),
-    };
+    const initialState = useMemo(() => {
+        const localState = JSON.parse(sessionStorage.getItem('quill-adminState') ?? 'null');
+        if (localState?.domainName === domainName && domainName) {
+            return parsedSessionStorageAdminState(localState);
+        }
+        sessionStorage.removeItem('quill-adminState');
+        sessionStorage.removeItem('quill-client');
+        return {
+            loading: true,
+            publicKey: publicKey || '',
+            queryEndpoint,
+            queryHeaders,
+            withCredentials,
+            client: null,
+            clients: [],
+            organization: null,
+            organizations: [],
+            organizationId: null,
+            activeQuery: '',
+            activeEditItem: undefined,
+            tables: [],
+            schema: [],
+            activeComponent: 'Dashboards',
+            dashboards: [],
+            selectedDashboard: null,
+            reportId: null,
+            report: null,
+            theme: theme,
+            organizationIdSet: false,
+            dateFilter: {},
+            domainName: domainName || '',
+            databaseTypeMismatch: { show: false, backendDatabaseType: '' },
+        };
+    }, []);
     const [state, dispatch] = useReducer(reducer, initialState);
-    useEffect(() => {
+    const stateWithFlagsList = useMemo(() => {
+        return {
+            ...state,
+            client: {
+                ...state.client,
+                allTenantTypes: state.client?.allTenantTypes?.map((tenant) => ({
+                    ...tenant,
+                    flags: tenant.scope === 'database' ? tenant.flags : flagsList,
+                })),
+            },
+            clients: [
+                ...state.clients.map((client) => ({
+                    ...client,
+                    allTenantTypes: client?.allTenantTypes?.map((tenant) => ({
+                        ...tenant,
+                        flags: tenant.scope === 'database' ? tenant.flags : flagsList,
+                    })),
+                })),
+            ],
+        };
+    }, [state, flagsList, state.client]);
+    const setClient = (client, setLoadingImmediately = false) => {
+        if (setLoadingImmediately) {
+            setClientLoading(true);
+        }
+        dispatch({ type: 'SET_CLIENT_AND_TENANTS', payload: client });
+    };
+    async function quillFetchWithToken({ client, task, method = 'POST', metadata, abortSignal, credentials = 'omit', urlParameters, includeFlags = false, includeTenants = false, adminMode, }) {
         try {
-            const stateToSave = {
-                selectedDashboard: state.selectedDashboard,
-                organizationId: state.organizationId,
-                publicKey: state.publicKey,
-                client: state.client,
-            };
-            const serializedState = JSON.stringify(stateToSave);
-            sessionStorage.setItem('adminState', serializedState);
+            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 {
-            console.warn('Error writing state to session storage');
+        catch (e) {
+            if (e instanceof Error && e.name === 'AbortError') {
+                throw e;
+            }
+            console.error('Failed to fetch:', e);
+            return { error: 'Failed to fetch data' };
         }
-    }, [
-        state.selectedDashboard,
-        state.organizationId,
-        state.client,
-        state.publicKey,
-    ]);
+    }
+    // queryHeaders prop can change dynamically, need to stay updated
     useEffect(() => {
+        dispatch({ type: 'SET_QUERY_HEADERS', payload: queryHeaders });
+    }, [queryHeaders]);
+    useEffect(() => {
+        const client = JSON.parse(sessionStorage.getItem('quill-client') || 'null');
+        if (client?.id === publicKey) {
+            dispatch({
+                type: 'SET_CLIENT',
+                payload: { ...client, _id: publicKey },
+            });
+        }
         async function fetchClient(publicKey) {
             if (!publicKey) {
                 return;
             }
+            setClientLoading(true);
+            setCurrentFetchingClient(publicKey);
             try {
-                const response = await fetch(`${queryEndpoint}`, {
-                    method: 'POST',
-                    headers: {
-                        ...queryHeaders,
-                        'Content-Type': 'application/json',
+                const data = await quillFetchWithToken({
+                    client: {
+                        queryEndpoint,
+                        queryHeaders: queryHeaders,
+                        withCredentials: !!state.withCredentials,
+                        clientId: publicKey,
                     },
-                    body: JSON.stringify({
-                        metadata: {
-                            clientId: publicKey,
-                            publicKey,
-                            task: 'client',
-                        },
-                    }),
+                    task: 'client',
+                    metadata: {
+                        clientId: publicKey,
+                        fetchDefaultDashboard: true,
+                    },
+                    adminMode: true,
+                });
+                if (data.status === 'error') {
+                    throw new Error(data.error);
+                }
+                const result = data.data || data;
+                if (!result.client) {
+                    console.error('Client not found.');
+                    return;
+                }
+                const allClientTenantIds = await Promise.all(result.client.allTenantTypes?.map(async (tenant) => {
+                    return await getClientTenantIds({
+                        queryEndpoint,
+                        queryHeaders: state.queryHeaders,
+                        withCredentials: state.withCredentials,
+                        tenant,
+                        clientId: result.client._id,
+                        getToken: getAuthorizationToken,
+                    });
+                }) ?? []);
+                const mappedTenantIds = allClientTenantIds.reduce((acc, curr) => {
+                    acc[curr.id] = curr.tenantIds;
+                    return acc;
+                }, {});
+                setClient({
+                    ...result.client,
+                    queryEndpoint: result.client.queryEndpoint ?? queryEndpoint,
+                    allTenantTypes: result.client.allTenantTypes?.map((tenant) => ({
+                        ...tenant,
+                        tenantIds: mappedTenantIds?.[tenant.id],
+                    })),
+                });
+                const allClientsData = await quillFetchWithToken({
+                    client: {
+                        queryEndpoint,
+                        queryHeaders: queryHeaders,
+                        withCredentials: !!state.withCredentials,
+                        clientId: publicKey,
+                    },
+                    task: 'clients',
+                    metadata: {
+                        clientId: publicKey,
+                        fetchDefaultDashboard: true,
+                    },
+                    adminMode: true,
                 });
-                const data = await response.json();
+                if (allClientsData.status === 'error') {
+                    throw new Error(allClientsData.error);
+                }
+                const allClientsResult = allClientsData.data || allClientsData;
+                if (allClientsResult.clients?.length === 0) {
+                    console.error('No clients found.');
+                    return;
+                }
+                const allClients = allClientsResult.clients.map((client) => ({
+                    ...client,
+                    allTenantTypes: client.allTenantTypes?.map((tenant) => ({
+                        ...tenant,
+                        tenantIds: [],
+                    })),
+                }));
                 dispatch({
-                    type: 'SET_CLIENT',
-                    payload: initialState.client || data.data.client,
+                    type: 'SET_CLIENTS',
+                    payload: allClients,
                 });
-                dispatch({ type: 'SET_CLIENTS', payload: data.data.clients });
             }
             catch (error) {
                 console.error('ERROR:', error);
             }
+            finally {
+                // We want this to trigger after the schema loading effect runs so the loading state doesn't flicker
+                setTimeout(() => {
+                    setClientLoading(false);
+                    setCurrentFetchingClient(undefined);
+                }, 200);
+            }
         }
-        fetchClient(publicKey);
-    }, [publicKey]);
+        if (currentFetchingClient === (state.client?.id ?? publicKey))
+            return;
+        fetchClient(state?.client?.id ?? publicKey);
+    }, [publicKey, state?.client?.id]);
+    // Session storage
+    useEffect(() => {
+        // Overwrite the large collections to save performance
+        sessionStorage.setItem('quill-adminState', JSON.stringify({
+            ...state,
+            client: {
+                ...state.client,
+                allTenantTypes: undefined,
+            },
+            clients: [],
+            tables: [],
+            dashboards: [],
+            allTenantTypes: undefined,
+            selectedTenantValues: undefined,
+            selectedDashboardTenantIds: undefined,
+            currentTenantIdentity: undefined,
+        }));
+    }, [state]);
+    const tenants = useMemo(() => {
+        return state.selectedTenantField === SINGLE_TENANT
+            ? [SINGLE_TENANT]
+            : (state.currentTenantIdentity ?? [ALL_TENANTS]);
+    }, [state.client?.id, state.currentTenantIdentity]);
     useEffect(() => {
-        async function fetchSchemaAndTables(clientId) {
-            if (!clientId) {
+        async function fetchSchemaAndTables(clientId, tenants) {
+            setSchemaLoading(true);
+            if (!clientId)
                 return;
-            }
             try {
-                const schemaData = await getSchemaInfo({
-                    queryEndpoint: state.queryEndpoint,
-                    queryHeaders: state.queryHeaders,
-                    publicKey: state.client._id,
-                    customerId: state.client.customerId,
-                    gatherSchemaData: true,
-                }, 'svm');
-                dispatch({ type: 'SET_TABLES', payload: schemaData });
-                dispatch({ type: 'SET_SCHEMA', payload: schemaData });
+                const { schemaData: schema } = await getSchemaInfo({
+                    name: state.client?.name ?? '',
+                    queryEndpoint: state.queryEndpoint ?? '',
+                    queryHeaders: state.queryHeaders ?? undefined,
+                    publicKey: clientId,
+                    clientId: clientId,
+                    withCredentials: state.withCredentials || false,
+                }, 'svm', getAuthorizationToken, tenants);
+                dispatch({ type: 'SET_TABLES', payload: schema });
             }
             catch (error) {
                 console.error('ERROR:', error);
             }
-        }
-        if (state.client?._id) {
-            fetchSchemaAndTables(state.client._id);
-        }
-    }, [state?.client, publicKey]);
-    useEffect(() => {
-        let isSubscribed = true;
-        async function getCustomers() {
-            const requestOptions = {
-                method: 'GET',
-                headers: {
-                    Authorization: `Bearer `,
-                    ...(state.environment && { environment: state.environment }),
-                },
-            };
-            try {
-                let response;
-                if (state.queryEndpoint) {
-                    response = await fetch(state.queryEndpoint, {
-                        method: 'POST',
-                        headers: {
-                            ...state.queryHeaders,
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            metadata: {
-                                clientId: state.client._id,
-                                task: 'orgs',
-                                databaseType: state.client.databaseType,
-                            },
-                        }),
-                        credentials: state.withCredentials ? 'include' : 'omit', // If withCredentials is true, set to 'include'. Otherwise, set to 'omit'.
-                    });
-                }
-                else {
-                    response = await fetch(`${QUILL_SERVER}/orgs/${state.client._id}/`, requestOptions);
-                    if (!response.ok) {
-                        setLoading(false);
-                        throw new Error(`HTTP error! status: ${response.status}`);
-                    }
-                }
-                const data = await response.json();
-                if (data.status === 'error') {
-                    throw new Error(data.error);
-                }
-                if (data.queries.dbMismatched) {
-                    dispatch({
-                        type: 'SET_DATABASE_TYPE_MISMATCH',
-                        payload: {
-                            show: true,
-                            backendDatabaseType: data.queries.backendDatabaseType,
-                        },
-                    });
-                    setLoading(false);
-                    return;
-                }
-                if (state.queryEndpoint) {
-                    dispatch({
-                        type: 'SET_ORGANIZATIONS',
-                        payload: [...data.data.rows],
-                    });
-                }
-                else {
-                    dispatch({
-                        type: 'SET_ORGANIZATIONS',
-                        payload: [...data.orgs],
-                    });
-                }
-                dispatch({
-                    type: 'SET_DATABASE_TYPE_MISMATCH',
-                    payload: { show: false, backendDatabaseType: '' },
-                });
-                dispatch({
-                    type: 'SET_ORGANIZATION_ID',
-                    payload: state.organizationId || state.client.adminCustomerId,
-                });
-                setLoading(false);
-            }
-            catch (error) {
-                console.error('Error fetching data:', error);
+            finally {
+                setSchemaLoading(false);
             }
         }
-        if (isSubscribed && state.client) {
-            getCustomers();
+        if (!state.queryEndpoint) {
+            console.error('No queryEndpoint provided.');
+            return;
         }
-        if (!publicKey) {
-            setLoading(false);
+        if (state?.client?._id &&
+            (!state?.client?.featureFlags?.customFieldsEnabled || tenants) &&
+            state?.currentTenantIdentity) {
+            fetchSchemaAndTables(state.client._id, tenants);
         }
-        return () => {
-            isSubscribed = false;
-        };
-    }, [state.environment, state.client, state.organizationId, publicKey]);
-    return (_jsxs(AdminContext.Provider, { value: { state, dispatch }, children: [!state.client && !loading && _jsx(CreateEnvironment, { onOnboardComplete: onOnboardComplete }), state.client && (_jsx(QuillProvider, { organizationId: state.organizationId, queryEndpoint: state.queryEndpoint ?? '', withCredentials: state.withCredentials, queryHeaders: state.queryHeaders ?? {}, publicKey: state.client._id, environment: state.environment, theme: state.theme, children: children })), _jsx("style", { children: `/* For WebKit-based browsers (Chrome, Safari, Opera) */
+    }, [state?.client?._id, tenants]);
+    const flags = useMemo(() => {
+        return state.selectedTenantField === SINGLE_TENANT
+            ? state.selectedTenantValues?.map((value) => value.toString())
+            : undefined;
+    }, [state.selectedTenantValues, state.client?.id]);
+    if (!state.client || !state.tables) {
+        return null;
+    }
+    return (_jsxs(AdminContext.Provider, { value: {
+            state: stateWithFlagsList,
+            dispatch,
+            loading: clientLoading || schemaLoading,
+            setClient,
+            getToken: getAuthorizationToken,
+            quillFetchWithToken,
+        }, children: [!state.client && !clientLoading && (_jsx(CreateEnvironment, { onOnboardComplete: onOnboardComplete })), state.client && (_jsxs(QuillProvider, { tenants: tenants, flags: flags, queryEndpoint: state.queryEndpoint, withCredentials: state.withCredentials, queryHeaders: state.queryHeaders, publicKey: state.client._id, theme: state.theme, isAdmin: true, getAuthorizationToken: getAuthorizationToken, children: [children, _jsx(ErrorModal, { error: error, setError: setError })] })), _jsx("style", { children: `/* For WebKit-based browsers (Chrome, Safari, Opera) */
         ::-webkit-scrollbar {
           width: 0;
           height: 0;
@@ -293,4 +423,55 @@ function AdminProvider({ children, publicKey, queryEndpoint, queryHeaders, withC
           scrollbar-width: none;
         }` })] }));
 }
+function ErrorModal({ error, setError, }) {
+    if (!error) {
+        return null;
+    }
+    return (_jsx(ModalPrimitive, { onClose: () => setError(null), isOpen: error ? true : false, children: _jsxs("div", { style: { display: 'flex', flexDirection: 'column', width: '100%' }, children: [_jsx("div", { style: {
+                        marginBottom: '10px',
+                        display: 'flex',
+                        flexDirection: 'row',
+                        alignItems: 'center',
+                        justifyContent: 'space-between',
+                        width: '100%',
+                    }, children: _jsx("h2", { style: { fontWeight: 600, fontSize: 18, color: '#212121' }, children: "Error" }) }), _jsx("div", { style: { marginBottom: '10px' }, children: _jsx("div", { children: error.message || error }) }), _jsx("div", { style: { display: 'flex', justifyContent: 'flex-end' }, children: _jsx(ButtonPrimitive, { onClick: () => setError(null), label: "Dismiss" }) })] }) }));
+}
+export async function getClientTenantIds({ queryEndpoint, queryHeaders, withCredentials, tenant, clientId, getToken, }) {
+    if (tenant.scope === 'database') {
+        return {
+            id: tenant.id,
+            tenantIds: [],
+        };
+    }
+    const data = await quillFetch({
+        client: {
+            queryEndpoint,
+            queryHeaders: queryHeaders,
+            withCredentials: !!withCredentials,
+            clientId: clientId,
+        },
+        task: 'tenant-query',
+        metadata: {
+            tenantId: tenant.id,
+            clientId: clientId,
+        },
+        getToken,
+    });
+    if (!data.data?.rows || !data.data?.fields) {
+        return {
+            id: tenant.id,
+            tenantIds: [],
+        };
+    }
+    const tenantFieldDataType = data.data.fields.find((field) => field.name === tenant.tenantField)?.dataTypeID;
+    const isNumber = [20, 21, 23, 700, 701, 1700].includes(tenantFieldDataType);
+    return {
+        id: tenant.id,
+        tenantIds: data.data.rows.map((row) => ({
+            id: isNumber ? Number(row[tenant.tenantField]) : row[tenant.tenantField],
+            flag: row['quill_flag'],
+            label: row['quill_label'],
+        })),
+    };
+}
 export { AdminProvider, useAdmin };