ydb-embedded-ui 22.2.0 → 22.4.0

package/src/types/api/schema/sysView.ts

@@ -2,43 +2,66 @@ import type {TPathID} from './shared';
 
 export interface TSysViewDescription {
     Name?: string;
-    Type?: ESysViewType;
+    /**
+     * ESysViewType: enum name ("EVSlots") on YDB <= 26.3.1.x,
+     * numeric value (13) since ydb-platform/ydb#54332
+     */
+    Type?: ESysViewType | number;
     SourceObject?: TPathID;
 }
 
-export type ESysViewType =
-    | 'EPartitionStats'
-    | 'ENodes'
-    | 'ETopQueriesByDurationOneMinute'
-    | 'ETopQueriesByDurationOneHour'
-    | 'ETopQueriesByReadBytesOneMinute'
-    | 'ETopQueriesByReadBytesOneHour'
-    | 'ETopQueriesByCpuTimeOneMinute'
-    | 'ETopQueriesByCpuTimeOneHour'
-    | 'ETopQueriesByRequestUnitsOneMinute'
-    | 'ETopQueriesByRequestUnitsOneHour'
-    | 'EQuerySessions'
-    | 'EPDisks'
-    | 'EVSlots'
-    | 'EGroups'
-    | 'EStoragePools'
-    | 'EStorageStats'
-    | 'ETablets'
-    | 'EQueryMetricsOneMinute'
-    | 'ETopPartitionsByCpuOneMinute'
-    | 'ETopPartitionsByCpuOneHour'
-    | 'ETopPartitionsByTliOneMinute'
-    | 'ETopPartitionsByTliOneHour'
-    | 'EResourcePoolClassifiers'
-    | 'EResourcePools'
-    | 'EAuthUsers'
-    | 'EAuthGroups'
-    | 'EAuthGroupMembers'
-    | 'EAuthOwners'
-    | 'EAuthPermissions'
-    | 'EAuthEffectivePermissions'
-    | 'EPgTables'
-    | 'EInformationSchemaTables'
-    | 'EPgClass'
-    | 'EShowCreate'
-    | 'ECompileCacheQueries';
+/**
+ * Numeric ESysViewType values
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/sys_view_types.proto
+ */
+export const SYS_VIEW_TYPE_IDS = {
+    EPartitionStats: 1,
+    ENodes: 2,
+    ETopQueriesByDurationOneMinute: 3,
+    ETopQueriesByDurationOneHour: 4,
+    ETopQueriesByReadBytesOneMinute: 5,
+    ETopQueriesByReadBytesOneHour: 6,
+    ETopQueriesByCpuTimeOneMinute: 7,
+    ETopQueriesByCpuTimeOneHour: 8,
+    ETopQueriesByRequestUnitsOneMinute: 9,
+    ETopQueriesByRequestUnitsOneHour: 10,
+    EQuerySessions: 11,
+    EPDisks: 12,
+    EVSlots: 13,
+    EGroups: 14,
+    EStoragePools: 15,
+    EStorageStats: 16,
+    ETablets: 17,
+    EQueryMetricsOneMinute: 18,
+    ETopPartitionsByCpuOneMinute: 19,
+    ETopPartitionsByCpuOneHour: 20,
+    ETopPartitionsByTliOneMinute: 21,
+    ETopPartitionsByTliOneHour: 22,
+    EResourcePoolClassifiers: 23,
+    EResourcePools: 24,
+    EAuthUsers: 25,
+    EAuthGroups: 26,
+    EAuthGroupMembers: 27,
+    EAuthOwners: 28,
+    EAuthPermissions: 29,
+    EAuthEffectivePermissions: 30,
+    EPgTables: 31,
+    EInformationSchemaTables: 32,
+    EPgClass: 33,
+    EShowCreate: 34,
+    ECompileCacheQueries: 35,
+    EStorePrimaryIndexStats: 36,
+    EStorePrimaryIndexSchemaStats: 37,
+    EStorePrimaryIndexPortionStats: 38,
+    EStorePrimaryIndexGranuleStats: 39,
+    EStorePrimaryIndexOptimizerStats: 40,
+    ETablePrimaryIndexStats: 41,
+    ETablePrimaryIndexSchemaStats: 42,
+    ETablePrimaryIndexPortionStats: 43,
+    ETablePrimaryIndexGranuleStats: 44,
+    ETablePrimaryIndexOptimizerStats: 45,
+    EStreamingQueries: 46,
+    EUdfModules: 47,
+} as const;
+
+export type ESysViewType = keyof typeof SYS_VIEW_TYPE_IDS;

