ydb-embedded-ui 3.5.0 → 4.1.0

package/dist/utils/query.ts

@@ -2,13 +2,10 @@ import {YQLType} from '../types';
 import type {
     AnyExecuteResponse,
     AnyExplainResponse,
-    AnyResponse,
-    CommonFields,
-    DeepExecuteResponse,
-    DeprecatedExecuteResponsePlain,
-    ExecuteClassicResponsePlain,
     ExecuteModernResponse,
     KeyValueRow,
+    ScanPlan,
+    ScriptPlan,
 } from '../types/api/query';
 import type {IQueryResult} from '../types/store/query';
 
@@ -49,6 +46,7 @@ export const getColumnType = (type: string) => {
     }
 };
 
+/** parse response result field from ArrayRow to KeyValueRow */
 const parseExecuteModernResponse = (data: ExecuteModernResponse): IQueryResult => {
     const {result, columns, ...restData} = data;
 
@@ -57,43 +55,17 @@ const parseExecuteModernResponse = (data: ExecuteModernResponse): IQueryResult =
             result &&
             columns &&
             result.map((row) => {
-                return row.reduce((newRow: KeyValueRow, cellData, columnIndex) => {
+                return row.reduce((newRow, cellData, columnIndex) => {
                     const {name} = columns[columnIndex];
                     newRow[name] = cellData;
                     return newRow;
-                }, {});
+                }, {} as KeyValueRow);
             }),
         columns,
         ...restData,
     };
 };
 
-const parseDeprecatedExecuteResponseValue = (
-    data?: DeprecatedExecuteResponsePlain | ExecuteClassicResponsePlain,
-): KeyValueRow[] | undefined => {
-    if (!data) {
-        return undefined;
-    }
-
-    if (typeof data === 'string') {
-        try {
-            return JSON.parse(data);
-        } catch (e) {
-            return undefined;
-        }
-    }
-
-    if (Array.isArray(data)) {
-        return data;
-    }
-
-    // Plan is not a valid response in this case
-    return undefined;
-};
-
-const hasResult = (data: AnyExecuteResponse): data is DeepExecuteResponse =>
-    Boolean(data && typeof data === 'object' && 'result' in data);
-
 const isModern = (response: AnyExecuteResponse): response is ExecuteModernResponse =>
     Boolean(
         response &&
@@ -102,70 +74,64 @@ const isModern = (response: AnyExecuteResponse): response is ExecuteModernRespon
             Array.isArray((response as ExecuteModernResponse).columns),
     );
 
