ydb-embedded-ui 20.2.1 → 20.3.0

package/src/types/api/topic.ts

@@ -0,0 +1,362 @@
+import type {IProtobufTimeObject} from './common';
+import type {
+    Consumer,
+    Entry,
+    MultipleWindowsStat,
+    PartitionStats,
+    SupportedCodecs,
+} from './consumer';
+
+/**
+ * endpoint: /json/describe_topic
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/public/api/protos/ydb_topic.proto
+ *
+ * Original proto file doesn't specify optional fields, so every field is considered optional
+ */
+export interface DescribeTopicResult {
+    /** Description of scheme object. */
+    self?: Entry;
+
+    /** Settings for partitioning */
+    partitioning_settings?: PartitioningSettings;
+
+    /** Partitions description. */
+    partitions?: PartitionInfo[];
+
+    // Retention settings.
+    // Currently, only one limit may be set, so other should not be set.
+
+    /**
+     * google.protobuf.Duration
+     *
+     * How long data in partition should be stored.
+     */
+    retention_period?: string | IProtobufTimeObject;
+
+    /**
+     * int64
+     *
+     * How much data in partition should be stored.
+     * Zero value means infinite limit.
+     */
+    retention_storage_mb?: string;
+
+    /**
+     * List of allowed codecs for writers.
+     * Writes with codec not from this list are forbidden.
+     */
+    supported_codecs?: SupportedCodecs;
+
+    /**
+     * int64
+     *
+     * Partition write speed in bytes per second.
+     * Zero value means default limit: 1 MB per second.
+     */
+    partition_write_speed_bytes_per_second?: string;
+
+    /**
+     * int64
+     *
+     * Burst size for write in partition, in bytes.
+     * Zero value means default limit: 1 MB.
+     */
+    partition_write_burst_bytes?: string;
+
+    /** User and server attributes of topic. Server attributes starts from "_" and will be validated by server. */
+    attributes?: Record<string, string>;
+
+    /** List of consumers for this topic. */
+    consumers?: Consumer[];
+
+    /** Metering settings. */
+    metering_mode?: MeteringMode;
+
+    /** Statistics of topic. */
+    topic_stats?: TopicStats;
+}
+
+/** Partition info types differs for consumer and topic, although they are very similar */
+export interface PartitionInfo {
+    /** int64  */
+    partition_id?: string;
+
+    /** Is partition open for write. */
+    active?: boolean;
+
+    /**
+     * int64
+     *
+     * Ids of partitions which was formed when this partition was split or merged.
+     */
+    child_partition_ids?: string;
+
+    /**
+     * int64
+     *
+     * Ids of partitions from which this partition was formed by split or merge.
+     */
+    parent_partition_ids?: string;
+
+    /** Stats for partition, filled only when include_stats in request is true. */
+    partition_stats?: PartitionStats;
+}
+
+export interface TopicStats {
+    /**
+     * int64
+     *
+     * Approximate size of topic.
+     */
+    store_size_bytes?: string;
+
+    /**
+     * google.protobuf.Timestamp
+     *
+     * Minimum of timestamps of last write among all partitions.
+     */
+    min_last_write_time?: string | IProtobufTimeObject;
+
+    /**
+     * google.protobuf.Duration
+     *
+     * Maximum of differences between write timestamp and create timestamp for all messages, written during last minute.
+     */
+    max_write_time_lag?: string | IProtobufTimeObject;
+
+    /** How much bytes were written statistics. */
+    bytes_written?: MultipleWindowsStat;
+}
+
+/** Partitioning settings for topic. */
+interface PartitioningSettings {
+    /**
+     * int64
+     *
+     * Minimum partition count auto merge would stop working at.
+     *
+     * Zero value means default - 1.
+     */
+    min_active_partitions?: string;
+
+    max_active_partitions?: string;
+
+    /**
+     * int64
+     *
+     * Limit for total partition count, including active (open for write) and read-only partitions.
+     *
+     * Zero value means default - 100.
+     */
+    partition_count_limit?: string;
+
+    auto_partitioning_settings?: AutoPartitioningSettings;
+}
+
+interface AutoPartitioningSettings {
+    strategy?: AutoPartitioningStrategy;
+    partition_write_speed?: AutoPartitioningWriteSpeedStrategy;
+}
+
+interface AutoPartitioningWriteSpeedStrategy {
+    stabilization_window?: string | IProtobufTimeObject;
+    up_utilization_percent?: number;
+    down_utilization_percent?: number;
+}
+
+enum AutoPartitioningStrategy {
+    AUTO_PARTITIONING_STRATEGY_UNSPECIFIED = 'AUTO_PARTITIONING_STRATEGY_UNSPECIFIED',
+    AUTO_PARTITIONING_STRATEGY_DISABLED = 'AUTO_PARTITIONING_STRATEGY_DISABLED',
+    AUTO_PARTITIONING_STRATEGY_SCALE_UP = 'AUTO_PARTITIONING_STRATEGY_SCALE_UP',
+    AUTO_PARTITIONING_STRATEGY_SCALE_UP_AND_DOWN = 'AUTO_PARTITIONING_STRATEGY_SCALE_UP_AND_DOWN',
+    AUTO_PARTITIONING_STRATEGY_PAUSED = 'AUTO_PARTITIONING_STRATEGY_PAUSED',
+}
+
+enum MeteringMode {
+    /** Use default */
+    METERING_MODE_UNSPECIFIED = 'METERING_MODE_UNSPECIFIED',
+
+    /** Metering based on resource reservation */
+    METERING_MODE_RESERVED_CAPACITY = 'METERING_MODE_RESERVED_CAPACITY',
+
+    /** Metering based on actual consumption. Default. */
+    METERING_MODE_REQUEST_UNITS = 'METERING_MODE_REQUEST_UNITS',
+}
+
+export interface TopicDataRequest {
+    /** path of topic */
+    path: string;
+    /** database name */
+    database?: string;
+    /** partition to read from */
+    partition: string;
+    /** start offset to read from */
+    offset?: number;
+    /** last offset that can possibly be read */
+    last_offset?: number;
+    /** min message timestamp to read from */
+    read_timestamp?: number;
+    /** max number of messages to read (default = 10) */
+    limit?: number;
+    /** timeout in ms */
+    timeout?: number;
+    /** max size of single message (default = 1_000_000 (1 MB)) */
+    message_size_limit?: number;
+}
+
+export interface TopicDataResponse {
+    /**
+     * uint64
+     *
+     * Start offset of the returned data range
+     */
+    StartOffset?: string;
+
+    /**
+     * uint64
+     *
+     * End offset of the returned data range
+     */
+    EndOffset?: string;
+
+    /**
+     * Array of messages
+     */
+    Messages?: TopicMessage[];
+
+    /**
+     * Whether the response was truncated due to size limits
+     */
+    Truncated?: boolean;
+
+    /**
+     * Error produced while trying to schematize the response messages
+     */
+    SchematizeError?: string;
+
+    /**
+     * Proto message name used to schematize the response messages
+     */
+    ProtoMessageName?: string;
+
+    /**
+     * Proto sequence number used to schematize the response messages
+     */
+    Protoseq?: string | number;
+
+    /**
+     * Schema path used to schematize the response messages
+     */
+    SchemaPath?: string;
+}
+
+export interface TopicMessage {
+    /**
+     * uint64
+     *
+     * Message offset in the partition
+     */
+    Offset?: string | number;
+
+    /**
+     * uint64
+     *
+     * Timestamp when the message was created
+     */
+    CreateTimestamp?: string;
+
+    /**
+     * uint64
+     *
+     * Timestamp when the message was written
+     */
+    WriteTimestamp?: string;
+
+    /**
+     * uint64
+     *
+     * Difference between write and create timestamps
+     */
+    TimestampDiff?: string;
+
+    /**
+     * Message content.
+     *
+     * Usually a base64-encoded string. When the topic has an associated schema,
+     * the new handler returns the message already schematized as a JSON value
+     * (object/array/primitive), so consumers must narrow before using
+     * string-only APIs like `atob`.
+     */
+    Message?: string | unknown;
+
+    /**
+     * Error produced while trying to schematize this message
+     */
+    SchematizeError?: string;
+
+    /**
+     * uint32
+     *
+     * Size of the message in storage
+     */
+    StorageSize?: number;
+
+    /**
+     * uint32
+     *
+     * Original size of the message before compression
+     */
+    OriginalSize?: number;
+
+    /**
+     * uint32
+     *
+     * Codec used for message compression
+     */
+    Codec?: number;
+
+    /**
+     * ID of the producer that created the message
+     */
+    ProducerId?: string;
+
+    /**
+     * uint64
+     *
+     * Sequence number
+     */
+    SeqNo?: string;
+
+    Ip?: string;
+
+    /**
+     * Message metadata
+     */
+    MessageMetadata?: TopicMessageMetadataItem[];
+}
+
+export interface TopicMessageEnhanced extends TopicMessage {
+    removed?: boolean;
+    notLoaded?: boolean;
+    /**
+     * Whether the message value is already schematized (a parsed JSON value,
+     * including string primitives) and therefore must NOT be base64-decoded.
+     * Derived from the response schema context (`SchemaPath` present and no
+     * `SchematizeError`), since a raw string value alone is ambiguous between a
+     * schematized primitive and a legacy base64 payload.
+     */
+    isSchematized?: boolean;
+}
+
+export interface TopicMessageMetadataItem {
+    /**
+     * Metadata key
+     */
+    Key?: string;
+
+    /**
+     * Metadata value
+     */
+    Value?: string;
+}

