ydb-embedded-ui 1.13.1 → 1.14.0

package/dist/types/api/query.ts

@@ -0,0 +1,147 @@
+// common
+
+type Plan = Record<string, any>;
+type AST = string;
+type Stats = Record<string, any>;
+
+export interface CommonFields {
+    ast?: AST;
+    plan?: Plan;
+    stats?: Stats;
+};
+
+interface DeprecatedCommonFields {
+    stats?: Stats;
+}
+
+export interface ErrorRepsonse {
+    error?: any;
+    issues?: any;
+};
+
+export type ExecuteActions = 'execute-script' | 'execute' | 'execute-scan' | undefined;
+export type ExplainActions = 'explain' | 'explain-ast';
+export type Actions = ExecuteActions | ExplainActions;
+
+// undefined == 'classic'
+export type Schemas = 'classic' | 'modern' | 'ydb' | undefined;
+
+// ==== EXECUTE ====
+
+// common types
+
+type CellValue = string | number | null | undefined;
+
+export type KeyValueRow<T = CellValue> = {
+    [key: string]: T;
+}
+
+export type ArrayRow<T = CellValue> = Array<T>;
+
+export interface ColumnType {
+    name: string;
+    type: string;
+}
+
+// modern response
+
+export type ExecuteModernResponse = {
+    // either both fields exist, or neither one does
+    // they can be undefined for queries like `insert into`
+    result?: ArrayRow[];
+    columns?: ColumnType[];
+} & CommonFields;
+
+export type ExecuteClassicResponseDeep = {
+    // can be undefined for queries like `insert into`
+    result?: KeyValueRow[];
+} & CommonFields;
+
+// can be undefined for queries like `insert into`
+export type ExecuteClassicResponsePlain = KeyValueRow[] | undefined;
+
+export type ExecuteClassicResponse = ExecuteClassicResponseDeep | ExecuteClassicResponsePlain;
+
+export type ExecuteYdbResponse = {
+    // can be undefined for queries like `insert into`
+    result?: KeyValueRow[];
+} & CommonFields;
+
+type ExecuteResponse<Schema extends Schemas> = (
+    Schema extends 'modern'
+        ? ExecuteModernResponse
+        : Schema extends 'ydb'
+            ? ExecuteYdbResponse
+            : Schema extends 'classic' | undefined
+                ? ExecuteClassicResponse
+                : unknown
+);
+
+// deprecated response from older versions, backward compatibility
+
+type DeprecatedExecuteResponseValue =
+    | KeyValueRow[]
+    | string
+    // can be here because of a bug in the previous backend version
+    // should be ignored in parsing
+    | Plan;
+
+export type DeprecatedExecuteResponseDeep = {
+    // can be undefined for queries like `insert into`
+    result?: DeprecatedExecuteResponseValue;
+} & DeprecatedCommonFields;
+
+// can be undefined for queries like `insert into`
+export type DeprecatedExecuteResponsePlain = DeprecatedExecuteResponseValue | undefined;
+
+export type DeprecatedExecuteResponse = DeprecatedExecuteResponseDeep | DeprecatedExecuteResponsePlain;
+
+
+// ==== EXPLAIN ====
+
+// modern response
+
+type ExplainResponse = CommonFields;
+
+// deprecated response from older versions, backward compatibility
+
+type DeprecatedExplainResponse<Action extends ExplainActions> = (
+    Action extends 'explain-ast'
+        ? {ast: AST} & DeprecatedCommonFields
+        : Actions extends 'explain'
+            ? ({result: Plan} & DeprecatedCommonFields) | Plan
+            : unknown
+);
+
+
+// ==== COMBINED API RESPONSE ====
+
+export type QueryAPIExecuteResponse<Schema extends Schemas = undefined> =
+    | ExecuteResponse<Schema>
+    | DeprecatedExecuteResponse
+    | null;
+
+export type QueryAPIExplainResponse<Action extends ExplainActions> =
+    | ExplainResponse
+    | DeprecatedExplainResponse<Action>
+    | null;
+
+export type QueryAPIResponse<Action extends Actions, Schema extends Schemas = undefined> = (
+    Action extends ExecuteActions
+        ? QueryAPIExecuteResponse<Schema>
+        : Action extends ExplainActions
+            ? QueryAPIExplainResponse<Action>
+            : unknown
+);
+
+export type AnyExecuteResponse = 
+    | ExecuteModernResponse
+    | ExecuteClassicResponse
+    | ExecuteYdbResponse
+    | DeprecatedExecuteResponse;
+
+export type DeepExecuteResponse =
+    | ExecuteModernResponse
+    | ExecuteClassicResponseDeep
+    | ExecuteYdbResponse
+    | DeprecatedExecuteResponseDeep;

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
-}