test pseudo query

artemmufazalov · artemmufazalov · commit e8d01e2e17a8 · 2025-11-17T16:40:44.000+03:00
diff --git a/src/containers/Tenant/Diagnostics/TenantOverview/TenantOverview.tsx b/src/containers/Tenant/Diagnostics/TenantOverview/TenantOverview.tsx
@@ -19,6 +19,7 @@ import {getInfoTabLinks} from '../../../../utils/additionalProps';
 import {TENANT_DEFAULT_TITLE} from '../../../../utils/constants';
 import {useAutoRefreshInterval, useTypedDispatch, useTypedSelector} from '../../../../utils/hooks';
 import {useClusterNameFromQuery} from '../../../../utils/hooks/useDatabaseFromQuery';
+import {canShowTenantMonitoringTab} from '../../../../utils/monitoringVisibility';
 import {useTenantPage} from '../../TenantNavigation/useTenantNavigation';
 import {mapDatabaseTypeToDBName} from '../../utils/schema';
 
diff --git a/src/containers/Tenant/ObjectSummary/SchemaTree/SchemaTree.tsx b/src/containers/Tenant/ObjectSummary/SchemaTree/SchemaTree.tsx
@@ -20,6 +20,7 @@ import type {EPathType, TEvDescribeSchemeResult} from '../../../../types/api/sch
 import {valueIsDefined} from '../../../../utils';
 import {useTypedDispatch, useTypedSelector} from '../../../../utils/hooks';
 import {getConfirmation} from '../../../../utils/hooks/withConfirmation/useChangeInputWithConfirmation';