package/src/types/api/vdisk.ts

@@ -0,0 +1,170 @@
+import type {ECapacityAlert, EFlag} from './enums';
+import type {TPDiskStateInfo} from './pdisk';
+/**
+ * Node whiteboard VDisk data
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/node_whiteboard.proto
+ */
+export interface TVDiskStateInfo {
+    VDiskId?: TVDiskID;
+    /** uint64 */
+    CreateTime?: string;
+    /** uint64 */
+    ChangeTime?: string;
+    PDiskId?: number;
+    PDisk?: TPDiskStateInfo;
+    VDiskSlotId?: number;
+    /** uint32; VDisk slot weight in allocation units. */
+    GroupSizeInUnits?: number;
+    /** float; percent in the 0..100 scale. */
+    VDiskSlotUsage?: number;
+    /** float; percent in the 0..100 scale. */
+    VDiskRawUsage?: number;
+    /** float; backend normalized occupancy value. */
+    NormalizedOccupancy?: number;
+    /** uint64 */
+    Guid?: string;
+    /** uint64 */
+    Kind?: string;
+    NodeId?: number;
+    Count?: number;
+
+    Overall?: EFlag;
+
+    /** Current state of VDisk */
+    VDiskState?: EVDiskState;
+    /** Disk space flags */
+    DiskSpace?: EFlag;
+    /** Compaction satisfaction rank */
+    SatisfactionRank?: TVDiskSatisfactionRank;
+    /** Is VDisk replicated? (i.e. contains all blobs it must have) */
+    Replicated?: boolean;
+    /** Does this VDisk has any yet unreplicated phantom-like blobs? */
+    UnreplicatedPhantoms?: boolean;
+    /** The same for the non-phantom-like blobs. */
+    UnreplicatedNonPhantoms?: boolean;
+    /** Replication progress (0 to 1) */
+    ReplicationProgress?: number;
+    ReplicationSecondsRemaining?: number;
+    /**
+     * uint64
+     * How many unsynced VDisks from current BlobStorage group we see
+     */
+    UnsyncedVDisks?: string;
+    /**
+     * uint64
+     * How much this VDisk have allocated on corresponding PDisk
+     */
+    AllocatedSize?: string;
+    /**
+     * uint64
+     * How much space is available for VDisk corresponding to PDisk's hard space limits
+     */
+    AvailableSize?: string;
+    /** Does this disk has some unreadable but not yet restored blobs? */
+    HasUnreadableBlobs?: boolean;
+    /** fixed64 */
+    IncarnationGuid?: string;
+    DonorMode?: boolean;
+    /**
+     * fixed64
+     * VDisk actor instance guid
+     */
+    InstanceGuid?: string;
+    // in reality it is `Donors: TVDiskStateInfo[] | TVSlotId[]`, but this way it is more error-proof
+    Donors?: Array<TVDiskStateInfo | TVSlotId>;
+
+    /** VDisk (Skeleton) Front Queue Status */
+    FrontQueues?: EFlag;
+
+    /** VDisk storage pool label */
+    StoragePoolName?: string;
+
+    /**
+     * uint64
+     * Read bytes per second from PDisk for TEvVGet blobs only
+     */
+    ReadThroughput?: string;
+    /**
+     * uint64
+     * Write bytes per second to PDisk for TEvVPut blobs and replication bytes only
+     */
+    WriteThroughput?: string;
+    CapacityAlert?: ECapacityAlert | string;
+}
+
+export interface TVSlotId {
+    NodeId?: number;
+    PDiskId?: number;
+    VSlotId?: number;
+}
+
+interface TVDiskSatisfactionRank {
+    FreshRank?: TRank;
+    LevelRank?: TRank;
+}
+
+export interface TVDiskID {
+    GroupID?: number;
+    GroupGeneration?: number;
+    Ring?: number;
+    Domain?: number;
+    VDisk?: number;
+}
+
+interface TRank {
+    /**
+     * Rank in percents; 0-100% is good; >100% is bad.
+     * Formula for rank calculation is the following:
+     * Rank = actual_value / max_allowed_value * 100
+     */
+    RankPercent?: number;
+
+    /**
+     * Flag is the Rank transformed to something simple
+     * to understand: Green, Yellow or Red
+     */
+    Flag?: EFlag;
+}
+
+export enum EVDiskState {
+    Initial = 'Initial',
+    LocalRecoveryError = 'LocalRecoveryError',
+    SyncGuidRecovery = 'SyncGuidRecovery',
+    SyncGuidRecoveryError = 'SyncGuidRecoveryError',
+    OK = 'OK',
+    PDiskError = 'PDiskError',
+}
+
+/**
+ * BSC VDisk data
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/protos/sys_view.proto
+ */
+export interface TVSlotEntry {
+    Key?: TVSlotKey;
+    Info?: TVSlotInfo;
+}
+
+type TVSlotKey = TVSlotId;
+
+export interface TVSlotInfo {
+    GroupId?: number;
+    GroupGeneration?: number;
+    FailRealm?: number;
+    FailDomain?: number;
+    VDisk?: number;
+    /** uint64 */
+    AllocatedSize?: string;
+    /** uint64 */
+    AvailableSize?: string;
+    StatusV2?: EVDiskStatus;
+    Kind?: string;
+    IsBeingDeleted?: boolean;
+}
+
+export type EVDiskStatus =
+    | 'ERROR' // the disk is not operational at all
+    | 'INIT_PENDING' // initialization in process
+    | 'REPLICATING' // the disk accepts queries, but not all the data was replicated
+    | 'READY'; // the disk is fully operational and does not affect group fault tolerance

