ydb-embedded-ui 6.4.0 → 6.6.0

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

@@ -0,0 +1,130 @@
+import type { Reducer } from '@reduxjs/toolkit';
+import type { IHostAction, IHostState } from '../../types/store/host';
+export declare const FETCH_HOST: {
+    readonly REQUEST: "host/FETCH_HOST_REQUEST";
+    readonly SUCCESS: "host/FETCH_HOST_SUCCESS";
+    readonly FAILURE: "host/FETCH_HOST_FAILURE";
+};
+declare const host: Reducer<IHostState, IHostAction>;
+export declare function getHostInfo(): (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: 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: import("./schemaAcl/types").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: 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: import("./schemaAcl/types").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 default host;

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

@@ -0,0 +1,173 @@
+import singleClusterMode from './singleClusterMode';
+export declare const rootReducer: {
+    api: import("redux").Reducer<import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api">, import("redux").UnknownAction>;
+    singleClusterMode: typeof singleClusterMode;
+    cluster: import("redux").Reducer<import("./cluster/types").ClusterState>;
+    tenant: import("redux").Reducer<import("./tenant/types").TenantState>;
+    tooltip: import("redux").Reducer<import("../../types/store/tooltip").ITooltipState, import("../../types/store/tooltip").ITooltipAction>;
+    tablets: import("redux").Reducer<import("../../types/store/tablets").TabletsState>;
+    schema: import("redux").Reducer<import("./schema/types").SchemaState, import("./schema/types").SchemaAction>;
+    host: import("redux").Reducer<import("../../types/store/host").IHostState, import("../../types/store/host").IHostAction>;
+    tenants: import("redux").Reducer<import("./tenants/types").TenantsState>;
+    partitions: import("redux").Reducer<import("./partitions/types").PartitionsState>;
+    executeQuery: import("redux").Reducer<import("../../types/store/executeQuery").ExecuteQueryState, import("../../types/store/executeQuery").ExecuteQueryAction>;
+    tabletsFilters: (state: {
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | undefined, action: any) => {
+        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("redux").Reducer<import("../../types/store/heatmap").IHeatmapState>;
+    settings: import("redux").Reducer<import("./settings/types").SettingsState, import("./settings/types").SettingsAction>;
+    schemaAcl: import("redux").Reducer<import("./schemaAcl/types").SchemaAclState, import("./schemaAcl/types").SchemaAclAction>;
+    executeTopQueries: import("redux").Reducer<import("./executeTopQueries/types").TopQueriesFilters>;
+    shardsWorkload: import("redux").Reducer<import("./shardsWorkload/types").ShardsWorkloadFilters>;
+    hotKeys: import("redux").Reducer<import("./hotKeys/types").HotKeysState, import("./hotKeys/types").HotKeysAction>;
+    authentication: import("redux").Reducer<import("./authentication/types").AuthenticationState, import("./authentication/types").AuthenticationAction>;
+    header: import("redux").Reducer<import("./header/types").HeaderState, {
+        readonly type: "header/SET_HEADER_BREADCRUMBS";
+        readonly page: import("./header/types").Page;
+        readonly options: {} | import("./header/types").TabletsBreadcrumbsOptions | import("./header/types").TenantBreadcrumbsOptions | import("./header/types").ClusterBreadcrumbsOptions | import("./header/types").TabletBreadcrumbsOptions | import("./header/types").NodeBreadcrumbsOptions;
+    }>;
+    saveQuery: import("redux").Reducer<string | null, {
+        readonly type: "SET_QUERY_NAME_TO_EDIT";
+        readonly data: string;
+    } | {
+        readonly type: "CLEAR_QUERY_NAME_TO_EDIT";
+    }>;
+    fullscreen: (state: boolean | undefined, action: {
+        readonly type: "ENABLE_FULLSCREEN_MODE";
+    } | {
+        readonly type: "DISABLE_FULLSCREEN_MODE";
+    }) => boolean;
+    clusters: import("redux").Reducer<import("./clusters/types").ClustersFilters>;
+};
+declare const combinedReducer: import("redux").Reducer<{
+    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: import("./schemaAcl/types").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;
+}, any, Partial<{
+    api: import("@reduxjs/toolkit/query").CombinedState<{}, "All", "api"> | undefined;
+    singleClusterMode: boolean | undefined;
+    cluster: import("./cluster/types").ClusterState | undefined;
+    tenant: import("./tenant/types").TenantState | undefined;
+    tooltip: never;
+    tablets: import("../../types/store/tablets").TabletsState | undefined;
+    schema: never;
+    host: never;
+    tenants: import("./tenants/types").TenantsState | undefined;
+    partitions: import("./partitions/types").PartitionsState | undefined;
+    executeQuery: never;
+    tabletsFilters: {
+        data: undefined;
+        loading: boolean;
+        wasLoaded: boolean;
+        stateFilter: never[];
+        typeFilter: never[];
+    } | undefined;
+    heatmap: import("../../types/store/heatmap").IHeatmapState | undefined;
+    settings: never;
+    schemaAcl: never;
+    executeTopQueries: import("./executeTopQueries/types").TopQueriesFilters | undefined;
+    shardsWorkload: import("./shardsWorkload/types").ShardsWorkloadFilters | undefined;
+    hotKeys: never;
+    authentication: never;
+    header: never;
+    saveQuery: never;
+    fullscreen: never;
+    clusters: import("./clusters/types").ClustersFilters | undefined;
+}>>;
+export default combinedReducer;

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

@@ -0,0 +1,51 @@
+import { combineReducers } from '@reduxjs/toolkit';
+import { api } from './api';
+import authentication from './authentication/authentication';
+import cluster from './cluster/cluster';
+import clusters from './clusters/clusters';
+import executeQuery from './executeQuery';
+import executeTopQueries from './executeTopQueries/executeTopQueries';
+import fullscreen from './fullscreen';
+import header from './header/header';
+import heatmap from './heatmap';
+import host from './host';
+import hotKeys from './hotKeys/hotKeys';
+import partitions from './partitions/partitions';
+import saveQuery from './saveQuery';
+import schema from './schema/schema';
+import schemaAcl from './schemaAcl/schemaAcl';
+import settings from './settings/settings';
+import shardsWorkload from './shardsWorkload/shardsWorkload';
+import singleClusterMode from './singleClusterMode';
+import tablets from './tablets';
+import tabletsFilters from './tabletsFilters';
+import tenant from './tenant/tenant';
+import tenants from './tenants/tenants';
+import tooltip from './tooltip';
+export const rootReducer = {
+    [api.reducerPath]: api.reducer,
+    singleClusterMode,
+    cluster,
+    tenant,
+    tooltip,
+    tablets,
+    schema,
+    host,
+    tenants,
+    partitions,
+    executeQuery,
+    tabletsFilters,
+    heatmap,
+    settings,
+    schemaAcl,
+    executeTopQueries,
+    shardsWorkload,
+    hotKeys,
+    authentication,
+    header,
+    saveQuery,
+    fullscreen,
+    clusters,
+};
+const combinedReducer = combineReducers(Object.assign({}, rootReducer));
+export default combinedReducer;

package/dist/src/store/reducers/node/selectors.d.ts

@@ -0,0 +1,83 @@
+import type { RootState } from '../../defaultStore';
+import type { PreparedNodeStructure } from './types';
+export declare const selectNodeStructure: ((state: {
+    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: import("../schemaAcl/types").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;
+}, nodeId: string) => PreparedNodeStructure) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: number, resultFuncArgs_1: import("../../../types/api/storage").TStorageInfo | undefined) => PreparedNodeStructure;
+    memoizedResultFunc: ((resultFuncArgs_0: number, resultFuncArgs_1: import("../../../types/api/storage").TStorageInfo | undefined) => PreparedNodeStructure) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => PreparedNodeStructure;
+    dependencies: [(_state: RootState, nodeId: string) => number, (state: RootState, nodeId: string) => import("../../../types/api/storage").TStorageInfo | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,85 @@
+import type { RootState } from '../defaultStore';
+export declare const nodesListApi: import("@reduxjs/toolkit/query").Api<import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, {
+    getNodesList: import("@reduxjs/toolkit/query").QueryDefinition<any, import("@reduxjs/toolkit/query").BaseQueryFn<void, typeof import("./api")._NEVER, unknown, {}>, "All", import("../../types/api/nodesList").TEvNodesInfo | undefined, "api">;
+}, "api", "All", typeof import("@reduxjs/toolkit/query").coreModuleName | typeof import("@reduxjs/toolkit/dist/query/react").reactHooksModuleName>;
+export declare const selectNodesMap: ((state: {
+    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: import("./schemaAcl/types").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;
+}) => import("../../types/store/nodesList").NodesMap | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: import("../../types/api/nodesList").TEvNodesInfo | undefined) => import("../../types/store/nodesList").NodesMap | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: import("../../types/api/nodesList").TEvNodesInfo | undefined) => import("../../types/store/nodesList").NodesMap | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("../../types/store/nodesList").NodesMap | undefined;
+    dependencies: [(state: RootState) => import("../../types/api/nodesList").TEvNodesInfo | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+    memoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,31 @@
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../utils/query';
+import { api } from './api';
+function createOlatStatsQuery(path) {
+    return `SELECT * FROM \`${path}/.sys/primary_index_stats\``;
+}
+const queryAction = 'execute-scan';
+export const olapApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        getOlapStats: build.query({
+            queryFn: async ({ path = '' } = {}, { signal }) => {
+                try {
+                    const response = await window.api.sendQuery({
+                        schema: 'modern',
+                        query: createOlatStatsQuery(path),
+                        database: path,
+                        action: queryAction,
+                    }, { signal });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    return { data: parseQueryAPIExecuteResponse(response) };
+                }
+                catch (error) {
+                    return { error: error || new Error('Unauthorized') };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});

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

@@ -0,0 +1,22 @@
+import { isQueryErrorResponse, parseQueryAPIExecuteResponse } from '../../utils/query';
+import { api } from './api';
+export const previewApi = api.injectEndpoints({
+    endpoints: (build) => ({
+        sendQuery: build.query({
+            queryFn: async ({ query, database, action }, { signal }) => {
+                try {
+                    const response = await window.api.sendQuery({ schema: 'modern', query, database, action }, { signal });
+                    if (isQueryErrorResponse(response)) {
+                        return { error: response };
+                    }
+                    return { data: parseQueryAPIExecuteResponse(response) };
+                }
+                catch (error) {
+                    return { error: error || new Error('Unauthorized') };
+                }
+            },
+            providesTags: ['All'],
+        }),
+    }),
+    overrideExisting: 'throw',
+});