package/src/types/api/schema/table.ts

@@ -66,6 +66,13 @@ interface TEnabled {
     ExpireAfterSeconds?: number;
     ColumnUnit?: EUnit;
     SysSettings?: TSysSettings;
+    Tiers?: TTTLTier[];
+}
+
+export interface TTTLTier {
+    ApplyAfterSeconds?: number;
+    Delete?: {};
+    EvictToExternalStorage?: {Storage?: string};
 }
 
 interface TSysSettings {

package/src/types/api/vdisk.ts

@@ -41,6 +41,8 @@ export interface TVDiskStateInfo {
     SatisfactionRank?: TVDiskSatisfactionRank;
     /** Is VDisk replicated? (i.e. contains all blobs it must have) */
     Replicated?: boolean;
+    /** Detailed Whiteboard replication status. May be absent on older nodes. */
+    DetailedReplicationStatus?: EVDiskDetailedReplicationStatus;
     /** Does this VDisk has any yet unreplicated phantom-like blobs? */
     UnreplicatedPhantoms?: boolean;
     /** The same for the non-phantom-like blobs. */
@@ -138,6 +140,13 @@ export enum EVDiskState {
     PDiskError = 'PDiskError',
 }
 
+export enum EVDiskDetailedReplicationStatus {
+    Replicated = 'Replicated',
+    WaitingForToken = 'WaitingForToken',
+    InProgress = 'InProgress',
+    PhantomsOnly = 'PhantomsOnly',
+}
+
 /**
  * BSC VDisk data
  *

package/src/types/store/nodesList.ts

@@ -1,7 +1,7 @@
-export type NodesMap = Map<
-    number,
-    {
-        Host?: string;
-        DC?: string;
-    }
->;
+export interface NodeMetadata {
+    Host?: string;
+    DC?: string;
+    Rack?: string;
+}
+
+export type NodesMap = Map<number, NodeMetadata>;

package/src/uiFactory/types.ts

@@ -7,7 +7,10 @@ import type {
     GetHealthcheckViewTitles,
     GetHealthcheckViewsOrder,
 } from '../containers/Tenant/Healthcheck/shared';
-import type {HealthcheckAssistantActionProps} from '../containers/Tenant/Healthcheck/types';
+import type {
+    HealthcheckAssistantActionProps,
+    HealthcheckAssistantTarget,
+} from '../containers/Tenant/Healthcheck/types';
 import type {ClusterInfo} from '../store/reducers/cluster/cluster';
 import type {PreparedStorageNode} from '../store/reducers/storage/types';
 import type {PreparedTenant} from '../store/reducers/tenants/types';
@@ -70,7 +73,7 @@ export interface UIFactory<H extends string = CommonIssueCategory, T extends str
          * Renders after the drawer header and before Healthcheck content.
          * Stays mounted while the drawer is open, independent of loading, error or issue state.
          */
-        renderDrawerExtension?: () => React.ReactNode;
+        renderDrawerExtension?: (props: HealthcheckDrawerExtensionProps) => React.ReactNode;
     };
     hasAccess: HasAccess;
     hideGrantAccess?: boolean;
@@ -211,6 +214,10 @@ export type RenderNodeTooltipActions = (props: {data?: PreparedStorageNode}) =>
 
 export type RenderChatPanel = () => React.ReactNode;
 
+export interface HealthcheckDrawerExtensionProps {
+    target?: HealthcheckAssistantTarget;
+}
+
 export type RenderHealthcheckAssistantAction = (
     props: HealthcheckAssistantActionProps,
 ) => React.ReactNode;

package/src/utils/bytesParsers/formatBytes.ts

@@ -1,6 +1,11 @@
 import {GIGABYTE, KILOBYTE, MEGABYTE, PETABYTE, TERABYTE, UNBREAKABLE_GAP} from '../constants';
 import type {FormatToSizeArgs, FormatValuesArgs} from '../dataFormatters/common';
-import {formatNumber, roundToPrecision} from '../dataFormatters/dataFormatters';
+import {
+    formatNumber,
+    roundToDecimalPlaces,
+    roundToPrecision,
+} from '../dataFormatters/dataFormatters';
+import {configuredNumeral} from '../numeral';
 import {isNumeric} from '../utils';
 
 import i18n from './i18n';
@@ -57,8 +62,22 @@ export const getBytesSizeUnit = (value: number) => {
     return size;
 };
 
-const formatToSize = ({value, size = 'mb', precision = 0}: FormatToSizeArgs<BytesSizes>) => {
-    const result = roundToPrecision(Number(value) / sizes[size].value, precision);
+const formatToSize = ({
+    value,
+    size = 'mb',
+    precision = 0,
+    fixedDecimalPlaces,
+}: FormatToSizeArgs<BytesSizes> & {fixedDecimalPlaces?: number}) => {
+    const convertedValue = Number(value) / sizes[size].value;
+    if (fixedDecimalPlaces !== undefined) {
+        const roundedValue = roundToDecimalPlaces(convertedValue, fixedDecimalPlaces);
+        const pattern =
+            roundedValue !== 0 && fixedDecimalPlaces > 0
+                ? `0,0.${'0'.repeat(fixedDecimalPlaces)}`
+                : '0,0';
+        return configuredNumeral(roundedValue).format(pattern);
+    }
+    const result = roundToPrecision(convertedValue, precision);
 
     return formatNumber(result);
 };
@@ -78,7 +97,7 @@ export const formatBytes = ({
     withSizeLabel = true,
     delimiter,
     ...params
-}: FormatValuesArgs<BytesSizes>) => {
+}: FormatValuesArgs<BytesSizes> & {fixedDecimalPlaces?: number}) => {
     if (!isNumeric(value)) {
         return '';
     }

package/src/utils/disks/constants.ts

@@ -142,6 +142,7 @@ export const PDISK_STATE_SEVERITY = {
 export interface LabelVisualConfig {
     theme: LabelProps['theme'];
     icon?: IconData;
+    dangerHeavy?: boolean;
 }
 
 export const NUMERIC_SEVERITY_TO_LABEL_VIEW: Record<number, LabelVisualConfig> = {
@@ -157,6 +158,10 @@ export const NUMERIC_SEVERITY_TO_LABEL_VIEW: Record<number, LabelVisualConfig> =
         theme: 'danger',
         icon: CircleExclamation,
     },
+    [SOLID_RED_SEVERITY]: {
+        theme: 'danger',
+        dangerHeavy: true,
+    },
     [DISK_COLOR_STATE_TO_NUMERIC_SEVERITY.Blue]: {
         theme: 'info',
         icon: ArrowsRotateLeft,

package/src/utils/disks/diskInfo/getDiskLocationItems.ts

@@ -0,0 +1,50 @@
+import {isNil} from 'lodash';
+
+import type {YDBDefinitionListItem} from '../../../components/YDBDefinitionList/YDBDefinitionList';
+import type {NodeMetadata} from '../../../types/store/nodesList';
+import {EMPTY_DATA_PLACEHOLDER} from '../../constants';
+
+import i18n from './i18n';
+
+export interface DiskDetailItem extends YDBDefinitionListItem {
+    /** Stable field identifier for ordering and grouping independently of translated names. */
+    id: string;
+}
+
+interface DiskLocationData {
+    NodeId?: number;
+    PDiskId?: number;
+    Path?: string;
+    VDiskSlotId?: number;
+}
+
+export function getDiskLocationItems(
+    data: DiskLocationData,
+    nodeData: NodeMetadata,
+    {withVDiskSlotId = false}: {withVDiskSlotId?: boolean} = {},
+): DiskDetailItem[] {
+    const entries = [
+        {id: 'fqdn', name: i18n('field_fqdn'), value: nodeData.Host},
+        {id: 'rack', name: i18n('field_rack'), value: nodeData.Rack},
+        {id: 'datacenter', name: i18n('field_datacenter'), value: nodeData.DC},
+        {id: 'pdisk-path', name: i18n('field_pdisk-path'), value: data.Path},
+        {id: 'node-id', name: i18n('field_node-id'), value: data.NodeId || undefined},
+        {id: 'pdisk-id', name: i18n('field_pdisk-id'), value: data.PDiskId},
+    ];
+    if (withVDiskSlotId) {
+        entries.push({
+            id: 'vdisk-slot-id',
+            name: i18n('field_vdisk-slot-id'),
+            value: data.VDiskSlotId,
+        });
+    }
+    return entries.map(({id, name, value}) => {
+        const missing = isNil(value) || value === '';
+        return {
+            id,
+            name,
+            content: missing ? EMPTY_DATA_PLACEHOLDER : value,
+            copyText: missing ? undefined : value,
+        };
+    });
+}

package/src/utils/disks/diskInfo/i18n/en.json

@@ -0,0 +1,9 @@
+{
+  "field_fqdn": "FQDN",
+  "field_rack": "Rack",
+  "field_datacenter": "Datacenter",
+  "field_pdisk-path": "PDisk Path",
+  "field_node-id": "Node ID",
+  "field_pdisk-id": "PDisk ID",
+  "field_vdisk-slot-id": "VDisk Slot ID"
+}

package/src/utils/disks/diskInfo/i18n/index.ts

@@ -0,0 +1,5 @@
+import {registerKeysets} from '../../../i18n';
+
+import en from './en.json';
+
+export default registerKeysets('ydb-disk-info', {en});

package/src/utils/disks/iconCalculators.ts

@@ -161,7 +161,7 @@ export function calculateFrontQueuesIcon(
  * Get icon and color for a single status flag.
  * Maps EFlag to the corresponding pair-legend icon and color.
  */
-function getFlagIconWithColor(flag: EFlag | undefined): IconWithColor | undefined {
+export function getFlagIconWithColor(flag: EFlag | undefined): IconWithColor | undefined {
     if (!flag || flag === EFlag.Grey) {
         return {
             icon: CircleQuestionFill,

package/src/utils/disks/prepareDisks.ts

@@ -1,6 +1,6 @@
 import {isNil} from 'lodash';
 
-import type {TPDiskStateInfo} from '../../types/api/pdisk';
+import type {TPDiskInfo, TPDiskStateInfo} from '../../types/api/pdisk';
 import type {TVDiskStateInfo, TVSlotId} from '../../types/api/vdisk';
 import {stringifyVdiskId} from '../dataFormatters/dataFormatters';
 import {isNumeric, parseOptionalNonNegativeNumber} from '../utils';
@@ -8,7 +8,7 @@ import {isNumeric, parseOptionalNonNegativeNumber} from '../utils';
 import {calculatePDiskSeverity} from './calculatePDiskSeverity';
 import {calculateVDiskSeverity} from './calculateVDiskSeverity';
 import {getPDiskType} from './getPDiskType';
-import {getPDiskId, isFullVDiskData} from './helpers';
+import {getPDiskId, isFullVDiskData, makeVDiskLocationKey} from './helpers';
 import type {PreparedPDisk, PreparedVDisk} from './types';
 
 export function prepareWhiteboardVDiskData(
@@ -21,16 +21,7 @@ export function prepareWhiteboardVDiskData(
     if (!isFullVDiskData(vDiskState)) {
         const {NodeId, PDiskId, VSlotId, ...restVDiskFields} = vDiskState;
 
-        const vDiskId =
-            !isNil(VSlotId) && !isNil(PDiskId) && !isNil(NodeId)
-                ? {
-                      NodeId,
-                      PDiskId,
-                      VSlotId,
-                  }
-                : undefined;
-
-        const StringifiedId = stringifyVdiskId(vDiskId);
+        const StringifiedId = makeVDiskLocationKey(NodeId, PDiskId, VSlotId) ?? '';
 
         return {
             ...restVDiskFields,
@@ -66,13 +57,7 @@ export function prepareWhiteboardVDiskData(
         AllocatedSize: AllocatedSize,
         SlotSize: PDisk?.EnforcedDynamicSlotSize,
     });
-    const WhiteboardSize = hasWhiteboardData
-        ? prepareWhiteboardVDiskSizeFields({
-              AvailableSize,
-              AllocatedSize,
-              SlotSize: PDisk?.EnforcedDynamicSlotSize,
-          })
-        : undefined;
+    const WhiteboardSize = hasWhiteboardData ? vDiskSizeFields.DisplaySize : undefined;
 
     const Severity = calculateVDiskSeverity(vDiskState);
 
@@ -124,7 +109,7 @@ export function prepareWhiteboardVDiskData(
 }
 
 export function prepareWhiteboardPDiskData(
-    pdiskState: TPDiskStateInfo = {},
+    pdiskState: TPDiskStateInfo & Pick<TPDiskInfo, 'StatusV2'> = {},
     whiteboardSizeSource: Pick<TPDiskStateInfo, 'AvailableSize' | 'TotalSize'> | null = pdiskState,
 ): PreparedPDisk {
     const hasWhiteboardData = pdiskState.HasWhiteboardData ?? Boolean(whiteboardSizeSource);
@@ -170,33 +155,7 @@ export function prepareWhiteboardPDiskData(
         State,
         Severity,
         SlotSize: EnforcedDynamicSlotSize,
-    };
-}
-
-function prepareWhiteboardVDiskSizeFields({
-    AvailableSize,
-    AllocatedSize,
-    SlotSize,
-}: {
-    AvailableSize: unknown;
-    AllocatedSize: unknown;
-    SlotSize: unknown;
-}) {
-    const allocatedSize = parseOptionalNonNegativeNumber(AllocatedSize);
-    const availableSize = parseOptionalNonNegativeNumber(AvailableSize);
-    const slotSize = parseOptionalNonNegativeNumber(SlotSize);
-    const preparedSizeFields = prepareVDiskSizeFields({
-        AvailableSize: availableSize,
-        AllocatedSize: allocatedSize,
-        SlotSize: slotSize,
-    });
-
-    return {
-        AllocatedSize: allocatedSize === undefined ? undefined : preparedSizeFields.AllocatedSize,
-        SizeLimit:
-            availableSize === undefined && slotSize === undefined
-                ? undefined
-                : preparedSizeFields.SizeLimit,
+        DriveStatus: pdiskState.Status ?? pdiskState.StatusV2,
     };
 }
 
@@ -253,12 +212,27 @@ export function prepareVDiskSizeFields({
     });
     const allocatedPercent = sizeLimit > 0 ? Math.floor((allocated * 100) / sizeLimit) : NaN;
 
+    // Preserve missing values for display without changing the legacy calculations above.
+    const displayAllocatedSize = parseOptionalNonNegativeNumber(AllocatedSize);
+    const displayAvailableSize = parseOptionalNonNegativeNumber(AvailableSize);
+    const displaySlotSize = parseOptionalNonNegativeNumber(SlotSize);
+    let displaySizeLimit: number | undefined;
+    if (!displayAvailableSize && displaySlotSize) {
+        displaySizeLimit = displaySlotSize;
+    } else if (displayAllocatedSize !== undefined && displayAvailableSize !== undefined) {
+        displaySizeLimit = displayAllocatedSize + displayAvailableSize;
+    }
+
     return {
         AvailableSize: available,
         AllocatedSize: allocated,
         SizeLimit: sizeLimit,
         FreeSize: freeSize,
         AllocatedPercent: allocatedPercent,
+        DisplaySize: {
+            AllocatedSize: displayAllocatedSize,
+            SizeLimit: displaySizeLimit,
+        },
     };
 }
 

package/src/utils/disks/types.ts

@@ -1,6 +1,6 @@
 import type {EFlag} from '../../types/api/enums';
 import type {EDriveStatus, TPDiskInfo, TPDiskStateInfo} from '../../types/api/pdisk';
-import type {EVDiskStatus, TVDiskStateInfo, TVSlotId} from '../../types/api/vdisk';
+import type {EVDiskStatus, TVDiskStateInfo} from '../../types/api/vdisk';
 import type {ValueOf} from '../../types/common';
 
 import type {PDISK_TYPES} from './getPDiskType';
@@ -98,6 +98,8 @@ export interface PreparedVDisk
     extends Omit<TVDiskStateInfo, 'PDisk' | 'AvailableSize' | 'AllocatedSize' | 'Donors'> {
     Status?: EVDiskStatus;
     PDisk?: PreparedPDisk;
+    PDiskType?: string;
+    PDiskPath?: string;
     Severity?: number;
     StringifiedId?: string;
 
@@ -106,6 +108,11 @@ export interface PreparedVDisk
     AllocatedPercent?: number;
     SizeLimit?: number;
     FreeSize?: number;
+    /** Size values for display, preserving missing source values independently. */
+    DisplaySize?: {
+        AllocatedSize?: number;
+        SizeLimit?: number;
+    };
     WhiteboardSize?: {
         AllocatedSize?: number;
         SizeLimit?: number;
@@ -118,7 +125,8 @@ export interface PreparedVDisk
 
 export type PDiskType = ValueOf<typeof PDISK_TYPES>;
 
-export interface UnavailableDonor extends TVSlotId {
+export interface UnavailableDonor
+    extends Pick<PreparedVDisk, 'NodeId' | 'PDiskId' | 'VDiskSlotId'> {
     DonorMode?: boolean;
     StoragePoolName?: string;
 }

package/src/utils/hooks/useNodeMetadata.ts

@@ -0,0 +1,21 @@
+import {isNil} from 'lodash';
+
+import {selectNodesMap} from '../../store/reducers/nodesList';
+import type {NodeMetadata} from '../../types/store/nodesList';
+import {useTypedSelector} from '../hooks';
+
+import {useDatabaseFromQuery} from './useDatabaseFromQuery';
+
+export function useNodeMetadata(
+    nodeId: number | undefined,
+    parentNodeData?: NodeMetadata,
+): NodeMetadata {
+    const database = useDatabaseFromQuery();
+    const nodesMap = useTypedSelector((state) => selectNodesMap(state, database));
+    const storedNodeData = isNil(nodeId) ? undefined : nodesMap?.get(nodeId);
+    return {
+        Host: parentNodeData?.Host || storedNodeData?.Host,
+        DC: parentNodeData?.DC || storedNodeData?.DC,
+        Rack: parentNodeData?.Rack || storedNodeData?.Rack,
+    };
+}

package/src/utils/nodes.ts

@@ -32,9 +32,14 @@ export const isUnavailableNode = <
 export const prepareNodesMap = (nodesList?: TNodeInfo[]) => {
     return nodesList?.reduce<NodesMap>((nodeHosts, node) => {
         if (valueIsDefined(node.Id)) {
+            const physicalLocation = node.PhysicalLocation;
+            // The legacy numeric Rack can be a hash of the actual rack name.
+            const Rack = physicalLocation?.Location?.match(/(?:^|\/)R=([^/]+)/)?.[1];
+
             nodeHosts.set(node.Id, {
                 Host: node.Host,
-                DC: node.PhysicalLocation?.DataCenterId,
+                DC: physicalLocation?.DataCenterId,
+                Rack,
             });
         }
         return nodeHosts;

package/src/utils/query.ts

@@ -253,6 +253,61 @@ export function isErrorResponse(data: unknown): data is ErrorResponse {
     return Boolean(data && typeof data === 'object' && 'issues' in data);
 }
 
+function hasIssueContent(data: ErrorResponse) {
+    return Boolean(data.error || data.issues?.length);
+}
+
+// The issues view walks this tree and renders these fields, so anything else would throw while drawing.
+function isIssueTree(value: unknown): boolean {
+    return (
+        Array.isArray(value) &&
+        value.every((issue) => {
+            if (!issue || typeof issue !== 'object' || Array.isArray(issue)) {
+                return false;
+            }
+            const {
+                message,
+                issue_code: issueCode,
+                issues,
+            } = issue as {
+                message?: unknown;
+                issue_code?: unknown;
+                issues?: unknown;
+            };
+            return (
+                (message === undefined || typeof message === 'string') &&
+                (issueCode === undefined || typeof issueCode === 'number') &&
+                (issues === undefined || issues === null || isIssueTree(issues))
+            );
+        })
+    );
+}
+
+function hasRenderableIssues(data: ErrorResponse) {
+    const message: unknown = data.error?.message;
+    return (
+        (message === undefined || typeof message === 'string') &&
+        (data.issues === undefined || data.issues === null || isIssueTree(data.issues))
+    );
+}
+
+export function parseIssuesData(raw: unknown): ErrorResponse | string | undefined {
+    if (typeof raw === 'string' && raw) {
+        try {
+            const parsed: unknown = JSON.parse(raw);
+            return isErrorResponse(parsed) && hasIssueContent(parsed) && hasRenderableIssues(parsed)
+                ? parsed
+                : undefined;
+        } catch {
+            return raw;
+        }
+    }
+    if (isErrorResponse(raw) && hasIssueContent(raw) && hasRenderableIssues(raw)) {
+        return raw;
+    }
+    return undefined;
+}
+
 // Although schema is set in request, if schema is not supported default schema for the version will be used
 // So we should additionally parse response
 export function parseQueryAPIResponse(

package/src/utils/schema.ts

@@ -1,14 +1,31 @@
 import type {ESysViewType} from '../types/api/schema/sysView';
+import {SYS_VIEW_TYPE_IDS} from '../types/api/schema/sysView';
 
-export function prepareSystemViewType(type?: ESysViewType) {
-    if (!type) {
+const SYS_VIEW_TYPE_NAMES_BY_ID = new Map<number, ESysViewType>(
+    (Object.keys(SYS_VIEW_TYPE_IDS) as ESysViewType[]).map(
+        (name) => [SYS_VIEW_TYPE_IDS[name], name] as const,
+    ),
+);
+
+/**
+ * Normalizes SysViewDescription.Type for display.
+ * YDB <= 26.3.1.x returns the enum name ("EVSlots"),
+ * YDB with ydb-platform/ydb#54332 returns the numeric value (13).
+ */
+export function prepareSystemViewType(type?: string | number | null): string | undefined {
+    if (type === undefined || type === null || type === '') {
         return undefined;
     }
+
+    // Ids unknown to this UI version are shown as-is instead of hiding the row
+    const name =
+        typeof type === 'number' ? (SYS_VIEW_TYPE_NAMES_BY_ID.get(type) ?? String(type)) : type;
+
     // System view type is enum, its format from backend is EType
     // We need to display only Type, remove redundant E
     // EStoragePools -> StoragePools, EStorageStats -> StorageStats
-    if (type.startsWith('E')) {
-        return type.slice(1);
+    if (name.startsWith('E')) {
+        return name.slice(1);
     }
-    return type;
+    return name;
 }