package/src/types/api/vdiskBlobIndex.ts

@@ -0,0 +1,69 @@
+/**
+ * VDisk Blob Index Statistics API types
+ *
+ * endpoint: /vdisk/blobindexstat
+ */
+
+export interface VDiskBlobIndexItem {
+    /** Tablet ID */
+    TabletId?: string | number;
+    /** Alternative field name for Tablet ID */
+    tabletId?: string | number;
+    /** Channel ID */
+    ChannelId?: number;
+    /** Alternative field name for Channel ID */
+    channelId?: number;
+    /** Count */
+    Count?: number;
+    /** Alternative field name for Count */
+    count?: number;
+    /** Size in bytes */
+    Size?: number | string;
+    /** Alternative field name for Size */
+    size?: number | string;
+    /** Allow for other possible field names */
+    [key: string]: any;
+}
+
+export interface VDiskBlobIndexChannel {
+    /** Channel count */
+    count?: string;
+    /** Channel data size */
+    data_size?: string;
+    /** Channel minimum ID */
+    min_id?: string;
+    /** Channel maximum ID */
+    max_id?: string;
+}
+
+export interface VDiskBlobIndexTablet {
+    /** Tablet identifier */
+    tablet_id?: string;
+    /** Array of tablet channels */
+    channels?: VDiskBlobIndexChannel[];
+}
+
+export interface VDiskBlobIndexStat {
+    /** Array of tablets */
+    tablets?: VDiskBlobIndexTablet[];
+    /** Array of channels */
+    channels?: VDiskBlobIndexChannel[];
+}
+
+export interface VDiskBlobIndexResponse {
+    /** Response status */
+    status?: string;
+    /** Statistics data */
+    stat?: VDiskBlobIndexStat;
+    /** Response time */
+    ResponseTime?: string;
+    /** Response duration */
+    ResponseDuration?: number;
+    /** Alternative response structures for backward compatibility */
+    BlobIndexStat?: VDiskBlobIndexItem[];
+    blobIndexStat?: VDiskBlobIndexItem[];
+    blobindexstat?: VDiskBlobIndexItem[];
+    result?: VDiskBlobIndexItem[];
+    data?: VDiskBlobIndexItem[];
+    [key: string]: any; // Allow for other possible field names
+}

