feat: enable explain-script parsing, remove deprecated code

BREAKING CHANGE: app no longer parses query responses from older ydb versions

Author: artemmufazalov

src/store/reducers/explainQuery.ts

@@ -11,7 +11,7 @@ import type {
 import type {QueryRequestParams} from '../../types/store/query';
 
 import {preparePlan} from '../../utils/prepareQueryExplain';
-import {parseQueryAPIExplainResponse} from '../../utils/query';
+import {parseQueryAPIExplainResponse, parseQueryExplainPlan} from '../../utils/query';
 import {parseQueryError} from '../../utils/error';
 
 import {createRequestActionTypes, createApiRequest} from '../utils';
@@ -102,19 +102,19 @@ export const getExplainQuery = ({query, database}: QueryRequestParams) => {
         request: window.api.getExplainQuery(query, database),
         actions: GET_EXPLAIN_QUERY,
         dataHandler: (response): PreparedExplainResponse => {
-            const {plan: result, ast} = parseQueryAPIExplainResponse(response);
+            const {plan: rawPlan, ast} = parseQueryAPIExplainResponse(response);
 
-            if (!result) {
+            if (!rawPlan) {
                 return {ast};
             }
 
-            const {tables, meta, Plan} = result;
+            const {tables, meta, Plan} = parseQueryExplainPlan(rawPlan);
 
             if (supportedExplainQueryVersions.indexOf(meta.version) === -1) {
                 // Do not prepare plan for not supported versions
                 return {
                     plan: {
-                        pristine: result,
+                        pristine: rawPlan,
                         version: meta.version,
                     },
                     ast,
@@ -136,7 +136,7 @@ export const getExplainQuery = ({query, database}: QueryRequestParams) => {
                     nodes,
                     tables,
                     version: meta.version,
-                    pristine: result,
+                    pristine: rawPlan,
                 },
                 ast,
             };

src/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[]) => {