fix: review fixes

Author: astandrik

src/containers/Tenant/Schema/SchemaTree/SchemaTree.tsx

@@ -10,6 +10,8 @@ import {schemaApi} from '../../../../store/reducers/schema/schema';
 import type {GetTableSchemaDataParams} from '../../../../store/reducers/tableSchemaData';
 import {useGetTableSchemaDataMutation} from '../../../../store/reducers/tableSchemaData';
 import type {EPathType, TEvDescribeSchemeResult} from '../../../../types/api/schema';
+import {wait} from '../../../../utils';
+import {SECOND_IN_MS} from '../../../../utils/constants';
 import {useQueryExecutionSettings, useTypedDispatch} from '../../../../utils/hooks';
 import {getSchemaControls} from '../../utils/controls';
 import {isChildlessPathType, mapPathTypeToNavigationTreeType} from '../../utils/schema';
@@ -24,6 +26,8 @@ interface SchemaTreeProps {
     onActivePathUpdate: (path: string) => void;
 }
 
+const TABLE_SCHEMA_TIMEOUT = SECOND_IN_MS * 2;
+
 export function SchemaTree(props: SchemaTreeProps) {
     const createDirectoryFeatureAvailable = useCreateDirectoryFeatureAvailable();
     const {rootPath, rootName, rootType, currentPath, onActivePathUpdate} = props;
@@ -33,7 +37,10 @@ export function SchemaTree(props: SchemaTreeProps) {
     const getTableSchemaDataPromise = React.useCallback(
         async (args: GetTableSchemaDataParams) => {
             try {
-                const result = await getTableSchemaDataMutation(args).unwrap();
+                const result = await Promise.race([
+                    getTableSchemaDataMutation(args).unwrap(),
+                    wait<undefined>(TABLE_SCHEMA_TIMEOUT),
+                ]);
                 return result;
             } catch (e) {
                 return undefined;

src/services/api.ts

@@ -374,7 +374,7 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
         );
     }
     getDescribe(
-        {path, database, timeout}: {path: string; database: string; timeout?: Timeout},
+        {path, database}: {path: string; database: string},
         {concurrentId, signal}: AxiosOptions = {},
     ) {
         return this.get<Nullable<TEvDescribeSchemeResult>>(
@@ -386,7 +386,7 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
                 partition_stats: true,
                 subs: 0,
             },
-            {concurrentId: concurrentId || `getDescribe|${path}`, requestConfig: {signal}, timeout},
+            {concurrentId: concurrentId || `getDescribe|${path}`, requestConfig: {signal}},
         );
     }
     getSchemaAcl(

src/store/reducers/overview/overview.ts

@@ -1,28 +1,18 @@
-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,
-                    timeout,
-                    concurrentId,
-                }: {paths: string[]; database: string; timeout?: Timeout; concurrentId?: string},
-                {signal},
-            ) => {
+            queryFn: async ({paths, database}: {paths: string[]; database: string}, {signal}) => {
                 try {
                     const [data, ...additionalData] = await Promise.all(
                         paths.map((p) =>
                             window.api.getDescribe(
                                 {
                                     path: p,
                                     database,
-                                    timeout,
                                 },
-                                {signal, concurrentId},
+                                {signal},
                             ),
                         ),
                     );

src/store/reducers/tableSchemaData.ts

@@ -17,31 +17,16 @@ export interface GetTableSchemaDataParams {
     type: EPathType;
 }
 
-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}, {dispatch}) => {
                 try {
-                    const schemaData = await dispatch(
-                        overviewApi.endpoints.getOverview.initiate({
-                            paths: [path],
-                            database: tenantName,
-                            timeout: TABLE_SCHEMA_TIMEOUT,
-                            concurrentId: getTableSchemaDataConcurrentId + 'getOverview',
-                        }),
-                    );
-
                     if (isViewType(type)) {
                         const response = await dispatch(
                             viewSchemaApi.endpoints.getViewSchema.initiate({
                                 database: tenantName,
                                 path,
-                                timeout: TABLE_SCHEMA_TIMEOUT,
-                                concurrentId: getTableSchemaDataConcurrentId + 'getViewSchema',
                             }),
                         );
 
@@ -53,6 +38,12 @@ export const tableSchemeDataApi = api.injectEndpoints({
                         return {data: result};
                     }
 
+                    const schemaData = await dispatch(
+                        overviewApi.endpoints.getOverview.initiate({
+                            paths: [path],
+                            database: tenantName,
+                        }),
+                    );
                     const result = prepareSchemaData(type, schemaData.data?.data);
 
                     return {data: result};

src/store/reducers/viewSchema/viewSchema.ts

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

src/utils/index.ts

@@ -6,8 +6,8 @@ export function valueIsDefined<T>(value: T | null | undefined): value is T {
     return value !== null && value !== undefined;
 }
 
-export async function wait(time: number) {
+export async function wait<T = unknown>(time: number, value?: T): Promise<T | undefined> {
     return new Promise((resolve) => {
-        setTimeout(resolve, time);
+        setTimeout(() => resolve(value), time);
     });
 }