ydb-embedded-ui 6.6.0 → 6.7.0

package/dist/src/store/reducers/schema/schema.js

@@ -1,116 +1,72 @@
 import { createSelector } from '@reduxjs/toolkit';
 import { isEntityWithMergedImplementation } from '../../../containers/Tenant/utils/schema';
-import { settingsManager } from '../../../services/settings';
-import { AUTO_REFRESH_INTERVAL } from '../../../utils/constants';
-import { createApiRequest, createRequestActionTypes } from '../../utils';
-export const FETCH_SCHEMA = createRequestActionTypes('schema', 'FETCH_SCHEMA');
-const PRELOAD_SCHEMAS = 'schema/PRELOAD_SCHEMAS';
-const SET_SCHEMA = 'schema/SET_SCHEMA';
+import { api } from '../api';
 const SET_SHOW_PREVIEW = 'schema/SET_SHOW_PREVIEW';
-export const SET_AUTOREFRESH_INTERVAL = 'schema/SET_AUTOREFRESH_INTERVAL';
-const RESET_LOADING_STATE = 'schema/RESET_LOADING_STATE';
-const autoRefreshLS = Number(settingsManager.readUserSettingsValue(AUTO_REFRESH_INTERVAL, 0));
 export const initialState = {
     loading: true,
-    wasLoaded: false,
     data: {},
     currentSchemaPath: undefined,
-    autorefresh: isNaN(autoRefreshLS) ? 0 : autoRefreshLS,
     showPreview: false,
 };
 const schema = (state = initialState, action) => {
-    var _a;
     switch (action.type) {
-        case FETCH_SCHEMA.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_SCHEMA.SUCCESS: {
-            const isCurrentSchema = !state.currentSchemaPath || state.currentSchemaPath === action.data.path;
-            const newData = Object.assign(Object.assign({}, state.data), action.data.data);
-            if (!isCurrentSchema) {
-                return Object.assign(Object.assign({}, state), { data: newData });
-            }
-            return Object.assign(Object.assign({}, state), { error: undefined, data: newData, currentSchema: action.data.currentSchema, currentSchemaPath: action.data.path, loading: false, wasLoaded: true });
-        }
-        case FETCH_SCHEMA.FAILURE: {
-            if ((_a = action.error) === null || _a === void 0 ? void 0 : _a.isCancelled) {
-                return state;
-            }
-            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
-        }
-        case PRELOAD_SCHEMAS: {
-            return Object.assign(Object.assign({}, state), { data: Object.assign(Object.assign({}, action.data), state.data) });
-        }
-        case SET_SCHEMA: {
-            return Object.assign(Object.assign({}, state), { currentSchemaPath: action.data });
-        }
-        case SET_AUTOREFRESH_INTERVAL: {
-            return Object.assign(Object.assign({}, state), { autorefresh: action.data });
-        }
         case SET_SHOW_PREVIEW: {
             return Object.assign(Object.assign({}, state), { showPreview: action.data });
         }
-        case RESET_LOADING_STATE: {
-            return Object.assign(Object.assign({}, state), { wasLoaded: initialState.wasLoaded });
-        }
         default:
             return state;
     }
 };
-export function getSchema({ path }) {
-    const request = window.api.getSchema({ path });
-    return createApiRequest({
-        request,
-        actions: FETCH_SCHEMA,
-        dataHandler: (data) => {
-            const newData = {};
-            if (data === null || data === void 0 ? void 0 : data.Path) {
-                newData[data.Path] = data;
-            }
-            return {
-                path: data === null || data === void 0 ? void 0 : data.Path,
-                currentSchema: data !== null && data !== void 0 ? data : undefined,
-                data: newData,
-            };
-        },
-    });
-}
-export function setCurrentSchemaPath(currentSchemaPath) {
-    return {
-        type: SET_SCHEMA,
-        data: currentSchemaPath,
-    };
-}
-export function setAutorefreshInterval(interval) {
-    return (dispatch) => {
-        settingsManager.setUserSettingsValue(AUTO_REFRESH_INTERVAL, interval);
-        dispatch({
-            type: SET_AUTOREFRESH_INTERVAL,
-            data: interval,
-        });
-    };
-}
 export function setShowPreview(value) {
     return {
         type: SET_SHOW_PREVIEW,
         data: value,
     };
 }