-const hasCommonFields = (data: AnyResponse): data is CommonFields =>
-    Boolean(
-        data && typeof data === 'object' && ('ast' in data || 'plan' in data || 'stats' in data),
+type UnsupportedQueryResponseFormat =
+    | Array<unknown>
+    | string
+    | null
+    | undefined
+    | {result: string | Record<string, unknown>};
+
+const isUnsupportedType = (
+    data: AnyExecuteResponse | AnyExplainResponse | UnsupportedQueryResponseFormat,
+): data is UnsupportedQueryResponseFormat => {
+    return Boolean(
+        !data ||
+            typeof data !== 'object' ||
+            Array.isArray(data) ||
+            ('result' in data && !Array.isArray(data.result)),
     );
+};
 
-// complex logic because of the variety of possible responses
-// after all backends are updated to the latest version, it can be simplified
-export const parseQueryAPIExecuteResponse = (data: AnyExecuteResponse): IQueryResult => {
-    if (!data) {
+export const parseQueryAPIExecuteResponse = (
+    data: AnyExecuteResponse | UnsupportedQueryResponseFormat,
+): IQueryResult => {
+    if (isUnsupportedType(data)) {
         return {};
     }
-
-    if (hasResult(data)) {
-        if (isModern(data)) {
-            return parseExecuteModernResponse(data);
-        }
-
-        return {
-            ...data,
-            result: parseDeprecatedExecuteResponseValue(data.result),
-        };
-    }
-
-    if (hasCommonFields(data)) {
-        return data;
+    if (isModern(data)) {
+        return parseExecuteModernResponse(data);
     }
 
-    return {
-        result: parseDeprecatedExecuteResponseValue(data),
-    };
+    return data;
 };
 
-// complex logic because of the variety of possible responses
-// after all backends are updated to the latest version, it can be simplified
-export const parseQueryAPIExplainResponse = (data: AnyExplainResponse): IQueryResult => {
-    if (!data) {
+export const parseQueryAPIExplainResponse = (
+    data: AnyExplainResponse | UnsupportedQueryResponseFormat,
+): IQueryResult => {
+    if (isUnsupportedType(data)) {
         return {};
     }
 
-    if ('ast' in data) {
-        return data;
-    }
+    return data;
+};
 
-    if ('result' in data) {
-        const {result, ...restData} = data;
+const isExplainScriptPlan = (plan: ScriptPlan | ScanPlan): plan is ScriptPlan =>
+    Boolean(plan && 'queries' in plan);
 
-        if ('ast' in data.result) {
-            return {
-                ast: result.ast,
-                ...restData,
-            };
+export const parseQueryExplainPlan = (plan: ScriptPlan | ScanPlan): ScanPlan => {
+    if (isExplainScriptPlan(plan)) {
+        if (!plan.queries || !plan.queries.length) {
+            return {meta: plan.meta};
         }
 
         return {
-            plan: data.result,
-            ...restData,
+            Plan: plan.queries[0].Plan,
+            tables: plan.queries[0].tables,
+            meta: plan.meta,
         };
     }
 
-    if (hasCommonFields(data)) {
-        return data;
-    }
-
-    return {plan: data};
+    return plan;
 };
 
 export const prepareQueryResponse = (data?: KeyValueRow[]) => {

package/dist/utils/timeParsers/i18n/en.json

@@ -1,11 +1,11 @@
 {
-  "daysHours": "{{days}}d {{hours}}h",
-  "hoursMin": "{{hours}}h {{minutes}}m",
-  "minSec": "{{minutes}}m {{seconds}}s",
-  "secMs": "{{seconds}}s {{ms}}ms",
-  "days": "{{days}}d",
-  "hours": "{{hours}}h",
-  "min": "{{minutes}}m",
-  "sec": "{{seconds}}s",
-  "ms": "{{ms}}ms"
+  "daysHours": "{{days}}\u00a0d\u00a0{{hours}}\u00a0h",
+  "hoursMin": "{{hours}}\u00a0h\u00a0{{minutes}}\u00a0m",
+  "minSec": "{{minutes}}\u00a0m\u00a0{{seconds}}\u00a0s",
+  "secMs": "{{seconds}}\u00a0s\u00a0{{ms}}\u00a0ms",
+  "days": "{{days}}\u00a0d",
+  "hours": "{{hours}}\u00a0h",
+  "min": "{{minutes}}\u00a0m",
+  "sec": "{{seconds}}\u00a0s",
+  "ms": "{{ms}}\u00a0ms"
 }

package/dist/utils/timeParsers/i18n/ru.json

@@ -1,11 +1,11 @@
 {
-  "daysHours": "{{days}}д {{hours}}ч",
-  "hoursMin": "{{hours}}ч {{minutes}}м",
-  "minSec": "{{minutes}}м {{seconds}}с",
-  "secMs": "{{seconds}}с {{ms}}мс",
-  "days": "{{days}}д",
-  "hours": "{{hours}}ч",
-  "min": "{{minutes}}м",
-  "sec": "{{seconds}}с",
-  "ms": "{{ms}}мс"
+  "daysHours": "{{days}}\u00a0д\u00a0{{hours}}\u00a0ч",
+  "hoursMin": "{{hours}}\u00a0ч\u00a0{{minutes}}\u00a0м",
+  "minSec": "{{minutes}}\u00a0м\u00a0{{seconds}}\u00a0с",
+  "secMs": "{{seconds}}\u00a0с\u00a0{{ms}}\u00a0мс",
+  "days": "{{days}}\u00a0д",
+  "hours": "{{hours}}\u00a0ч",
+  "min": "{{minutes}}\u00a0м",
+  "sec": "{{seconds}}\u00a0с",
+  "ms": "{{ms}}\u00a0мс"
 }

package/dist/utils/timeParsers/parsers.ts

@@ -1,5 +1,6 @@
 import type {IProtobufTimeObject} from '../../types/api/common';
 
+import {isNumeric} from '../utils';
 import {parseProtobufDurationToMs, parseProtobufTimestampToMs} from '.';
 
 export const parseLag = (value: string | IProtobufTimeObject | undefined) =>
@@ -16,3 +17,11 @@ export const parseTimestampToIdleTime = (value: string | IProtobufTimeObject | u
     // Usually it below 100ms, so it could be omitted
     return duration < 0 ? 0 : duration;
 };
+
+export const parseUsToMs = (value: string | number | undefined) => {
+    if (!value || !isNumeric(value)) {
+        return 0;
+    }
+
+    return Math.round(Number(value) / 1000);
+};

package/dist/utils/utils.js

@@ -1,11 +1,10 @@
 export function parseJson(value) {
     if (!value) {
-        return;
+        return undefined;
     }
     try {
         return JSON.parse(value);
     } catch (err) {
-        console.log(err);
         return value;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-embedded-ui",
-  "version": "3.5.0",
+  "version": "4.1.0",
   "files": [
     "dist"
   ],

package/dist/services/api.d.ts

@@ -1,86 +0,0 @@
-type AxiosOptions = {
-    concurrentId?: string;
-};
-
-interface Window {
-    api: {
-        getSchema: (
-            params: {path: string},
-            axiosOptions?: AxiosOptions,
-        ) => Promise<import('../types/api/schema').TEvDescribeSchemeResult>;
-        getDescribe: (
-            params: {path: string},
-            axiosOptions?: AxiosOptions,
-        ) => Promise<import('../types/api/schema').TEvDescribeSchemeResult>;
-        getStorageInfo: (
-            params: {
-                tenant: string;
-                filter: string;
-                nodeId: string;
-            },
-            axiosOptions?: AxiosOptions,
-        ) => Promise<import('../types/api/storage').TStorageInfo>;
-        getNodes: (
-            params: import('../types/store/nodes').INodesApiRequestParams,
-            axiosOptions?: AxiosOptions,
-        ) => Promise<import('../types/api/nodes').TNodesInfo>;
-        getCompute: (path: string) => Promise<import('../types/api/compute').TComputeInfo>;
-        sendQuery: <
-            Action extends import('../types/api/query').Actions,
-            Schema extends import('../types/api/query').Schemas = undefined,
-        >(
-            params: {
-                query?: string;
-                database?: string;
-                action?: Action;
-                stats?: string;
-                schema?: Schema;
-            },
-            axiosOptions?: AxiosOptions,
-        ) => Promise<import('../types/api/query').QueryAPIResponse<Action, Schema>>;
-        getExplainQuery: (
-            query: string,
-            database: string,
-        ) => Promise<import('../types/api/query').QueryAPIExplainResponse<'explain'>>;
-        getExplainQueryAst: (
-            query: string,
-            database: string,
-        ) => Promise<import('../types/api/query').QueryAPIExplainResponse<'explain-ast'>>;
-        getHealthcheckInfo: (
-            database: string,
-        ) => Promise<import('../types/api/healthcheck').HealthCheckAPIResponse>;
-        getTenantInfo: (params: {
-            path: string;
-        }) => Promise<import('../types/api/tenant').TTenantInfo>;
-        getClusterInfo: () => Promise<import('../types/api/cluster').TClusterInfo>;
-        getTabletsInfo: (params: {
-            nodes?: string[];
-            path?: string;
-        }) => Promise<import('../types/api/tablet').TEvTabletStateResponse>;
-        getTabletDescribe: (
-            tenantId?: import('../types/api/tablet').TDomainKey,
-        ) => Promise<import('../types/api/schema').TEvDescribeSchemeResult>;
-        getTablet: (params: {
-            id?: string;
-        }) => Promise<import('../types/api/tablet').TEvTabletStateResponse>;
-        getTabletHistory: (params: {
-            id?: string;
-        }) => Promise<import('../types/api/tablet').UnmergedTEvTabletStateResponse>;
-        getHeatmapData: (params: {
-            path: string;
-        }) => Promise<import('../types/api/schema').TEvDescribeSchemeResult>;
-        getTopic: (params: {
-            path?: string;
-        }) => Promise<import('../types/api/topic').DescribeTopicResult>;
-        getConsumer: (params: {
-            path?: string;
-            consumer?: string;
-        }) => Promise<import('../types/api/consumer').DescribeConsumerResult>;
-        getHostInfo: () => Promise<import('../types/api/systemState').TEvSystemStateResponse>;
-        getNodeInfo: (
-            id?: string,
-        ) => Promise<import('../types/api/systemState').TEvSystemStateResponse>;
-        getNodesList: () => Promise<import('../types/api/nodesList').TEvNodesInfo>;
-        [method: string]: Function;
-    };
-}

package/dist/services/api.js

@@ -1,278 +0,0 @@
-import AxiosWrapper from '@gravity-ui/axios-wrapper';
-
-import {backend as BACKEND} from '../store';
-
-const config = {withCredentials: !window.custom_backend};
-
-const {settingsApi} = window.web_version ? window.systemSettings : {};
-
-export class YdbEmbeddedAPI extends AxiosWrapper {
-    getPath(path) {
-        return `${BACKEND}${path}`;
-    }
-    getClusterInfo() {
-        return this.get(this.getPath('/viewer/json/cluster'), {tablets: true});
-    }
-    getNodeInfo(id) {
-        return this.get(this.getPath('/viewer/json/sysinfo?enums=true'), {
-            node_id: id,
-        });
-    }
-    getTenants() {
-        return this.get(this.getPath('/viewer/json/tenantinfo'), {
-            tablets: 1,
-            storage: 1,
-        });
-    }
-    getTenantInfo({path}) {
-        return this.get(this.getPath('/viewer/json/tenantinfo'), {
-            path,
-            tablets: true,
-            storage: true,
-        });
-    }
-    getNodes({tenant, filter, storage, type = 'any', tablets = true}, {concurrentId} = {}) {
-        return this.get(
-            this.getPath('/viewer/json/nodes?enums=true'),
-            {
-                tenant,
-                with: filter,
-                storage,
-                type,
-                tablets,
-            },
-            {
-                concurrentId,
-            },
-        );
-    }
-    getCompute(path) {
-        return this.get(this.getPath('/viewer/json/compute?enums=true'), {path});
-    }
-    getStorageInfo({tenant, filter, nodeId}, {concurrentId} = {}) {
-        return this.get(
-            this.getPath(`/viewer/json/storage?enums=true`),
-            {
-                tenant,
-                node_id: nodeId,
-                with: filter,
-            },
-            {
-                concurrentId,
-            },
-        );
-    }
-    getPdiskInfo(nodeId, pdiskId) {
-        return this.get(this.getPath('/viewer/json/pdiskinfo?enums=true'), {
-            filter: `(NodeId=${nodeId}${pdiskId ? `;PDiskId=${pdiskId}` : ''})`,
-        });
-    }
-    getVdiskInfo({vdiskId, pdiskId, nodeId}) {
-        return this.get(this.getPath('/viewer/json/vdiskinfo?enums=true'), {
-            filter: `(VDiskId=${vdiskId ?? ''};PDiskId=${pdiskId ?? ''};NodeId=${nodeId ?? ''})`,
-        });
-    }
-    getGroupInfo(groupId) {
-        return this.get(this.getPath('/viewer/json/storage?enums=true'), {
-            group_id: groupId,
-        });
-    }
-    getHostInfo() {
-        return this.get(this.getPath('/viewer/json/sysinfo?node_id=.&enums=true'));
-    }
-    getTabletsInfo({nodes = [], path}) {
-        const filter = nodes.length > 0 && `(NodeId=[${nodes.join(',')}])`;
-        return this.get(this.getPath('/viewer/json/tabletinfo'), {
-            filter,
-            path,
-            enums: true,
-        });
-    }
-    getSchema({path}, {concurrentId} = {}) {
-        return this.get(
-            this.getPath('/viewer/json/describe'),
-            {
-                path,
-                enums: true,
-                backup: false,
-                private: true,
-                partition_config: true,
-                partition_stats: true,
-                partitioning_info: true,
-                subs: 1,
-            },
-            {concurrentId: concurrentId || `getSchema|${path}`},
-        );
-    }
-    getDescribe({path}, {concurrentId} = {}) {
-        return this.get(
-            this.getPath('/viewer/json/describe'),
-            {
-                path,
-                enums: true,
-                partition_stats: true,
-                subs: 0,
-            },
-            {concurrentId: concurrentId || `getDescribe|${path}`},
-        );
-    }
-    getSchemaAcl({path}) {
-        return this.get(
-            this.getPath('/viewer/json/acl'),
-            {
-                path,
-            },
-            {concurrentId: `getSchemaAcl|${path}`},
-        );
-    }
-    getHeatmapData({path}) {
-        return this.get(this.getPath('/viewer/json/describe'), {
-            path,
-            enums: true,
-            backup: false,
-            children: false,
-            partition_config: false,
-            partition_stats: true,
-        });
-    }
-    getNetwork(path) {
-        return this.get(this.getPath('/viewer/json/netinfo'), {
-            enums: true,
-            path,
-        });
-    }
-    getTopic({path}, {concurrentId} = {}) {
-        return this.get(
-            this.getPath('/viewer/json/describe_topic'),
-            {
-                enums: true,
-                include_stats: true,
-                path,
-            },
-            {concurrentId: concurrentId || 'getTopic'},
-        );
-    }
-    getConsumer({path, consumer}, {concurrentId} = {}) {
-        return this.get(
-            this.getPath('/viewer/json/describe_consumer'),
-            {
-                enums: true,
-                include_stats: true,
-                path,
-                consumer,
-            },
-            {concurrentId: concurrentId || 'getConsumer'},
-        );
-    }
-    getPoolInfo(poolName) {
-        return this.get(this.getPath('/viewer/json/storage'), {
-            pool: poolName,
-            enums: true,
-        });
-    }
-    getTablet({id}) {
-        return this.get(this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`), {
-            enums: true,
-        });
-    }
-    getTabletHistory({id}) {
-        return this.get(this.getPath(`/viewer/json/tabletinfo?filter=(TabletId=${id})`), {
-            enums: true,
-            merge: false,
-        });
-    }
-    getNodesList() {
-        return this.get(this.getPath('/viewer/json/nodelist'), {enums: true});
-    }
-    getTenantsList() {
-        return this.get(this.getPath('/viewer/json/tenants'), {
-            enums: true,
-            state: 0,
-        });
-    }
-    sendQuery({query, database, action, stats, schema}, {concurrentId} = {}) {
-        return this.post(
-            this.getPath(`/viewer/json/query${schema ? `?schema=${schema}` : ''}`),
-            {
-                query,
-                database,
-                action,
-                stats,
-                timeout: 600000,
-            },
-            null,
-            {
-                concurrentId,
-                timeout: 9 * 60 * 1000,
-            },
-        );
-    }
-    getExplainQuery(query, database) {
-        return this.post(this.getPath('/viewer/json/query'), {
-            query,
-            database,
-            action: 'explain',
-            timeout: 600000,
-        });
-    }
-    getExplainQueryAst(query, database) {
-        return this.post(this.getPath('/viewer/json/query'), {
-            query,
-            database,
-            action: 'explain-ast',
-            timeout: 600000,
-        });
-    }
-    getHotKeys(path, enableSampling) {
-        return this.get(this.getPath('/viewer/json/hotkeys'), {
-            path,
-            enable_sampling: enableSampling,
-        });
-    }
-    getHealthcheckInfo(database) {
-        return this.get(this.getPath('/viewer/json/healthcheck'), {
-            tenant: database,
-        });
-    }
-    killTablet(id) {
-        return this.get(this.getPath(`/tablets?KillTabletID=${id}`));
-    }
-    stopTablet(id, hiveId) {
-        return this.get(
-            this.getPath(`/tablets/app?TabletID=${hiveId}&page=StopTablet&tablet=${id}`),
-        );
-    }
-    resumeTablet(id, hiveId) {
-        return this.get(
-            this.getPath(`/tablets/app?TabletID=${hiveId}&page=ResumeTablet&tablet=${id}`),
-        );
-    }
-    getTabletDescribe(tenantId) {
-        return this.get(this.getPath('/viewer/json/describe'), {
-            schemeshard_id: tenantId?.SchemeShard,
-            path_id: tenantId?.PathId,
-        });
-    }
-    postSetting(name, value) {
-        return this.request({
-            method: 'PATCH',
-            url: settingsApi,
-            data: {[name]: value},
-        });
-    }
-    authenticate(user, password) {
-        return this.post(this.getPath('/login'), {
-            user,
-            password,
-        });
-    }
-    logout() {
-        return this.post(this.getPath('/logout'), {});
-    }
-    whoami() {
-        return this.get(this.getPath('/viewer/json/whoami'));
-    }
-}
-
-const api = new YdbEmbeddedAPI({config: config});
-window.api = api;