ydb-embedded-ui 1.13.2 → 1.14.1

package/dist/types/api/schema.ts

@@ -56,9 +56,12 @@ interface TPathDescription {
     ColumnTableDescription?: unknown;
 
     TableIndex?: TIndexDescription;
+
+    CdcStreamDescription?: TCdcStreamDescription;
+    PersQueueGroup?: TPersQueueGroupDescription;
 }
 
-interface TDirEntry {
+export interface TDirEntry {
     Name?: string;
     /** uint64 */
     PathId?: string;
@@ -208,12 +211,50 @@ export interface TIndexDescription {
     DataSize?: 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',
+}
+
+interface TPathID {
+    /** fixed64 */
+    OwnerId?: string;
+    /** uint64 */
+    LocalId?: string;
+}
+
+export interface TCdcStreamDescription {
+    Name?: string;
+    Mode?: ECdcStreamMode;
+    Format?: ECdcStreamFormat;
+    PathId?: TPathID;
+    State?: ECdcStreamState;
+    /** uint64 */
+    SchemaVersion?: string;
+}
+
 // incomplete
 export enum EPathType {
     EPathTypeInvalid = 'EPathTypeInvalid',
     EPathTypeDir = 'EPathTypeDir',
     EPathTypeTable = 'EPathTypeTable',
-
+    EPathTypePersQueueGroup = 'EPathTypePersQueueGroup',
     EPathTypeSubDomain = 'EPathTypeSubDomain',
 
     EPathTypeTableIndex = 'EPathTypeTableIndex',
@@ -264,3 +305,195 @@ interface TPathVersion {
     /** uint64 */
     GeneralVersion?: string;
 }
+
+interface TPartitionKeyRange {
+    // Inclusive left border. Emptiness means -inf.
+    FromBound?: string;
+    // Exclusive right border. Emptiness means +inf.
+    ToBound?: string;
+}
+
+interface TPartition {
+    PartitionId?: number;
+    /** uint64 */
+    TabletId?: string;
+    KeyRange?: TPartitionKeyRange;
+}
+
+interface TPartitionToAdd {
+    PartitionId?: number;
+    GroupId?: number;
+}
+
+interface TCodecs {
+    /** int64 */
+    Ids?: string[];
+    Codecs?: string[];
+}
+
+interface TKeyComponentSchema {
+    Name?: string;
+    TypeId?: number;
+}
+
+enum EMeteringMode {
+    METERING_MODE_RESERVED_CAPACITY = 'METERING_MODE_RESERVED_CAPACITY',
+    METERING_MODE_REQUEST_UNITS = 'METERING_MODE_REQUEST_UNITS',
+}
+
+interface TReadQuota {
+    ClientId?: string;
+    /** uint64 */
+    SpeedInBytesPerSecond?: string;
+    /** uint64 */
+    BurstSize?: string;
+}
+
+interface TChannelProfile {
+    PoolKind?: string;
+    /** uint64 */
+    Size?: string;
+    ReadIops?: number;
+    ReadBandwidth?: number;
+    WriteIops?: number;
+    WriteBandwidth?: number;
+}
+
+interface IamCredentials {
+    Endpoint?: string;
+    ServiceAccountKey?: string;
+}
+
+interface TCredentials {
+    OauthToken?: string;
+    JwtParams?: string;
+    Iam?: IamCredentials;
+}
+
+interface TMirrorPartitionConfig {
+    Endpoint?: string;
+    EndpointPort?: number;
+    Topic?: string;
+    Consumer?: string;
+    /** uint64 */
+    ReadFromTimestampsMs?: string;
+    Credentials?: TCredentials;
+    Database?: string;
+    UseSecureConnection?: boolean;
+    SyncWriteTime?: boolean;
+}
+
+interface TPQPartitionConfig {
+    MaxCountInPartition?: number;
+    /** int64 */
+    MaxSizeInPartition?: string;
+    LifetimeSeconds: number;
+    /** uint64 */
+    StorageLimitBytes?: string;
+
+    ImportantClientId?: string[];
+    LowWatermark?: number;
+    SourceIdLifetimeSeconds?: number;
+    SourceIdMaxCounts?: number;
+
+    /** uint64 */
+    WriteSpeedInBytesPerSecond?: string;
+    /** uint64 */
+    BurstSize?: string;
+
+    ReadQuota?: TReadQuota[];
+    /** uint64 */
+    MaxWriteInflightSize?: string;
+    /** uint64 */
+    BorderWriteInflightSize?: string;
+
+    NumChannels?: number;
+
+    TotalPartitions?: number;
+
+    ExplicitChannelProfiles?: TChannelProfile[];
+
+    MirrorFrom?: TMirrorPartitionConfig;
+};
+
+interface TPQTabletConfig {
+    /** uint64 */
+    CacheSize?: string;
+    PartitionConfig: TPQPartitionConfig;
+    /** @deprecated use Partitions */
+    PartitionIds?: number[];
+    TopicName?: string;
+    Version?: number;
+    LocalDC?: boolean;
+    RequireAuthWrite?: boolean;
+    RequireAuthRead?: boolean;
+    Producer?: string;
+    Ident?: string;
+    Topic?: string;
+    DC?: string;
+
+    ReadRules?: string[];
+    /** uint64[] */
+    ReadFromTimestampsMs?: number[];
+    /** uint64[] */
+    ConsumerFormatVersions?: number[];
+    
+    ConsumerCodecs?: TCodecs[];
+    ReadRuleServiceTypes?: string;
+
+    /** uint64 */
+    FormatVersion?: string;
+    Codecs?: TCodecs;
+
+    /** uint64[] */
+    ReadRuleVersions?: string[];
+    /** uint64[] */
+    ReadRuleGenerations?: string[];
+
+    TopicPath?: string;
+
+    YcCloudId?: string;
+    YcFolderId?: string;
+    YdbDatabaseId?: string;
+    YdbDatabasePath?: string;
+    FederationAccount?: string;
+
+    PartitionKeySchema?: TKeyComponentSchema[];
+
+    Partitions?: TPartition[];
+    
+    MeteringMode?: EMeteringMode;
+}
+
+interface TMessageGroup {
+    // Id of message group (SourceId)
+    Id?: string;
+    // Range of the key to which it is allowed to write.
+    KeyRange?: TPartitionKeyRange;
+}
+
+interface TBootstrapConfig {
+    ExplicitMessageGroups?: TMessageGroup[];
+}
+
+export interface TPersQueueGroupDescription {
+    Name: string;
+    /** uint64 */
+    PathId?: string;
+    TotalGroupCount: number;
+    
+    PartitionsToAdd?: TPartitionToAdd[];
+    PartitionsToDelete?: number[];
+    NextPartitionId?: number;
+    PartitionPerTablet?: number;
+    PQTabletConfig: TPQTabletConfig;
+    Partitions?: TPartition[];
+    /** uint64 */
+    AlterVersion?: string;
+    /** uint64 */
+    BalancerTabletID?: string;
+
+    PartitionBoundaries?: any;
+
+    BootstrapConfig?: TBootstrapConfig;
+}

package/dist/types/index.ts

@@ -1 +1,34 @@
 export type RequiredField<Src, Fields extends keyof Src> = Src & Required<Pick<Src, Fields>>;
+
+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',
+}

package/dist/types/store/query.ts

@@ -0,0 +1,9 @@
+import type {KeyValueRow, ColumnType} from '../api/query';
+
+export interface IQueryResult {
+    result?: KeyValueRow[];
+    columns?: ColumnType[];
+    stats?: any;
+    plan?: any;
+    ast?: any;
+}

package/dist/utils/{constants.js → constants.ts}

@@ -14,7 +14,8 @@ export const GIGABYTE = 1_000_000_000;
 export const TERABYTE = 1_000_000_000_000;
 export const GROUP = 'group';
 
-export const DAY_IN_SECONDS = 24 * 60 * 60;
+export const HOUR_IN_SECONDS = 60 * 60;
+export const DAY_IN_SECONDS = 24 * HOUR_IN_SECONDS;
 
 export const TABLET_STATES = {
     TABLET_VOLATILE_STATE_UNKNOWN: 'unknown',
@@ -87,13 +88,15 @@ export const TABLET_SYMBOLS = {
     TenantSlotBroker: 'TB',
 };
 
-export const getTabletLabel = (type) => {
+const isTabletType = (type: string): type is keyof typeof TABLET_SYMBOLS => type in TABLET_SYMBOLS;
+
+export const getTabletLabel = (type?: string) => {
     if (!type) {
-        return;
+        return undefined;
     }
-    const defaultValue = type.match(/[A-Z]/g).join('');
+    const defaultValue = type.match(/[A-Z]/g)?.join('');
 
-    return TABLET_SYMBOLS[type] || defaultValue;
+    return isTabletType(type) ? TABLET_SYMBOLS[type] : defaultValue;
 };
 
 export const LOAD_AVERAGE_TIME_INTERVALS = ['1 min', '5 min', '15 min'];
@@ -116,12 +119,14 @@ export const ALL = 'All';
 export const PROBLEMS = 'With problems';
 
 export const THEME_KEY = 'theme';
+export const INVERTED_DISKS_KEY = 'invertedDisks';
 export const SAVED_QUERIES_KEY = 'saved_queries';
 export const QUERIES_HISTORY_KEY = 'queries_history';
 export const DATA_QA_TUNE_COLUMNS_POPUP = 'tune-columns-popup';
 
 export const defaultUserSettings = {
     [THEME_KEY]: 'light',
+    [INVERTED_DISKS_KEY]: false,
 };
 export const DEFAULT_SIZE_RESULT_PANE_KEY = 'default-size-result-pane';
 export const DEFAULT_SIZE_TENANT_SUMMARY_KEY = 'default-size-tenant-summary-pane';
@@ -139,7 +144,7 @@ export const DEFAULT_TABLE_SETTINGS = {
     syncHeadOnResize: true,
     dynamicRender: true,
     highlightRows: true,
-};
+} as const;
 
 export const TENANT_INITIAL_TAB_KEY = 'saved_tenant_initial_tab';
 export const QUERY_INITIAL_RUN_ACTION_KEY = 'query_initial_run_action';

package/dist/utils/index.js

@@ -1,6 +1,5 @@
 import numeral from 'numeral';
 import locales from 'numeral/locales'; // eslint-disable-line no-unused-vars
-import _ from 'lodash';
 
 import {i18n} from './i18n';
 import {MEGABYTE, TERABYTE, DAY_IN_SECONDS, GIGABYTE} from './constants';
@@ -143,26 +142,3 @@ export const getMetaForExplainNode = (node) => {
             return '';
     }
 };
-
-export const prepareQueryResponse = (data) => {
-    return _.map(data, (item) => {
-        const formattedData = {};
-
-        for (const field in item) {
-            if (Object.prototype.hasOwnProperty.call(item, field)) {
-                const type = typeof item[field];
-                if (type === 'object' || type === 'boolean' || Array.isArray(item[field])) {
-                    formattedData[field] = JSON.stringify(item[field]);
-                } else {
-                    formattedData[field] = item[field];
-                }
-            }
-        }
-
-        return formattedData;
-    });
-};
-
-export function prepareQueryError(error) {
-    return error.data?.error?.message || error.data || error
-}

package/dist/utils/query.test.ts

@@ -0,0 +1,189 @@
+import {parseQueryAPIExecuteResponse} from './query';
+
+describe('API utils', () => {
+    describe('json/viewer/query', () => {
+        describe('parseQueryAPIExecuteResponse', () => {
+            describe('old format', () => {
+                describe('plain response', () => {
+                    it('should handle empty response', () => {
+                        expect(parseQueryAPIExecuteResponse(null).result).toBeUndefined();
+                    });
+
+                    it('should parse json string', () => {
+                        const json = {foo: 'bar'};
+                        const response = JSON.stringify(json);
+                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(json);
+                    });
+
+                    // it should not be in the response, but is there because of a bug
+                    it('should ignore request plan as the response', () => {
+                        const response = {queries: 'some queries'};
+                        expect(parseQueryAPIExecuteResponse(response).result).toBeUndefined();
+                    });
+
+                    it('should accept key-value rows', () => {
+                        const response = [{foo: 'bar'}];
+                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(response);
+                    });
+                });
+
+                describe('deep response without stats', () => {
+                    it('should parse json string in the result field', () => {
+                        const json = {foo: 'bar'};
+                        const response = {result: JSON.stringify(json)};
+                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(json);
+                    });
+
+                    // it should not be in the response, but is there because of a bug
+                    it('should ignore request plan in the result field', () => {
+                        const response = {result: {queries: 'some queries'}};
+                        expect(parseQueryAPIExecuteResponse(response).result).toBeUndefined();
+                    });
+
+                    it('should accept key-value rows in the result field', () => {
+                        const response = {result: [{foo: 'bar'}]};
+                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(response.result);
+                    });
+                });
+
+                describe('deep response with stats', () => {
+                    it('should parse json string in the result field', () => {
+                        const json = {foo: 'bar'};
+                        const response = {
+                            result: JSON.stringify(json),
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toEqual(json);
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+
+                    // it should not be in the response, but is there because of a bug
+                    it('should ignore request plan in the result field', () => {
+                        const response = {
+                            result: {queries: 'some queries'},
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toBeUndefined();
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+
+                    it('should accept key-value rows in the result field', () => {
+                        const response = {
+                            result: [{foo: 'bar'}],
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toEqual(response.result);
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+
+                    it('should accept stats without a result', () => {
+                        const response = {
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toBeUndefined();
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+                });
+            });
+
+            describe('new format', () => {
+                describe('response without stats', () => {
+                    it('should parse modern schema', () => {
+                        const response = {
+                            result: [['42', 'hello world']],
+                            columns: [{
+                                name: 'id',
+                                type: 'Uint64?'
+                            }, {
+                                name: 'value',
+                                type: 'Utf8?'
+                            }],
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toEqual([{
+                            id: '42',
+                            value: 'hello world'
+                        }]);
+                        expect(actual.columns).toEqual(response.columns);
+                    });
+
+                    it('should handle empty response for classic schema', () => {
+                        expect(parseQueryAPIExecuteResponse(null).result).toBeUndefined();
+                    });
+
+                    it('should parse plain classic schema', () => {
+                        const response = [{foo: 'bar'}];
+                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(response);
+                    });
+
+                    it('should parse deep classic schema', () => {
+                        const response = {result: [{foo: 'bar'}]};
+                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(response.result);
+                    });
+
+                    it('should parse ydb schema', () => {
+                        const response = {result: [{foo: 'bar'}]};
+                        expect(parseQueryAPIExecuteResponse(response).result).toEqual(response.result);
+                    });
+                });
+
+                describe('response with stats', () => {
+                    it('should parse modern schema', () => {
+                        const response = {
+                            result: [['42', 'hello world']],
+                            columns: [{
+                                name: 'id',
+                                type: 'Uint64?'
+                            }, {
+                                name: 'value',
+                                type: 'Utf8?'
+                            }],
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toEqual([{
+                            id: '42',
+                            value: 'hello world'
+                        }]);
+                        expect(actual.columns).toEqual(response.columns);
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+
+                    it('should parse classic schema', () => {
+                        const response = {
+                            result: [{foo: 'bar'}],
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toEqual(response.result);
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+
+                    it('should parse ydb schema', () => {
+                        const response = {
+                            result: [{foo: 'bar'}],
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toEqual(response.result);
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+
+                    it('should accept stats without a result', () => {
+                        const response = {
+                            stats: {metric: 'good'},
+                        };
+                        const actual = parseQueryAPIExecuteResponse(response);
+                        expect(actual.result).toBeUndefined();
+                        expect(actual.columns).toBeUndefined();
+                        expect(actual.stats).toEqual(response.stats);
+                    });
+                });
+            });
+        });
+    });
+});