-// only stores data for paths that are not in the store yet
-// existing paths are ignored
-export function preloadSchemas(data) {
-    return {
-        type: PRELOAD_SCHEMAS,
-        data,
-    };
-}
-export function resetLoadingState() {
-    return {
-        type: RESET_LOADING_STATE,
-    };
-}
-const selectSchemaChildren = (state, path) => { var _a, _b; return path ? (_b = (_a = state.schema.data[path]) === null || _a === void 0 ? void 0 : _a.PathDescription) === null || _b === void 0 ? void 0 : _b.Children : undefined; };
-export const selectSchemaData = (state, path) => path ? state.schema.data[path] : undefined;
+export default schema;
+export const schemaApi = api.injectEndpoints({
+    endpoints: (builder) => ({
+        getSchema: builder.query({
+            queryFn: async ({ path }, { signal }) => {
+                try {
+                    const data = await window.api.getSchema({ path }, { signal });
+                    return { data: data !== null && data !== void 0 ? data : {} };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            keepUnusedDataFor: Infinity,
+            forceRefetch: ({ endpointState }) => {
+                const data = endpointState === null || endpointState === void 0 ? void 0 : endpointState.data;
+                if (data && typeof data === 'object' && 'partial' in data && data.partial) {
+                    return true;
+                }
+                return false;
+            },
+            onQueryStarted: async ({ path }, { dispatch, getState, queryFulfilled }) => {
+                const { data } = await queryFulfilled;
+                if (data) {
+                    const state = getState();
+                    const { PathDescription: { Children = [] } = {} } = data;
+                    for (const child of Children) {
+                        const { Name = '' } = child;
+                        const childPath = `${path}/${Name}`;
+                        const cachedData = schemaApi.endpoints.getSchema.select({ path: childPath })(state).data;
+                        if (!cachedData) {
+                            // not full data, but it contains PathType, which ensures seamless switch between nodes
+                            dispatch(schemaApi.util.upsertQueryData('getSchema', { path: childPath }, { PathDescription: { Self: child }, partial: true }));
+                        }
+                    }
+                }
+            },
+        }),
+    }),
+    overrideExisting: 'throw',
+});
+const getSchemaSelector = createSelector((path) => path, (path) => schemaApi.endpoints.getSchema.select({ path }));
+const selectGetSchema = createSelector((state) => state, (_state, path) => getSchemaSelector(path), (state, selectTabletsInfo) => selectTabletsInfo(state).data);
+const selectSchemaChildren = (state, path) => { var _a, _b; return (_b = (_a = selectGetSchema(state, path)) === null || _a === void 0 ? void 0 : _a.PathDescription) === null || _b === void 0 ? void 0 : _b.Children; };
 export const selectSchemaMergedChildrenPaths = createSelector([
     (_, path) => path,
     (_, _path, type) => type,
@@ -120,4 +76,3 @@ export const selectSchemaMergedChildrenPaths = createSelector([
         ? children === null || children === void 0 ? void 0 : children.map(({ Name }) => path + '/' + Name)
         : undefined;
 });
-export default schema;

package/dist/src/store/reducers/schema/types.d.ts

@@ -1,29 +1,10 @@
-import type { IResponseError } from '../../../types/api/error';
 import type { TEvDescribeSchemeResult } from '../../../types/api/schema';
-import type { ApiRequestAction } from '../../utils';
-import type { FETCH_SCHEMA, SET_AUTOREFRESH_INTERVAL, preloadSchemas, resetLoadingState, setCurrentSchemaPath, setShowPreview } from './schema';
+import type { setShowPreview } from './schema';
 export type SchemaData = Record<string, TEvDescribeSchemeResult>;
 export interface SchemaState {
-    loading: boolean;
-    wasLoaded: boolean;
-    data: SchemaData;
-    currentSchema?: TEvDescribeSchemeResult;
-    currentSchemaPath?: string;
-    autorefresh: number;
     showPreview: boolean;
-    error?: IResponseError;
 }
-export interface SchemaHandledResponse {
-    path?: string;
-    currentSchema?: TEvDescribeSchemeResult;
-    data?: SchemaData;
-}
-type SchemaApiRequestAction = ApiRequestAction<typeof FETCH_SCHEMA, SchemaHandledResponse, IResponseError>;
-export type SchemaAction = SchemaApiRequestAction | (ReturnType<typeof setCurrentSchemaPath> | {
-    type: typeof SET_AUTOREFRESH_INTERVAL;
-    data: number;
-} | ReturnType<typeof setShowPreview> | ReturnType<typeof preloadSchemas> | ReturnType<typeof resetLoadingState>);
+export type SchemaAction = ReturnType<typeof setShowPreview>;
 export interface SchemaStateSlice {
     schema: SchemaState;
 }
-export {};

package/dist/src/store/reducers/schemaAcl/schemaAcl.d.ts

@@ -1,135 +1,8 @@
-import type { Reducer } from '@reduxjs/toolkit';
-import type { SchemaAclAction, SchemaAclState } from './types';
-export declare const FETCH_SCHEMA_ACL: {
-    readonly REQUEST: "schemaAcl/FETCH_SCHEMA_ACL_REQUEST";
-    readonly SUCCESS: "schemaAcl/FETCH_SCHEMA_ACL_SUCCESS";
-    readonly FAILURE: "schemaAcl/FETCH_SCHEMA_ACL_FAILURE";
-};
-declare const schemaAcl: Reducer<SchemaAclState, SchemaAclAction>;
-export declare function getSchemaAcl({ path }: {
-    path: string;
-}): (dispatch: import("redux-thunk").ThunkDispatch<{
-    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
-    singleClusterMode: boolean;
-    cluster: import("../cluster/types").ClusterState;
-    tenant: import("../tenant/types").TenantState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").TabletsState;
-    schema: import("../schema/types").SchemaState;
-    host: import("../../../types/store/host").IHostState;
-    tenants: import("../tenants/types").TenantsState;
-    partitions: import("../partitions/types").PartitionsState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    tabletsFilters: {
-        loading: boolean;
-        requestTime: number;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        tabletsData: any;
-        nodes: any;
-        loading: boolean;
-        wasLoaded: boolean;
-        timeoutForRequest: number;
-        error: undefined;
-        data: undefined;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        error: any;
-        loading: boolean;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        stateFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        typeFilter: never[];
-    } | {
-        typeFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        stateFilter: never[];
-    };
-    heatmap: import("../../../types/store/heatmap").IHeatmapState;
-    settings: import("../settings/types").SettingsState;
-    schemaAcl: SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
-    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
-    hotKeys: import("../hotKeys/types").HotKeysState;
-    authentication: import("../authentication/types").AuthenticationState;
-    header: import("../header/types").HeaderState;
-    saveQuery: string | null;
-    fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersFilters;
-}, undefined, import("redux").UnknownAction> & import("redux").Dispatch<any>, getState: () => {
-    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">;
-    singleClusterMode: boolean;
-    cluster: import("../cluster/types").ClusterState;
-    tenant: import("../tenant/types").TenantState;
-    tooltip: import("../../../types/store/tooltip").ITooltipState;
-    tablets: import("../../../types/store/tablets").TabletsState;
-    schema: import("../schema/types").SchemaState;
-    host: import("../../../types/store/host").IHostState;
-    tenants: import("../tenants/types").TenantsState;
-    partitions: import("../partitions/types").PartitionsState;
-    executeQuery: import("../../../types/store/executeQuery").ExecuteQueryState;
-    tabletsFilters: {
-        loading: boolean;
-        requestTime: number;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        tabletsData: any;
-        nodes: any;
-        loading: boolean;
-        wasLoaded: boolean;
-        timeoutForRequest: number;
-        error: undefined;
-        data: undefined;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        error: any;
-        loading: boolean;
-        data: undefined;
-        wasLoaded: boolean;
-        stateFilter: never[];
-        typeFilter: never[];
-    } | {
-        stateFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        typeFilter: never[];
-    } | {
-        typeFilter: any;
-        data: undefined;
-        loading: boolean;
-        wasLoaded: boolean;
-        stateFilter: never[];
-    };
-    heatmap: import("../../../types/store/heatmap").IHeatmapState;
-    settings: import("../settings/types").SettingsState;
-    schemaAcl: SchemaAclState;
-    executeTopQueries: import("../executeTopQueries/types").TopQueriesFilters;
-    shardsWorkload: import("../shardsWorkload/types").ShardsWorkloadFilters;
-    hotKeys: import("../hotKeys/types").HotKeysState;
-    authentication: import("../authentication/types").AuthenticationState;
-    header: import("../header/types").HeaderState;
-    saveQuery: string | null;
-    fullscreen: boolean;
-    clusters: import("../clusters/types").ClustersFilters;
-}) => Promise<unknown>;
-export declare const setAclWasNotLoaded: () => {
-    readonly type: "schemaAcl/SET_DATA_WAS_NOT_LOADED";
-};
-export default schemaAcl;
+export declare const schemaAclApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, {
+    getSchemaAcl: import("@reduxjs/toolkit/query").QueryDefinition<{
+        path: string;
+    }, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("../api")._NEVER, unknown, {}>, "All", {
+        acl: import("../../../types/api/acl").TACE[] | undefined;
+        owner: string | undefined;
+    } | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;

package/dist/src/store/reducers/schemaAcl/schemaAcl.js

@@ -1,44 +1,18 @@
-import { createApiRequest, createRequestActionTypes } from '../../utils';
-export const FETCH_SCHEMA_ACL = createRequestActionTypes('schemaAcl', 'FETCH_SCHEMA_ACL');
-const SET_ACL_WAS_NOT_LOADED = 'schemaAcl/SET_DATA_WAS_NOT_LOADED';
-const initialState = {
-    loading: false,
-    wasLoaded: false,
-};
-const schemaAcl = (state = initialState, action) => {
-    var _a, _b, _c;
-    switch (action.type) {
-        case FETCH_SCHEMA_ACL.REQUEST: {
-            return Object.assign(Object.assign({}, state), { loading: true });
-        }
-        case FETCH_SCHEMA_ACL.SUCCESS: {
-            const acl = (_a = action.data.Common) === null || _a === void 0 ? void 0 : _a.ACL;
-            const owner = (_b = action.data.Common) === null || _b === void 0 ? void 0 : _b.Owner;
-            return Object.assign(Object.assign({}, state), { acl,
-                owner, loading: false, wasLoaded: true, error: undefined });
-        }
-        case FETCH_SCHEMA_ACL.FAILURE: {
-            if ((_c = action.error) === null || _c === void 0 ? void 0 : _c.isCancelled) {
-                return state;
-            }
-            return Object.assign(Object.assign({}, state), { error: action.error, loading: false });
-        }
-        case SET_ACL_WAS_NOT_LOADED: {
-            return Object.assign(Object.assign({}, state), { wasLoaded: false });
-        }
-        default:
-            return state;
-    }
-};
-export function getSchemaAcl({ path }) {
-    return createApiRequest({
-        request: window.api.getSchemaAcl({ path }),
-        actions: FETCH_SCHEMA_ACL,
-    });
-}
-export const setAclWasNotLoaded = () => {
-    return {
-        type: SET_ACL_WAS_NOT_LOADED,
-    };
-};
-export default schemaAcl;
+import { api } from '../api';
+export const schemaAclApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        getSchemaAcl: build.query({
+            queryFn: async ({ path }, { signal }) => {
+                try {
+                    const data = await window.api.getSchemaAcl({ path }, { signal });
+                    return { data: { acl: data.Common.ACL, owner: data.Common.Owner } };
+                }
+                catch (error) {
+                    return { error };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

package/dist/src/store/reducers/settings/settings.d.ts

@@ -1,28 +1,22 @@
-import type { Reducer, ThunkAction } from '@reduxjs/toolkit';
-import type { RootState } from '../..';
-import type { SettingsObject } from '../../../services/settings';
-import type { ProblemFilterValue, SetSettingValueAction, SettingsAction, SettingsRootStateSlice, SettingsState } from './types';
-export declare const SET_SETTING_VALUE = "settings/SET_VALUE";
-export declare const SET_USER_SETTINGS = "settings/SET_USER_SETTINGS";
+import type { Store } from '@reduxjs/toolkit';
+import type { AppDispatch } from '../../defaultStore';
+import type { ProblemFilterValue, SettingsState } from './types';
 export declare const ProblemFilterValues: {
     readonly ALL: "All";
     readonly PROBLEMS: "With problems";
 };
-export declare const initialState: {
-    problemFilter: "All";
-    userSettings: SettingsObject;
-    systemSettings: SettingsObject;
+export declare const initialState: SettingsState;
+export declare const changeFilter: import("@reduxjs/toolkit").ActionCreatorWithPayload<ProblemFilterValue, "settings/changeFilter">;
+export declare const getSettingValue: import("reselect").Selector<{
+    settings: SettingsState;
+}, unknown, [name: string]> & {
+    unwrapped: (state: SettingsState, name: string) => unknown;
+}, selectProblemFilter: import("reselect").Selector<{
+    settings: SettingsState;
+}, ProblemFilterValue, []> & {
+    unwrapped: (state: SettingsState) => ProblemFilterValue;
 };
-declare const settings: Reducer<SettingsState, SettingsAction>;
-export declare const setSettingValue: (name: string, value: unknown) => ThunkAction<void, RootState, unknown, SetSettingValueAction>;
-export declare const setUserSettings: (data: SettingsObject) => {
-    readonly type: "settings/SET_USER_SETTINGS";
-    readonly data: SettingsObject;
-};
-export declare const getSettingValue: (state: SettingsRootStateSlice, name: string) => unknown;
-export declare const changeFilter: (filter: ProblemFilterValue) => {
-    readonly type: "settings/CHANGE_PROBLEM_FILTER";
-    readonly data: ProblemFilterValue;
-};
-export declare const selectProblemFilter: (state: SettingsRootStateSlice) => ProblemFilterValue;
-export default settings;
+export declare const setSettingValue: (name: string, value: unknown) => (dispatch: AppDispatch) => void;
+export declare function syncUserSettingsFromLS(store: Store): void;
+declare const _default: import("redux").Reducer<SettingsState>;
+export default _default;

package/dist/src/store/reducers/settings/settings.js

@@ -1,7 +1,6 @@
+import { createSlice } from '@reduxjs/toolkit';
 import { DEFAULT_USER_SETTINGS, settingsManager } from '../../../services/settings';
-const CHANGE_PROBLEM_FILTER = 'settings/CHANGE_PROBLEM_FILTER';
-export const SET_SETTING_VALUE = 'settings/SET_VALUE';
-export const SET_USER_SETTINGS = 'settings/SET_USER_SETTINGS';
+import { parseJson } from '../../../utils/utils';
 export const ProblemFilterValues = {
     ALL: 'All',
     PROBLEMS: 'With problems',
@@ -13,38 +12,46 @@ export const initialState = {
     userSettings,
     systemSettings,
 };
-const settings = (state = initialState, action) => {
-    switch (action.type) {
-        case CHANGE_PROBLEM_FILTER:
-            return Object.assign(Object.assign({}, state), { problemFilter: action.data });
-        case SET_SETTING_VALUE: {
-            const newSettings = Object.assign(Object.assign({}, state.userSettings), { [action.data.name]: action.data.value });
-            return Object.assign(Object.assign({}, state), { userSettings: newSettings });
-        }
-        case SET_USER_SETTINGS: {
-            return Object.assign(Object.assign({}, state), { userSettings: Object.assign(Object.assign({}, state.userSettings), action.data) });
-        }
-        default:
-            return state;
-    }
-};
+const settingsSlice = createSlice({
+    name: 'settings',
+    initialState,
+    reducers: (create) => ({
+        changeFilter: create.reducer((state, action) => {
+            state.problemFilter = action.payload;
+        }),
+        setSettingValue: create.reducer((state, action) => {
+            state.userSettings[action.payload.name] = action.payload.value;
+        }),
+    }),
+    selectors: {
+        getSettingValue: (state, name) => state.userSettings[name],
+        selectProblemFilter: (state) => state.problemFilter,
+    },
+});
+export const { changeFilter } = settingsSlice.actions;
+export const { getSettingValue, selectProblemFilter } = settingsSlice.selectors;
 export const setSettingValue = (name, value) => {
     return (dispatch) => {
-        dispatch({ type: SET_SETTING_VALUE, data: { name, value } });
+        dispatch(settingsSlice.actions.setSettingValue({ name, value }));
         settingsManager.setUserSettingsValue(name, value);
     };
 };
-export const setUserSettings = (data) => {
-    return { type: SET_USER_SETTINGS, data };
-};
-export const getSettingValue = (state, name) => {
-    return state.settings.userSettings[name];
-};
-export const changeFilter = (filter) => {
-    return {
-        type: CHANGE_PROBLEM_FILTER,
-        data: filter,
-    };
-};
-export const selectProblemFilter = (state) => state.settings.problemFilter;
-export default settings;
+export function syncUserSettingsFromLS(store) {
+    if (typeof window === 'undefined') {
+        return;
+    }
+    window.addEventListener('storage', (event) => {
+        if (event.key && event.key in DEFAULT_USER_SETTINGS) {
+            const name = event.key;
+            let value = DEFAULT_USER_SETTINGS[name];
+            if (event.newValue !== null) {
+                value = parseJson(event.newValue);
+            }
+            store.dispatch(settingsSlice.actions.setSettingValue({
+                name,
+                value,
+            }));
+        }
+    });
+}
+export default settingsSlice.reducer;

package/dist/src/store/reducers/settings/types.d.ts

@@ -1,20 +1,9 @@
 import type { SettingsObject } from '../../../services/settings';
 import type { ValueOf } from '../../../types/common';
-import type { ProblemFilterValues, SET_SETTING_VALUE, changeFilter, setUserSettings } from './settings';
+import type { ProblemFilterValues } from './settings';
 export type ProblemFilterValue = ValueOf<typeof ProblemFilterValues>;
 export interface SettingsState {
     problemFilter: ProblemFilterValue;
     userSettings: SettingsObject;
     systemSettings: SettingsObject;
 }
-export type SetSettingValueAction = {
-    type: typeof SET_SETTING_VALUE;
-    data: {
-        name: string;
-        value: unknown;
-    };
-};
-export type SettingsAction = ReturnType<typeof changeFilter> | ReturnType<typeof setUserSettings> | SetSettingValueAction;
-export interface SettingsRootStateSlice {
-    settings: SettingsState;
-}