package/src/types/api/whoami.ts

@@ -0,0 +1,30 @@
+/**
+ * endpoint: /viewer/json/whoami
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/library/aclib/protos/aclib.proto
+ */
+export interface TUserToken {
+    UserSID?: string;
+    // Generated ID when user is not authenticated
+    UserID?: string;
+    GroupSIDs?: TProtoHashTable;
+    OriginalUserToken?: string;
+    AuthType?: string;
+
+    /** Is user allowed to view only database specific data */
+    IsDatabaseAllowed?: boolean;
+    /** Is user allowed to view data (includes IsDatabaseAllowed rights) */
+    IsViewerAllowed?: boolean;
+    /** Is user allowed to view deeper and make simple changes */
+    IsMonitoringAllowed?: boolean;
+    /** Is user allowed to do unrestricted changes in the system */
+    IsAdministrationAllowed?: boolean;
+}
+
+interface TProtoHashTable {
+    Buckets?: TProtoHashBucket[];
+}
+
+interface TProtoHashBucket {
+    Values?: string[];
+}

package/src/types/assets.d.ts

@@ -0,0 +1,23 @@
+declare module '*.svg' {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+    const content: import('@gravity-ui/uikit').IconData;
+    export default content;
+}
+
+// Type declaration for SVG imports with ?react query parameter.
+// This is required for dynamic imports (import()) to ensure rsbuild's SVGR plugin
+// processes SVG files as React components (IconData) rather than asset URLs.
+// Static imports work without ?react, but dynamic imports need it explicitly.
+// rsbuild svgr docs: https://rsbuild.rs/plugins/list/plugin-svgr#example
+declare module '*.svg?react' {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-imports
+    const content: import('@gravity-ui/uikit').IconData;
+    export default content;
+}
+
+declare module '*.png';
+declare module '*.jpg';
+declare module '*.jpeg';
+declare module '*.ico';
+declare module '*.scss';
+declare module '*.css';