+import {canShowTenantMonitoringTab} from '../../../../utils/monitoringVisibility';
 import {useTenantPage} from '../../TenantNavigation/useTenantNavigation';
 import {getSchemaControls} from '../../utils/controls';
 import {
diff --git a/src/containers/Tenant/utils/schemaActions.tsx b/src/containers/Tenant/utils/schemaActions.tsx
@@ -12,6 +12,7 @@ import {
 } from '../../../store/reducers/tenant/constants';
 import {setDiagnosticsTab, setQueryTab} from '../../../store/reducers/tenant/tenant';
 import type {TenantPage} from '../../../store/reducers/tenant/types';
+import type {IQueryResult} from '../../../types/store/query';
 import createToast from '../../../utils/createToast';
 import {insertSnippetToEditor} from '../../../utils/monaco/insertSnippet';
 import {transformPath} from '../ObjectSummary/transformPath';
diff --git a/src/containers/UserSettings/settings.tsx b/src/containers/UserSettings/settings.tsx
@@ -3,7 +3,7 @@ import type {IconProps} from '@gravity-ui/uikit';
 import {createNextState} from '@reduxjs/toolkit';
 
 import {codeAssistBackend} from '../../store';
-import {DEFAULT_USER_SETTINGS, SETTING_KEYS} from '../../store/reducers/settings/constants';
+import {SETTING_KEYS} from '../../store/reducers/settings/constants';
 import {AclSyntax, OLD_BACKEND_CLUSTER_NAMES, PAGE_IDS, SECTION_IDS} from '../../utils/constants';
 import {Lang} from '../../utils/i18n';
 
@@ -66,7 +66,6 @@ export const languageSetting: SettingProps = {
     title: i18n('settings.language.title'),
     type: 'radio',
     options: languageOptions,
-    defaultValue: DEFAULT_USER_SETTINGS[SETTING_KEYS.LANGUAGE],
     onValueUpdate: () => {
         window.location.reload();
     },
diff --git a/src/services/api/index.ts b/src/services/api/index.ts
@@ -44,19 +44,18 @@ export class YdbEmbeddedAPI {
 
     meta?: MetaAPI;
     metaSettings?: MetaSettingsAPI;
-    metaSettings?: MetaSettingsAPI;
     codeAssist?: CodeAssistAPI;
 
     constructor({
         webVersion = false,
         withCredentials = false,
         singleClusterMode = true,
-        // proxyMeta = false,
-        proxyMeta = true,
+        proxyMeta = false,
+        // proxyMeta = true,
         csrfTokenGetter = () => undefined,
         defaults = {},
-        // useRelativePath = false,
-        useRelativePath = true,
+        useRelativePath = false,
+        // useRelativePath = true,
     }: YdbEmbeddedAPIProps) {
         const axiosParams: AxiosWrapperOptions = {config: {withCredentials, ...defaults}};
         const baseApiParams = {singleClusterMode, proxyMeta, useRelativePath};
diff --git a/src/store/reducers/authentication/authentication.ts b/src/store/reducers/authentication/authentication.ts
@@ -34,8 +34,8 @@ export const slice = createSlice({
             state.id = UserID;
 
             // TODO: test, remove after
-            state.user = 'root';
-            state.id = 'root';
+            // state.user = 'root';
+            // state.id = 'root';
             // TODO: test, remove after
 
             // If ydb version supports this feature,
diff --git a/src/store/reducers/settings/api.ts b/src/store/reducers/settings/api.ts
@@ -11,7 +11,7 @@ import {api} from '../api';
 
 import type {SettingKey} from './constants';
 import {DEFAULT_USER_SETTINGS, SETTINGS_OPTIONS} from './constants';
-import {readSettingValueFromLS} from './utils';
+import {parseSettingValue, readSettingValueFromLS, setSettingValueToLS} from './utils';
 
 export const settingsApi = api.injectEndpoints({
     endpoints: (builder) => ({
@@ -23,7 +23,7 @@ export const settingsApi = api.injectEndpoints({
                     return {data: undefined};
                 }
 
-                const defaultValue = DEFAULT_USER_SETTINGS[name as SettingKey];
+                const defaultValue = DEFAULT_USER_SETTINGS[name as SettingKey] as unknown;
 
                 // Do not load LS value from always sync values.
                 // In case there is no settings service
@@ -34,14 +34,31 @@ export const settingsApi = api.injectEndpoints({
 
                 const savedValue = readSettingValueFromLS(name);
 
-                return {data: savedValue ?? defaultValue};
+                const data = (savedValue ?? defaultValue) as unknown;
+
+                return {data};
             },
         }),
         getSingleSetting: builder.query({
-            queryFn: async ({name, user}: GetSingleSettingParams, baseApi) => {
+            queryFn: async ({name, user}: Partial<GetSingleSettingParams>, baseApi) => {
                 try {
-                    if (!window.api.metaSettings) {
-                        throw new Error('MetaSettings API is not available');
+                    if (!name) {
+                        throw new Error('Setting name is not provided');
+                    }
+                    const dispatch = baseApi.dispatch as AppDispatch;
+
+                    if (!window.api.metaSettings || !user) {
+                        if (SETTINGS_OPTIONS[name]?.preventSyncWithLS) {
+                            const savedValue = readSettingValueFromLS(name);
+                            const value = savedValue ?? DEFAULT_USER_SETTINGS[name as SettingKey];
+                            dispatch(settingsApi.util.upsertQueryData('setting', {name}, value));
+                        }
+
+                        if (!user) {
+                            throw new Error('User is not provided');
+                        } else {
+                            throw new Error('MetaSettings API is not available');
+                        }
                     }
                     const data = await window.api.metaSettings.getSingleSetting({
                         name,
@@ -50,25 +67,38 @@ export const settingsApi = api.injectEndpoints({
                         preventBatching: SETTINGS_OPTIONS[name]?.preventBatching,
                     });
 
-                    const dispatch = baseApi.dispatch as AppDispatch;
+                    if (isNil(data.value)) {
+                        // Try to sync local value if there is no backend value
+                        syncLocalValueToMetaIfNoData(data, dispatch);
+                    } else {
+                        setSettingValueToLS(name, data.value);
 
-                    // Try to sync local value if there is no backend value
-                    syncLocalValueToMetaIfNoData(data, dispatch);
+                        const parsedValue = parseSettingValue(data.value);
+                        dispatch(settingsApi.util.upsertQueryData('setting', {name}, parsedValue));
+                    }
 
-                    return {data};
+                    return {data: data};
                 } catch (error) {
                     return {error};
                 }
             },
         }),
         setSingleSetting: builder.mutation({
-            queryFn: async (params: SetSingleSettingParams) => {
+            queryFn: async ({name, user, value}: Partial<SetSingleSettingParams>) => {
                 try {
-                    if (!window.api.metaSettings) {
-                        throw new Error('MetaSettings API is not available');
+                    if (!name || isNil(value)) {
+                        throw new Error('Setting name is not provided');
+                    }
+                    if (!window.api.metaSettings || !user) {
+                        // throw new Error('MetaSettings API is not available');
+                        return {data: undefined};
                     }
 
-                    const data = await window.api.metaSettings.setSingleSetting(params);
+                    const data = await window.api.metaSettings.setSingleSetting({
+                        name,
+                        user,
+                        value,
+                    });
 
                     if (data.status !== 'SUCCESS') {
                         throw new Error('Setting status is not SUCCESS');
@@ -80,25 +110,30 @@ export const settingsApi = api.injectEndpoints({
                 }
             },
             async onQueryStarted(args, {dispatch, queryFulfilled}) {
-                const {name, user, value} = args;
+                const {name, value} = args;
 
                 // Optimistically update existing cache entry
                 const patchResult = dispatch(
-                    settingsApi.util.updateQueryData('getSingleSetting', {name, user}, (draft) => {
-                        return {...draft, name, user, value};
+                    settingsApi.util.updateQueryData('setting', {name}, () => {
+                        return value;
                     }),
                 );
+
                 try {
                     await queryFulfilled;
+                    setSettingValueToLS(name, value);
                 } catch {
                     patchResult.undo();
                 }
             },
         }),
         getSettings: builder.query({
-            queryFn: async ({name, user}: GetSettingsParams, baseApi) => {
+            queryFn: async ({name, user}: Partial<GetSettingsParams>, baseApi) => {
                 try {
-                    if (!window.api.metaSettings) {
+                    if (!name) {
+                        throw new Error('Settings names are not provided');
+                    }
+                    if (!window.api.metaSettings || !user) {
                         throw new Error('MetaSettings API is not available');
                     }
                     const data = await window.api.metaSettings.getSettings({name, user});
@@ -123,13 +158,26 @@ export const settingsApi = api.injectEndpoints({
                                 newValue,
                             ),
                         ).then(() => {
-                            // Try to sync local value if there is no backend value
-                            // Do it after upsert if finished to ensure proper values update order
-                            // 1. New entry added to cache with nil value
-                            // 2. Positive entry update - local storage value replace nil in cache
-                            // 3.1. Set is successful, local value in cache
-                            // 3.2. Set is not successful, cache value reverted to previous nil
-                            syncLocalValueToMetaIfNoData(settingData, dispatch);
+                            if (isNil(settingData.value)) {
+                                // Try to sync local value if there is no backend value
+                                // Do it after upsert if finished to ensure proper values update order
+                                // 1. New entry added to cache with nil value
+                                // 2. Positive entry update - local storage value replace nil in cache
+                                // 3.1. Set is successful, local value in cache
+                                // 3.2. Set is not successful, cache value reverted to previous nil
+                                syncLocalValueToMetaIfNoData(settingData, dispatch);
+                            } else {
+                                setSettingValueToLS(settingName, data.value);
+
+                                const parsedValue = parseSettingValue(settingData.value);
+                                dispatch(
+                                    settingsApi.util.upsertQueryData(
+                                        'setting',
+                                        {name: settingName},
+                                        parsedValue,
+                                    ),
+                                );
+                            }
                         });
 
                         patches.push(patch);
diff --git a/src/store/reducers/settings/useSetting.ts b/src/store/reducers/settings/useSetting.ts
@@ -1,24 +1,14 @@
 import React from 'react';
 
-import {skipToken} from '@reduxjs/toolkit/query';
 import {debounce} from 'lodash';
 
-import type {SetSingleSettingParams} from '../../../types/api/settings';
+import type {SetSingleSettingParams, SettingValue} from '../../../types/api/settings';
 import {uiFactory} from '../../../uiFactory/uiFactory';
-import {useTypedDispatch} from '../../../utils/hooks/useTypedDispatch';
 import {useTypedSelector} from '../../../utils/hooks/useTypedSelector';
 import {selectID, selectUser} from '../authentication/authentication';
 
 import {settingsApi} from './api';
-import type {SettingKey} from './constants';
-import {DEFAULT_USER_SETTINGS, SETTINGS_OPTIONS} from './constants';
-import {getSettingValue, setSettingValue} from './settings';
-import {
-    parseSettingValue,
-    readSettingValueFromLS,
-    setSettingValueToLS,
-    stringifySettingValue,
-} from './utils';
+import {SETTINGS_OPTIONS} from './constants';
 
 type SaveSettingValue<T> = (value: T | undefined) => void;
 
@@ -31,11 +21,11 @@ export function useSetting<T>(
     name?: string,
     {debounceTime = 0}: UseSettingOptions = {},
 ): {value: T | undefined; saveValue: SaveSettingValue<T>; isLoading: boolean} {
-    const dispatch = useTypedDispatch();
+    const {data: settingValue} = settingsApi.useSettingQuery({name});
 
     const preventSyncWithLS = Boolean(name && SETTINGS_OPTIONS[name]?.preventSyncWithLS);
 
-    const settingValue = useTypedSelector((state) => getSettingValue(state, name)) as T | undefined;
+    // const settingValue = useTypedSelector((state) => getSettingValue(state, name)) as T | undefined;
 
     const authUserSID = useTypedSelector(selectUser);
     const anonymousUserId = useTypedSelector(selectID);
@@ -45,44 +35,36 @@ export function useSetting<T>(
 
     const shouldUseOnlyExternalSettings = shouldUseMetaSettings && preventSyncWithLS;
 
-    const params = React.useMemo(() => {
-        return shouldUseMetaSettings ? {user, name} : skipToken;
-    }, [shouldUseMetaSettings, user, name]);
-
-    const {currentData: metaSetting, isLoading: isSettingLoading} =
-        settingsApi.useGetSingleSettingQuery(params);
+    const {isLoading: isSettingLoading} = settingsApi.useGetSingleSettingQuery({user, name});
 
     const [setMetaSetting] = settingsApi.useSetSingleSettingMutation();
 
-    // Add loading state to settings that are stored externally
-    const isLoading = shouldUseMetaSettings ? isSettingLoading : false;
-
-    // Load initial value
-    React.useEffect(() => {
-        let value = name ? (DEFAULT_USER_SETTINGS[name as SettingKey] as T | undefined) : undefined;
-
-        if (!shouldUseOnlyExternalSettings) {
-            const savedValue = readSettingValueFromLS<T>(name);
-            value = savedValue ?? value;
-        }
-
-        dispatch(setSettingValue(name, value));
-    }, [name, shouldUseOnlyExternalSettings, dispatch]);
-
-    // Sync value from backend with LS and store
-    React.useEffect(() => {
-        if (shouldUseMetaSettings && metaSetting?.value) {
-            if (!shouldUseOnlyExternalSettings) {
-                setSettingValueToLS(name, metaSetting.value);
-            }
-            const parsedValue = parseSettingValue<T>(metaSetting.value);
-            dispatch(setSettingValue(name, parsedValue));
-        }
-    }, [shouldUseMetaSettings, shouldUseOnlyExternalSettings, metaSetting, name, dispatch]);
+    // // Load initial value
+    // React.useEffect(() => {
+    //     let value = name ? (DEFAULT_USER_SETTINGS[name as SettingKey] as T | undefined) : undefined;
+
+    //     if (!shouldUseOnlyExternalSettings) {
+    //         const savedValue = readSettingValueFromLS<T>(name);
+    //         value = savedValue ?? value;
+    //     }
+
+    //     dispatch(setSettingValue(name, value));
+    // }, [name, shouldUseOnlyExternalSettings, dispatch]);
+
+    // // Sync value from backend with LS and store
+    // React.useEffect(() => {
+    //     if (shouldUseMetaSettings && metaSetting?.value) {
+    //         if (!shouldUseOnlyExternalSettings) {
+    //             setSettingValueToLS(name, metaSetting.value);
+    //         }
+    //         const parsedValue = parseSettingValue<T>(metaSetting.value);
+    //         dispatch(setSettingValue(name, parsedValue));
+    //     }
+    // }, [shouldUseMetaSettings, shouldUseOnlyExternalSettings, metaSetting, name, dispatch]);
 
     const debouncedSetMetaSetting = React.useMemo(
         () =>
-            debounce((params: SetSingleSettingParams) => {
+            debounce((params: Partial<SetSingleSettingParams>) => {
                 setMetaSetting(params);
             }, debounceTime),
         [debounceTime, setMetaSetting],
@@ -95,20 +77,20 @@ export function useSetting<T>(
 
     const saveValue = React.useCallback<SaveSettingValue<T>>(
         (value) => {
-            if (shouldUseMetaSettings) {
-                debouncedSetMetaSetting({
-                    user,
-                    name: name,
-                    value: stringifySettingValue(value),
-                });
-            }
-
-            if (!shouldUseOnlyExternalSettings) {
-                setSettingValueToLS(name, value);
-            }
+            // if (shouldUseMetaSettings) {
+            debouncedSetMetaSetting({
+                user,
+                name: name,
+                value: value as SettingValue,
+            });
+            // }
+
+            // if (!shouldUseOnlyExternalSettings) {
+            //     setSettingValueToLS(name, value);
+            // }
         },
         [shouldUseMetaSettings, shouldUseOnlyExternalSettings, user, name, debouncedSetMetaSetting],
     );
 
-    return {value: settingValue, saveValue, isLoading} as const;
+    return {value: settingValue as T | undefined, saveValue, isLoading: isSettingLoading} as const;
 }
diff --git a/src/uiFactory/uiFactory.ts b/src/uiFactory/uiFactory.ts
@@ -20,7 +20,7 @@ const uiFactoryBase: UIFactory = {
     },
     hasAccess: true,
     useDatabaseId: false,
-    useMetaSettings: true,
+    // useMetaSettings: true,
     // useMetaSettings: false,
 };
 
