fix: use existing endpoints

Author: astandrik

src/store/reducers/overview/overview.ts

@@ -1,18 +1,28 @@
+import type {Timeout} from '../../../types/api/query';
 import {api} from '../api';
 
 export const overviewApi = api.injectEndpoints({
     endpoints: (build) => ({
         getOverview: build.query({
-            queryFn: async ({paths, database}: {paths: string[]; database: string}, {signal}) => {
+            queryFn: async (
+                {
+                    paths,
+                    database,
+                    timeout,
+                    concurrentId,
+                }: {paths: string[]; database: string; timeout?: Timeout; concurrentId?: string},
+                {signal},
+            ) => {
                 try {
                     const [data, ...additionalData] = await Promise.all(
                         paths.map((p) =>
                             window.api.getDescribe(
                                 {
                                     path: p,
                                     database,
+                                    timeout,
                                 },
-                                {signal},
+                                {signal, concurrentId},
                             ),
                         ),
                     );

src/store/reducers/tableSchemaData.ts

@@ -8,56 +8,52 @@ import type {EPathType} from '../../types/api/schema';
 import {isQueryErrorResponse} from '../../utils/query';
 
 import {api} from './api';
-import {createViewSchemaQuery} from './viewSchema/viewSchema';
+import {overviewApi} from './overview/overview';
+import {viewSchemaApi} from './viewSchema/viewSchema';
 
 export interface GetTableSchemaDataParams {
     path: string;
     tenantName: string;
     type: EPathType;
 }
 
-const tableSchemaDataConcurrentId = 'getTableSchemaData';
-
 const TABLE_SCHEMA_TIMEOUT = 1000;
 
+const getTableSchemaDataConcurrentId = 'getTableSchemaData';
+
 export const tableSchemeDataApi = api.injectEndpoints({
     endpoints: (build) => ({
         getTableSchemaData: build.mutation<SchemaData[], GetTableSchemaDataParams>({
-            queryFn: async ({path, tenantName, type}, {signal}) => {
+            queryFn: async ({path, tenantName, type}, {dispatch}) => {
                 try {
-                    const schemaData = await window.api.getDescribe(
-                        {
-                            path,
+                    const schemaData = await dispatch(
+                        overviewApi.endpoints.getOverview.initiate({
+                            paths: [path],
                             database: tenantName,
                             timeout: TABLE_SCHEMA_TIMEOUT,
-                        },
-                        {signal, concurrentId: tableSchemaDataConcurrentId + 'describe'},
+                            concurrentId: getTableSchemaDataConcurrentId + 'getOverview',
+                        }),
                     );
 
                     if (isViewType(type)) {
-                        const response = await window.api.sendQuery(
-                            {
-                                query: createViewSchemaQuery(path),
+                        const response = await dispatch(
+                            viewSchemaApi.endpoints.getViewSchema.initiate({
                                 database: tenantName,
-                                action: 'execute-scan',
+                                path,
                                 timeout: TABLE_SCHEMA_TIMEOUT,
-                            },
-                            {
-                                withRetries: true,
-                                concurrentId: tableSchemaDataConcurrentId + 'query',
-                            },
+                                concurrentId: getTableSchemaDataConcurrentId + 'getViewSchema',
+                            }),
                         );
 
                         if (isQueryErrorResponse(response)) {
                             return {error: response};
                         }
 
-                        const viewColumnsData = {data: response?.result?.[0]?.columns || []};
-                        const result = prepareViewSchema(viewColumnsData.data);
+                        const result = prepareViewSchema(response.data);
                         return {data: result};
                     }
 
-                    const result = prepareSchemaData(type, schemaData);
+                    const result = prepareSchemaData(type, schemaData.data?.data);
 
                     return {data: result};
                 } catch (error) {

src/store/reducers/viewSchema/viewSchema.ts

@@ -1,3 +1,4 @@
+import type {Timeout} from '../../../types/api/query';
 import {isQueryErrorResponse} from '../../../utils/query';
 import {api} from '../api';
 
@@ -8,15 +9,26 @@ export function createViewSchemaQuery(path: string) {
 export const viewSchemaApi = api.injectEndpoints({
     endpoints: (build) => ({
         getViewSchema: build.query({
-            queryFn: async ({database, path}: {database: string; path: string}) => {
+            queryFn: async ({
+                database,
+                path,
+                timeout,
+                concurrentId,
+            }: {
+                database: string;
+                path: string;
+                timeout?: Timeout;
+                concurrentId?: string;
+            }) => {
                 try {
                     const response = await window.api.sendQuery(
                         {
                             query: createViewSchemaQuery(path),
                             database,
                             action: 'execute-scan',
+                            timeout,
                         },
-                        {withRetries: true},
+                        {withRetries: true, concurrentId},
                     );
 
                     if (isQueryErrorResponse(response)) {