package/src/types/common.ts

@@ -0,0 +1,3 @@
+export type ValueOf<T extends Object> = T[keyof T];
+export type ExtractType<T> = T extends {type: infer U} ? U : string;
+export type WithRequiredFields<T, K extends keyof T> = Exclude<T, K> & Required<Pick<T, K>>;

package/src/types/components.ts

@@ -0,0 +1,6 @@
+import type React from 'react';
+
+export interface InfoItem {
+    label: string;
+    value: React.ReactNode;
+}

package/src/types/global.d.ts

@@ -0,0 +1 @@
+declare type AnyRecord = Record<string | number | symbol, unknown>;

package/src/types/index.ts

@@ -0,0 +1,39 @@
+export enum YQLType {
+    // Numeric
+    Bool = 'Bool',
+    Int8 = 'Int8',
+    Int16 = 'Int16',
+    Int32 = 'Int32',
+    Int64 = 'Int64',
+    Uint8 = 'Uint8',
+    Uint16 = 'Uint16',
+    Uint32 = 'Uint32',
+    Uint64 = 'Uint64',
+    Float = 'Float',
+    Double = 'Double',
+    Decimal = 'Decimal',
+
+    // String
+    String = 'String',
+    Utf8 = 'Utf8',
+    Json = 'Json',
+    JsonDocument = 'JsonDocument',
+    Yson = 'Yson',
+    Uuid = 'Uuid',
+
+    // Date and time
+    Date = 'Date',
+    Datetime = 'Datetime',
+    Timestamp = 'Timestamp',
+    Interval = 'Interval',
+    TzDate = 'TzDate',
+    TzDateTime = 'TzDateTime',
+    TzTimestamp = 'TzTimestamp',
+    Date32 = 'Date32',
+    Datetime64 = 'Datetime64',
+    Timestamp64 = 'Timestamp64',
+    Interval64 = 'Interval64',
+    TzDate32 = 'TzDate32',
+    TzDatetime64 = 'TzDatetime64',
+    TzTimestamp64 = 'TzTimestamp64',
+}