ydb-embedded-ui 4.10.0 → 4.10.1

package/dist/containers/Tenant/ObjectSummary/ObjectSummary.tsx

@@ -48,10 +48,7 @@ import {
 } from '../utils/paneVisibilityToggleHelpers';
 import {setShowPreview} from '../../../store/reducers/schema/schema';
 import {setQueryTab, setTenantPage} from '../../../store/reducers/tenant/tenant';
-import {
-    TENANT_PAGES_IDS,
-    TENANT_QUERY_TABS_ID,
-} from '../../../store/reducers/tenant/constants';
+import {TENANT_PAGES_IDS, TENANT_QUERY_TABS_ID} from '../../../store/reducers/tenant/constants';
 
 import './ObjectSummary.scss';
 
@@ -246,9 +243,7 @@ function ObjectSummary(props: ObjectSummaryProps) {
     const renderTree = () => {
         return (
             <div className={b('tree-wrapper')}>
-                <div className={b('tree-header')}>
-                    <div className={b('tree-title')}>Navigation</div>
-                </div>
+                <div className={b('tree-header')}>Navigation</div>
                 <div className={b('tree')}>
                     {pathData && (
                         <SchemaTree

package/dist/containers/Tenant/Query/i18n/en.json

@@ -1,7 +1,7 @@
 {
   "controls.query-mode-selector_type": "Query type:",
 
-  "tabs.newQuery": "New query",
+  "tabs.newQuery": "Query",
   "tabs.history": "History",
   "tabs.saved": "Saved",
 

package/dist/containers/Tenant/Query/i18n/ru.json

@@ -1,7 +1,7 @@
 {
   "controls.query-mode-selector_type": "Тип запроса:",
 
-  "tabs.newQuery": "Новый запрос",
+  "tabs.newQuery": "Запрос",
   "tabs.history": "История",
   "tabs.saved": "Сохраненные",
 

package/dist/containers/Tenants/Tenants.scss

@@ -1,9 +1,6 @@
 @import '../../styles/mixins.scss';
 
 .tenants {
-    height: 100%;
-    @include flex-container();
-
     &__format-label {
         margin-right: 15px;
     }
@@ -28,16 +25,7 @@
         }
     }
 
-    &__controls {
-        @include controls();
-    }
-
-    &__table-wrapper {
-        overflow: auto;
-        flex-grow: 1;
-
-        @include freeze-nth-column(1);
-
+    &__table {
         @include table-styles;
     }
 

package/dist/containers/Tenants/Tenants.tsx

@@ -2,7 +2,7 @@ import cn from 'bem-cn-lite';
 import {useDispatch} from 'react-redux';
 
 import DataTable, {Column} from '@gravity-ui/react-data-table';
-import {Loader, Button} from '@gravity-ui/uikit';
+import {Button} from '@gravity-ui/uikit';
 
 import EntityStatus from '../../components/EntityStatus/EntityStatus';
 import {PoolsGraph} from '../../components/PoolsGraph/PoolsGraph';
@@ -10,6 +10,7 @@ import {TabletsStatistic} from '../../components/TabletsStatistic';
 import {ProblemFilter} from '../../components/ProblemFilter';
 import {Illustration} from '../../components/Illustration';
 import {Search} from '../../components/Search';
+import {TableWithControlsLayout} from '../../components/TableWithControlsLayout/TableWithControlsLayout';
 import {ResponseError} from '../../components/Errors/ResponseError';
 
 import type {AdditionalTenantsProps} from '../../types/additionalProps';
@@ -66,7 +67,7 @@ export const Tenants = ({additionalTenantsProps}: TenantsProps) => {
 
     const renderControls = () => {
         return (
-            <div className={b('controls')}>
+            <>
                 <Search
                     value={searchValue}
                     onChange={handleSearchChange}
@@ -74,7 +75,7 @@ export const Tenants = ({additionalTenantsProps}: TenantsProps) => {
                     className={b('search')}
                 />
                 <ProblemFilter value={problemFilter} onChange={handleProblemFilterChange} />
-            </div>
+            </>
         );
     };
 
@@ -236,34 +237,26 @@ export const Tenants = ({additionalTenantsProps}: TenantsProps) => {
         }
 
         return (
-            <div className={b('table-wrapper')}>
-                <DataTable
-                    theme="yandex-cloud"
-                    data={filteredTenants}
-                    columns={columns}
-                    settings={DEFAULT_TABLE_SETTINGS}
-                    emptyDataMessage="No such tenants"
-                />
-            </div>
+            <DataTable
+                theme="yandex-cloud"
+                data={filteredTenants}
+                columns={columns}
+                settings={DEFAULT_TABLE_SETTINGS}
+                emptyDataMessage="No such tenants"
+            />
         );
     };
 
-    if (loading && !wasLoaded) {
-        return (
-            <div className={'loader'}>
-                <Loader size="l" />
-            </div>
-        );
-    }
-
     if (error) {
         return <ResponseError error={error} />;
     }
 
     return (
-        <div className={b()}>
-            {renderControls()}
-            {renderTable()}
-        </div>
+        <TableWithControlsLayout>
+            <TableWithControlsLayout.Controls>{renderControls()}</TableWithControlsLayout.Controls>
+            <TableWithControlsLayout.Table loading={loading && !wasLoaded} className={b('table')}>
+                {renderTable()}
+            </TableWithControlsLayout.Table>
+        </TableWithControlsLayout>
     );
 };

package/dist/store/reducers/nodes/nodes.ts

@@ -1,25 +1,12 @@
 import type {Reducer} from 'redux';
-import {createSelector, Selector} from 'reselect';
-import {escapeRegExp} from 'lodash/fp';
 
 import '../../../services/api';
-import {HOUR_IN_SECONDS} from '../../../utils/constants';
-import {calcUptime, calcUptimeInSeconds} from '../../../utils';
 import {NodesUptimeFilterValues} from '../../../utils/nodes';
-import {EFlag} from '../../../types/api/enums';
 
-import type {ProblemFilterValue} from '../settings/types';
 import {createRequestActionTypes, createApiRequest} from '../../utils';
-import {ProblemFilterValues} from '../settings/settings';
 
-import type {
-    NodesAction,
-    NodesApiRequestParams,
-    NodesHandledResponse,
-    NodesPreparedEntity,
-    NodesStateSlice,
-    NodesState,
-} from './types';
+import type {NodesAction, NodesApiRequestParams, NodesState} from './types';
+import {prepareComputeNodesData, prepareNodesData} from './utils';
 
 export const FETCH_NODES = createRequestActionTypes('nodes', 'FETCH_NODES');
 
@@ -97,24 +84,7 @@ export function getNodes({tenant, visibleEntities, type = 'any'}: NodesApiReques
     return createApiRequest({
         request: window.api.getNodes({tenant, visibleEntities, type}),
         actions: FETCH_NODES,
-        dataHandler: (data): NodesHandledResponse => {
-            const rawNodes = data.Nodes || [];
-
-            const preparedNodes = rawNodes.map((node) => {
-                return {
-                    ...node?.SystemState,
-                    Tablets: node?.Tablets,
-                    NodeId: node?.NodeId,
-                    Uptime: calcUptime(node?.SystemState?.StartTime),
-                    TenantName: node?.SystemState?.Tenants?.[0],
-                };
-            });
-
-            return {
-                Nodes: preparedNodes,
-                TotalNodes: Number(data.TotalNodes) || preparedNodes.length,
-            };
-        },
+        dataHandler: prepareNodesData,
     });
 }
 
@@ -122,31 +92,7 @@ export function getComputeNodes(path: string) {
     return createApiRequest({
         request: window.api.getCompute(path),
         actions: FETCH_NODES,
-        dataHandler: (data): NodesHandledResponse => {
-            const preparedNodes: NodesPreparedEntity[] = [];
-
-            if (data.Tenants) {
-                for (const tenant of data.Tenants) {
-                    if (tenant && tenant.Nodes) {
-                        const tenantNodes = tenant.Nodes.map((node) => {
-                            return {
-                                ...node,
-                                TenantName: tenant.Name,
-                                SystemState: node?.Overall,
-                                Uptime: calcUptime(node?.StartTime),
-                            };
-                        });
-
-                        preparedNodes.push(...tenantNodes);
-                    }
-                }
-            }
-
-            return {
-                Nodes: preparedNodes,
-                TotalNodes: preparedNodes.length,
-            };
-        },
+        dataHandler: prepareComputeNodesData,
     });
 }
 
@@ -175,58 +121,4 @@ export const setSearchValue = (value: string) => {
     } as const;
 };
 
-const getNodesUptimeFilter = (state: NodesStateSlice) => state.nodes.nodesUptimeFilter;
-const getSearchValue = (state: NodesStateSlice) => state.nodes.searchValue;
-const getNodesList = (state: NodesStateSlice) => state.nodes.data;
-
-const filterNodesByProblemsStatus = (
-    nodesList: NodesPreparedEntity[] = [],
-    problemFilter: ProblemFilterValue,
-) => {
-    if (problemFilter === ProblemFilterValues.ALL) {
-        return nodesList;
-    }
-
-    return nodesList.filter(({SystemState}) => {
-        return SystemState && SystemState !== EFlag.Green;
-    });
-};
-
-export const filterNodesByUptime = <T extends {StartTime?: string}>(
-    nodesList: T[] = [],
-    nodesUptimeFilter: NodesUptimeFilterValues,
-) => {
-    if (nodesUptimeFilter === NodesUptimeFilterValues.All) {
-        return nodesList;
-    }
-    return nodesList.filter(({StartTime}) => {
-        return !StartTime || calcUptimeInSeconds(StartTime) < HOUR_IN_SECONDS;
-    });
-};
-
-const filterNodesBySearchValue = (nodesList: NodesPreparedEntity[] = [], searchValue: string) => {
-    if (!searchValue) {
-        return nodesList;
-    }
-    const re = new RegExp(escapeRegExp(searchValue), 'i');
-
-    return nodesList.filter((node) => {
-        return node.Host ? re.test(node.Host) || re.test(String(node.NodeId)) : true;
-    });
-};
-
-export const getFilteredPreparedNodesList: Selector<
-    NodesStateSlice,
-    NodesPreparedEntity[] | undefined
-> = createSelector(
-    [getNodesList, getNodesUptimeFilter, getSearchValue, (state) => state.settings.problemFilter],
-    (nodesList, uptimeFilter, searchValue, problemFilter) => {
-        let result = filterNodesByUptime(nodesList, uptimeFilter);
-        result = filterNodesByProblemsStatus(result, problemFilter);
-        result = filterNodesBySearchValue(result, searchValue);
-
-        return result;
-    },
-);
-
 export default nodes;

package/dist/store/reducers/nodes/selectors.ts

@@ -0,0 +1,74 @@
+import {Selector, createSelector} from 'reselect';
+import {escapeRegExp} from 'lodash';
+
+import {EFlag} from '../../../types/api/enums';
+import {calcUptimeInSeconds} from '../../../utils';
+import {HOUR_IN_SECONDS} from '../../../utils/constants';
+import {NodesUptimeFilterValues} from '../../../utils/nodes';
+
+import type {ProblemFilterValue} from '../settings/types';
+import type {NodesPreparedEntity, NodesStateSlice} from './types';
+import {ProblemFilterValues} from '../settings/settings';
+
+// ==== Filters ====
+
+const filterNodesByProblemsStatus = (
+    nodesList: NodesPreparedEntity[] = [],
+    problemFilter: ProblemFilterValue,
+) => {
+    if (problemFilter === ProblemFilterValues.ALL) {
+        return nodesList;
+    }
+
+    return nodesList.filter(({SystemState}) => {
+        return SystemState && SystemState !== EFlag.Green;
+    });
+};
+
+export const filterNodesByUptime = <T extends {StartTime?: string}>(
+    nodesList: T[] = [],
+    nodesUptimeFilter: NodesUptimeFilterValues,
+) => {
+    if (nodesUptimeFilter === NodesUptimeFilterValues.All) {
+        return nodesList;
+    }
+    return nodesList.filter(({StartTime}) => {
+        return !StartTime || calcUptimeInSeconds(StartTime) < HOUR_IN_SECONDS;
+    });
+};
+
+const filterNodesBySearchValue = (nodesList: NodesPreparedEntity[] = [], searchValue: string) => {
+    if (!searchValue) {
+        return nodesList;
+    }
+    const re = new RegExp(escapeRegExp(searchValue), 'i');
+
+    return nodesList.filter((node) => {
+        return node.Host ? re.test(node.Host) || re.test(String(node.NodeId)) : true;
+    });
+};
+
+// ==== Simple selectors ====
+
+const selectNodesUptimeFilter = (state: NodesStateSlice) => state.nodes.nodesUptimeFilter;
+const selectSearchValue = (state: NodesStateSlice) => state.nodes.searchValue;
+const selectNodesList = (state: NodesStateSlice) => state.nodes.data;
+
+// ==== Complex selectors ====
+
+export const selectFilteredNodes: Selector<NodesStateSlice, NodesPreparedEntity[] | undefined> =
+    createSelector(
+        [
+            selectNodesList,
+            selectNodesUptimeFilter,
+            selectSearchValue,
+            (state) => state.settings.problemFilter,
+        ],
+        (nodesList, uptimeFilter, searchValue, problemFilter) => {
+            let result = filterNodesByUptime(nodesList, uptimeFilter);
+            result = filterNodesByProblemsStatus(result, problemFilter);
+            result = filterNodesBySearchValue(result, searchValue);
+
+            return result;
+        },
+    );

package/dist/store/reducers/nodes/utils.ts

@@ -0,0 +1,46 @@
+import type {TComputeInfo} from '../../../types/api/compute';
+import type {TNodesInfo} from '../../../types/api/nodes';
+import {calcUptime} from '../../../utils';
+
+import type {NodesHandledResponse, NodesPreparedEntity} from './types';
+
+export const prepareComputeNodesData = (data: TComputeInfo): NodesHandledResponse => {
+    const preparedNodes: NodesPreparedEntity[] = [];
+
+    if (data.Tenants) {
+        for (const tenant of data.Tenants) {
+            tenant.Nodes?.forEach((node) => {
+                preparedNodes.push({
+                    ...node,
+                    TenantName: tenant.Name,
+                    SystemState: node?.Overall,
+                    Uptime: calcUptime(node?.StartTime),
+                });
+            });
+        }
+    }
+
+    return {
+        Nodes: preparedNodes,
+        TotalNodes: preparedNodes.length,
+    };
+};
+
+export const prepareNodesData = (data: TNodesInfo): NodesHandledResponse => {
+    const rawNodes = data.Nodes || [];
+
+    const preparedNodes = rawNodes.map((node) => {
+        return {
+            ...node.SystemState,
+            Tablets: node.Tablets,
+            NodeId: node.NodeId,
+            Uptime: calcUptime(node.SystemState?.StartTime),
+            TenantName: node.SystemState?.Tenants?.[0],
+        };
+    });
+
+    return {
+        Nodes: preparedNodes,
+        TotalNodes: Number(data.TotalNodes) ?? preparedNodes.length,
+    };
+};

package/dist/store/reducers/storage/selectors.ts

@@ -15,7 +15,7 @@ import type {
     StorageStateSlice,
     UsageFilter,
 } from './types';
-import {filterNodesByUptime} from '../nodes/nodes';
+import {filterNodesByUptime} from '../nodes/selectors';
 
 // ==== Prepare data ====
 const FLAGS_POINTS = {

package/dist/types/api/compute.ts

@@ -4,13 +4,20 @@ import {TMetrics} from './tenant';
 
 /**
  * endpoint: viewer/json/compute
- * 
+ *
  * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ *
+ * response has 2 versions, depending on version param in request
  */
 export interface TComputeInfo {
     Overall: EFlag;
-    Tenants?: TComputeTenantInfo[];
+    Tenants?: TComputeTenantInfo[]; // v1
     Errors?: string[];
+    /** uint64 */
+    TotalNodes: string;
+    /** uint64 */
+    FoundNodes: string;
+    Nodes?: TComputeNodeInfo[]; // v2
 }
 
 interface TComputeTenantInfo {
@@ -43,6 +50,7 @@ export interface TComputeNodeInfo {
     MemoryLimit?: string;
     Metrics: TMetrics;
     Tablets?: TTabletStateInfo[];
+    Tenant?: string; // For v2 response without grouping by tenants
 }
 
 // Tablets in compute nodes
@@ -52,3 +60,20 @@ export interface TTabletStateInfo {
     State: EFlag;
     Count: number;
 }
+
+export enum EVersion {
+    v1,
+    v2, // only this versions works with sorting
+}
+
+export enum ESort {
+    NodeId,
+    Host,
+    DC,
+    Rack,
+    Version,
+    Uptime,
+    Memory,
+    CPU,
+    LoadAverage,
+}

package/dist/types/api/nodes.ts

@@ -5,7 +5,7 @@ import {TVDiskStateInfo} from './vdisk';
 
 /**
  * endpoint: /viewer/json/nodes
- * 
+ *
  * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
  */
 export interface TNodesInfo {
@@ -101,3 +101,14 @@ enum EConfigState {
     'Consistent' = 'Consistent',
     'Outdated' = 'Outdated',
 }
+
+export enum ESort {
+    NodeId,
+    Host,
+    DC,
+    Version,
+    Uptime,
+    Memory,
+    CPU,
+    LoadAverage,
+}

package/dist/types/api/schema/cdcStream.ts

@@ -0,0 +1,32 @@
+import type {TPathID} from './shared';
+
+export interface TCdcStreamDescription {
+    Name?: string;
+    Mode?: ECdcStreamMode;
+    Format?: ECdcStreamFormat;
+    PathId?: TPathID;
+    State?: ECdcStreamState;
+    /** uint64 */
+    SchemaVersion?: string;
+}
+
+enum ECdcStreamMode {
+    ECdcStreamModeInvalid = 'ECdcStreamModeInvalid',
+    ECdcStreamModeKeysOnly = 'ECdcStreamModeKeysOnly',
+    ECdcStreamModeUpdate = 'ECdcStreamModeUpdate',
+    ECdcStreamModeNewImage = 'ECdcStreamModeNewImage',
+    ECdcStreamModeOldImage = 'ECdcStreamModeOldImage',
+    ECdcStreamModeNewAndOldImages = 'ECdcStreamModeNewAndOldImages',
+}
+
+enum ECdcStreamFormat {
+    ECdcStreamFormatInvalid = 'ECdcStreamFormatInvalid',
+    ECdcStreamFormatProto = 'ECdcStreamFormatProto',
+    ECdcStreamFormatJson = 'ECdcStreamFormatJson',
+}
+
+enum ECdcStreamState {
+    ECdcStreamStateInvalid = 'ECdcStreamStateInvalid',
+    ECdcStreamStateReady = 'ECdcStreamStateReady',
+    ECdcStreamStateDisabled = 'ECdcStreamStateDisabled',
+}

package/dist/types/api/schema/columnEntity.ts

@@ -0,0 +1,138 @@
+import type {EColumnCodec, EUnit, TPathID, TStorageSettings, TTypeInfo} from './shared';
+
+export interface TColumnTableDescription {
+    Name?: string;
+
+    Schema?: TColumnTableSchema;
+    TtlSettings?: TColumnDataLifeCycle;
+
+    SchemaPresetId?: number;
+    SchemaPresetName?: string;
+
+    ColumnStorePathId?: TPathID;
+
+    ColumnShardCount?: number;
+    Sharding?: TColumnTableSharding;
+
+    /** uint64 */
+    SchemaPresetVersionAdj?: string;
+    /** uint64 */
+    TtlSettingsPresetVersionAdj?: string;
+
+    StorageConfig?: TColumnStorageConfig;
+}
+
+export interface TColumnStoreDescription {
+    Name?: string;
+    ColumnShardCount?: number;
+
+    /** uint64 */
+    ColumnShards?: string[];
+
+    SchemaPresets?: TColumnTableSchemaPreset[];
+    StorageConfig?: TColumnStorageConfig;
+
+    NextSchemaPresetId?: number;
+    NextTtlSettingsPresetId?: number;
+}
+
+export interface TColumnDataLifeCycle {
+    Enabled?: TTtl;
+    Disabled?: {};
+    Tiering?: TStorageTiering;
+
+    /** uint64 */
+    Version?: string;
+}
+
+interface TColumnStorageConfig {
+    SysLog?: TStorageSettings;
+    Log?: TStorageSettings;
+    Data?: TStorageSettings;
+    DataChannelCount?: number;
+}
+
+interface TStorageTiering {
+    Tiers?: TStorageTier[];
+}
+
+interface TStorageTier {
+    Name?: string;
+    Eviction?: TTtl;
+}
+
+interface TTtl {
+    ColumnName?: string;
+
+    ExpireAfterSeconds?: number;
+
+    /** uint64 */
+    ExpireAfterBytes?: string;
+
+    ColumnUnit?: EUnit;
+}
+
+interface TColumnTableSchema {
+    Columns?: TOlapColumnDescription[];
+    KeyColumnNames?: string[];
+    Engine?: EColumnTableEngine;
+    NextColumnId?: number;
+
+    /** uint64 */
+    Version?: string;
+
+    DefaultCompression?: TCompressionOptions;
+    EnableTiering?: boolean;
+}
+
+interface TColumnTableSchemaPreset {
+    Id?: number;
+    Name?: string;
+    Schema?: TColumnTableSchema;
+}
+
+interface TOlapColumnDescription {
+    Id?: number;
+    Name?: string;
+    Type?: string;
+    TypeId?: number;
+    TypeInfo?: TTypeInfo;
+}
+
+interface TColumnTableSharding {
+    /** uint64 */
+    Version?: string;
+
+    /** uint64 */
+    ColumnShards?: string[];
+
+    /** uint64 */
+    AdditionalColumnShards?: string[];
+
+    UniquePrimaryKey?: boolean;
+
+    RandomSharding?: {};
+    HashSharding?: THashSharding;
+}
+
+interface THashSharding {
+    Function?: EHashFunction;
+    Columns?: string[];
+    UniqueShardKey?: boolean;
+    ActiveShardsCount?: number;
+}
+
+interface TCompressionOptions {
+    CompressionCodec?: EColumnCodec;
+    CompressionLevel?: number;
+}
+
+enum EHashFunction {
+    HASH_FUNCTION_MODULO_N = 'HASH_FUNCTION_MODULO_N',
+    HASH_FUNCTION_CLOUD_LOGS = 'HASH_FUNCTION_CLOUD_LOGS',
+}
+
+enum EColumnTableEngine {
+    COLUMN_ENGINE_NONE = 'COLUMN_ENGINE_NONE',
+    COLUMN_ENGINE_REPLACING_TIMESERIES = 'COLUMN_ENGINE_REPLACING_TIMESERIES',
+}