ydb-embedded-ui 6.0.1 → 6.1.0

package/dist/components/CriticalActionDialog/CriticalActionDialog.scss

@@ -15,7 +15,5 @@
     &__body {
         display: flex;
         align-items: center;
-
-        padding: 16px 16px 0;
     }
 }

package/dist/containers/PDiskPage/PDiskPage.js

@@ -46,7 +46,12 @@ export function PDiskPage() {
     const groupsData = (_a = pDiskStorageQuery.currentData) !== null && _a !== void 0 ? _a : [];
     const handleRestart = async () => {
         if (valueIsDefined(nodeId) && valueIsDefined(pDiskId)) {
-            return window.api.restartPDisk(nodeId, pDiskId);
+            return window.api.restartPDisk(nodeId, pDiskId).then((res) => {
+                if ((res === null || res === void 0 ? void 0 : res.result) === false) {
+                    const err = { statusText: res.error };
+                    throw err;
+                }
+            });
         }
         return undefined;
     };

package/dist/containers/Tenant/Query/QueryEditor/QueryEditor.js

@@ -10,6 +10,7 @@ import { setShowPreview } from '../../../../store/reducers/schema/schema';
 import { cn } from '../../../../utils/cn';
 import { DEFAULT_IS_QUERY_RESULT_COLLAPSED, DEFAULT_SIZE_RESULT_PANE_KEY, LAST_USED_QUERY_ACTION_KEY, QUERY_USE_MULTI_SCHEMA_KEY, SAVED_QUERIES_KEY, } from '../../../../utils/constants';
 import { useQueryModes, useSetting } from '../../../../utils/hooks';
+import { LANGUAGE_YQL_ID } from '../../../../utils/monaco/yql/constants';
 import { QUERY_ACTIONS } from '../../../../utils/query';
 import { parseJson } from '../../../../utils/utils';
 import { PaneVisibilityActionTypes, paneVisibilityToggleReducerCreator, } from '../../utils/paneVisibilityToggleHelpers';
@@ -286,7 +287,7 @@ function QueryEditor(props) {
     };
     return (_jsx("div", { className: b(), children: _jsxs(SplitPane, { direction: "vertical", defaultSizePaneKey: DEFAULT_SIZE_RESULT_PANE_KEY, triggerCollapse: resultVisibilityState.triggerCollapse, triggerExpand: resultVisibilityState.triggerExpand, minSize: [0, 52], collapsedSizes: [100, 0], onSplitStartDragAdditional: onSplitStartDragAdditional, children: [_jsxs("div", { className: b('pane-wrapper', {
                         top: true,
-                    }), children: [_jsx("div", { className: b('monaco-wrapper'), children: _jsx("div", { className: b('monaco'), children: _jsx(MonacoEditor, { language: "sql", value: executeQuery.input, options: editorOptions, onChange: onChange, editorDidMount: editorDidMount, theme: `vs-${theme}` }) }) }), renderControls()] }), _jsx("div", { className: b('pane-wrapper'), children: _jsx(Result, { executeQuery: executeQuery, explainQuery: explainQuery, resultVisibilityState: resultVisibilityState, onExpandResultHandler: onExpandResultHandler, onCollapseResultHandler: onCollapseResultHandler, type: type, handleAstQuery: handleAstQuery, theme: theme, resultType: resultType, path: path, showPreview: showPreview }) })] }) }));
+                    }), children: [_jsx("div", { className: b('monaco-wrapper'), children: _jsx("div", { className: b('monaco'), children: _jsx(MonacoEditor, { language: LANGUAGE_YQL_ID, value: executeQuery.input, options: editorOptions, onChange: onChange, editorDidMount: editorDidMount, theme: `vs-${theme}` }) }) }), renderControls()] }), _jsx("div", { className: b('pane-wrapper'), children: _jsx(Result, { executeQuery: executeQuery, explainQuery: explainQuery, resultVisibilityState: resultVisibilityState, onExpandResultHandler: onExpandResultHandler, onCollapseResultHandler: onCollapseResultHandler, type: type, handleAstQuery: handleAstQuery, theme: theme, resultType: resultType, path: path, showPreview: showPreview }) })] }) }));
 }
 const mapStateToProps = (state) => {
     return {

package/dist/containers/Tenant/Query/QueryEditor/helpers.js

@@ -1,5 +1,5 @@
 import React from 'react';
-import { ENABLE_AUTOCOMPLETE, useSetting } from '../../../../lib';
+import { AUTOCOMPLETE_ON_ENTER, ENABLE_AUTOCOMPLETE, useSetting } from '../../../../lib';
 export const EDITOR_OPTIONS = {
     automaticLayout: true,
     selectOnLineNumbers: true,
@@ -9,9 +9,10 @@ export const EDITOR_OPTIONS = {
 };
 export function useEditorOptions() {
     const [enableAutocomplete] = useSetting(ENABLE_AUTOCOMPLETE);
+    const [autocompleteOnEnter] = useSetting(AUTOCOMPLETE_ON_ENTER);
     const options = React.useMemo(() => {
         const useAutocomplete = Boolean(enableAutocomplete);
-        return Object.assign({ quickSuggestions: useAutocomplete, suggestOnTriggerCharacters: useAutocomplete }, EDITOR_OPTIONS);
-    }, [enableAutocomplete]);
+        return Object.assign({ quickSuggestions: useAutocomplete, suggestOnTriggerCharacters: useAutocomplete, acceptSuggestionOnEnter: autocompleteOnEnter ? 'on' : 'off' }, EDITOR_OPTIONS);
+    }, [enableAutocomplete, autocompleteOnEnter]);
     return options;
 }

package/dist/containers/Tenant/Tenant.js

@@ -47,7 +47,7 @@ function Tenant(props) {
     React.useEffect(() => {
         if (tenantName && typeof tenantName === 'string' && previousTenant.current !== tenantName) {
             const register = async () => {
-                const { registerYQLCompletionItemProvider } = await import('../../utils/monaco/yqlSuggestions/registerCompletionItemProvider');
+                const { registerYQLCompletionItemProvider } = await import('../../utils/monaco/yql/yql.completionItemProvider');
                 registerYQLCompletionItemProvider(tenantName);
             };
             register().catch(console.error);

package/dist/containers/UserSettings/i18n/en.json

@@ -7,6 +7,8 @@
     "section.dev-setting": "Development settings",
     "settings.editor.autocomplete.title": "Enable autocomplete",
     "settings.editor.autocomplete.description": "You’re always able to get suggestions by pressing Ctrl+Space.",
+    "settings.editor.autocomplete-on-enter.title": "Accept suggestion on Enter",
+    "settings.editor.autocomplete-on-enter.description": "Controls whether suggestions should be accepted on Enter, in addition to Tab. Helps to avoid ambiguity between inserting new lines or accepting suggestions.",
     "settings.theme.title": "Interface theme",
     "settings.theme.option-dark": "Dark",
     "settings.theme.option-light": "Light",

package/dist/containers/UserSettings/i18n/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: (key: "page.general" | "section.appearance" | "page.experiments" | "section.experiments" | "page.editor" | "section.dev-setting" | "settings.editor.autocomplete.title" | "settings.editor.autocomplete.description" | "settings.theme.title" | "settings.theme.option-dark" | "settings.theme.option-light" | "settings.theme.option-system" | "settings.language.title" | "settings.language.option-russian" | "settings.language.option-english" | "settings.binaryDataInPlainTextDisplay.title" | "settings.binaryDataInPlainTextDisplay.description" | "settings.invertedDisks.title" | "settings.useNodesEndpoint.title" | "settings.useNodesEndpoint.popover" | "settings.useVirtualTables.title" | "settings.useVirtualTables.popover" | "settings.queryUseMultiSchema.title" | "settings.queryUseMultiSchema.popover", params?: import("@gravity-ui/i18n").Params | undefined) => string;
+declare const _default: (key: "page.general" | "section.appearance" | "page.experiments" | "section.experiments" | "page.editor" | "section.dev-setting" | "settings.editor.autocomplete.title" | "settings.editor.autocomplete.description" | "settings.editor.autocomplete-on-enter.title" | "settings.editor.autocomplete-on-enter.description" | "settings.theme.title" | "settings.theme.option-dark" | "settings.theme.option-light" | "settings.theme.option-system" | "settings.language.title" | "settings.language.option-russian" | "settings.language.option-english" | "settings.binaryDataInPlainTextDisplay.title" | "settings.binaryDataInPlainTextDisplay.description" | "settings.invertedDisks.title" | "settings.useNodesEndpoint.title" | "settings.useNodesEndpoint.popover" | "settings.useVirtualTables.title" | "settings.useVirtualTables.popover" | "settings.queryUseMultiSchema.title" | "settings.queryUseMultiSchema.popover", params?: import("@gravity-ui/i18n").Params | undefined) => string;
 export default _default;

package/dist/containers/UserSettings/settings.d.ts

@@ -20,6 +20,7 @@ export declare const useNodesEndpointSetting: SettingProps;
 export declare const useVirtualTables: SettingProps;
 export declare const queryUseMultiSchemaSetting: SettingProps;
 export declare const enableAutocompleteSetting: SettingProps;
+export declare const autocompleteOnEnterSetting: SettingProps;
 export declare const appearanceSection: SettingsSection;
 export declare const experimentsSection: SettingsSection;
 export declare const devSettingsSection: SettingsSection;

package/dist/containers/UserSettings/settings.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { Flask, PencilToSquare, StarFill } from '@gravity-ui/icons';
-import { BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, INVERTED_DISKS_KEY, LANGUAGE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../../utils/constants';
+import { AUTOCOMPLETE_ON_ENTER, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, INVERTED_DISKS_KEY, LANGUAGE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../../utils/constants';
 import { Lang, defaultLang } from '../../utils/i18n';
 import { ClusterModeGuard } from '../ClusterModeGuard';
 import i18n from './i18n';
@@ -73,6 +73,11 @@ export const enableAutocompleteSetting = {
     title: i18n('settings.editor.autocomplete.title'),
     description: i18n('settings.editor.autocomplete.description'),
 };
+export const autocompleteOnEnterSetting = {
+    settingKey: AUTOCOMPLETE_ON_ENTER,
+    title: i18n('settings.editor.autocomplete-on-enter.title'),
+    description: i18n('settings.editor.autocomplete-on-enter.description'),
+};
 export const appearanceSection = {
     id: 'appearanceSection',
     title: i18n('section.appearance'),
@@ -86,7 +91,7 @@ export const experimentsSection = {
 export const devSettingsSection = {
     id: 'devSettingsSection',
     title: i18n('section.dev-setting'),
-    settings: [enableAutocompleteSetting],
+    settings: [enableAutocompleteSetting, autocompleteOnEnterSetting],
 };
 export const generalPage = {
     id: 'generalPage',

package/dist/services/api.d.ts

@@ -2,6 +2,7 @@ import AxiosWrapper from '@gravity-ui/axios-wrapper';
 import type { ComputeApiRequestParams, NodesApiRequestParams } from '../store/reducers/nodes/types';
 import type { StorageApiRequestParams } from '../store/reducers/storage/types';
 import type { TMetaInfo } from '../types/api/acl';
+import type { TQueryAutocomplete } from '../types/api/autocomplete';
 import type { TClusterInfo } from '../types/api/cluster';
 import type { TComputeInfo } from '../types/api/compute';
 import type { DescribeConsumerResult } from '../types/api/consumer';
@@ -14,6 +15,7 @@ import type { TEvNodesInfo } from '../types/api/nodesList';
 import type { TEvPDiskStateResponse } from '../types/api/pdisk';
 import type { Actions, ExplainActions, ExplainResponse, QueryAPIResponse, Schemas } from '../types/api/query';
 import type { JsonRenderRequestParams, JsonRenderResponse } from '../types/api/render';
+import type { RestartPDiskResponse } from '../types/api/restartPDisk';
 import type { TEvDescribeSchemeResult } from '../types/api/schema';
 import type { TStorageInfo } from '../types/api/storage';
 import type { TEvSystemStateResponse } from '../types/api/systemState';
@@ -104,7 +106,7 @@ export declare class YdbEmbeddedAPI extends AxiosWrapper {
         failDomainIdx: string | number;
         vDiskIdx: string | number;
     }): Promise<any>;
-    restartPDisk(nodeId: number | string, pDiskId: number | string): Promise<any>;
+    restartPDisk(nodeId: number | string, pDiskId: number | string): Promise<RestartPDiskResponse>;
     killTablet(id?: string): Promise<string>;
     stopTablet(id?: string, hiveId?: string): Promise<string>;
     resumeTablet(id?: string, hiveId?: string): Promise<string>;
@@ -115,6 +117,12 @@ export declare class YdbEmbeddedAPI extends AxiosWrapper {
     authenticate(user: string, password: string): Promise<any>;
     logout(): Promise<any>;
     whoami(): Promise<TUserToken>;
+    autocomplete(params: {
+        database: string;
+        prefix?: string;
+        limit?: number;
+        table?: string[];
+    }): Promise<TQueryAutocomplete>;
     getClustersList(_?: never, { signal }?: {
         signal?: AbortSignal;
     }): Promise<MetaClusters>;

package/dist/services/api.js

@@ -302,6 +302,11 @@ export class YdbEmbeddedAPI extends AxiosWrapper {
     whoami() {
         return this.get(this.getPath('/viewer/json/whoami'), {});
     }
+    autocomplete(params) {
+        const { table } = params, rest = __rest(params, ["table"]);
+        const tablesParam = table === null || table === void 0 ? void 0 : table.join(',');
+        return this.get(this.getPath('/viewer/json/autocomplete'), Object.assign(Object.assign({}, rest), { table: tablesParam }), { concurrentId: 'sql-autocomplete' });
+    }
     // used if not single cluster mode
     getClustersList(_, { signal } = {}) {
         return this.get(`${META_BACKEND || ''}/meta/clusters`, null, {

package/dist/services/settings.js

@@ -1,5 +1,5 @@
 import { TENANT_PAGES_IDS } from '../store/reducers/tenant/constants';
-import { ASIDE_HEADER_COMPACT_KEY, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, INVERTED_DISKS_KEY, LANGUAGE_KEY, LAST_USED_QUERY_ACTION_KEY, PARTITIONS_HIDDEN_COLUMNS_KEY, QUERY_INITIAL_MODE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, SAVED_QUERIES_KEY, TENANT_INITIAL_PAGE_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_CLUSTER_BALANCER_AS_BACKEND_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../utils/constants';
+import { ASIDE_HEADER_COMPACT_KEY, AUTOCOMPLETE_ON_ENTER, BINARY_DATA_IN_PLAIN_TEXT_DISPLAY, ENABLE_AUTOCOMPLETE, INVERTED_DISKS_KEY, LANGUAGE_KEY, LAST_USED_QUERY_ACTION_KEY, PARTITIONS_HIDDEN_COLUMNS_KEY, QUERY_INITIAL_MODE_KEY, QUERY_USE_MULTI_SCHEMA_KEY, SAVED_QUERIES_KEY, TENANT_INITIAL_PAGE_KEY, THEME_KEY, USE_BACKEND_PARAMS_FOR_TABLES_KEY, USE_CLUSTER_BALANCER_AS_BACKEND_KEY, USE_NODES_ENDPOINT_IN_DIAGNOSTICS_KEY, } from '../utils/constants';
 import { QUERY_ACTIONS, QUERY_MODES } from '../utils/query';
 import { parseJson } from '../utils/utils';
 /** User settings keys and their default values */
@@ -19,6 +19,7 @@ export const DEFAULT_USER_SETTINGS = {
     [USE_BACKEND_PARAMS_FOR_TABLES_KEY]: false,
     [USE_CLUSTER_BALANCER_AS_BACKEND_KEY]: true,
     [ENABLE_AUTOCOMPLETE]: false,
+    [AUTOCOMPLETE_ON_ENTER]: true,
 };
 class SettingsManager {
     constructor() {

package/dist/types/api/autocomplete.d.ts

@@ -0,0 +1,21 @@
+/**
+ * endpoint: /viewer/json/autocomplete
+ *
+ * source: https://github.com/ydb-platform/ydb/blob/main/ydb/core/viewer/protos/viewer.proto
+ */
+export interface TQueryAutocomplete {
+    Success: boolean;
+    Error?: string[];
+    Result: TAutocompleteResult;
+}
+interface TAutocompleteResult {
+    Entities: TAutocompleteEntity[];
+    Total?: number;
+}
+export interface TAutocompleteEntity {
+    Name: string;
+    Type: AutocompleteEntityType;
+    Parent: string;
+}
+export type AutocompleteEntityType = 'unknown' | 'dir' | 'table' | 'pers_queue_group' | 'sub_domain' | 'rtmr_volume' | 'block_store_volume' | 'kesus' | 'solomon_volume' | 'table_index' | 'ext_sub_domain' | 'file_store' | 'column_store' | 'column_table' | 'cdc_stream' | 'sequence' | 'replication' | 'blob_depot' | 'external_table' | 'external_data_source' | 'view' | 'column' | 'index';
+export {};

package/dist/types/api/autocomplete.js

@@ -0,0 +1 @@
+export {};

package/dist/types/api/restartPDisk.d.ts

@@ -0,0 +1,4 @@
+export interface RestartPDiskResponse {
+    result?: boolean;
+    error?: string;
+}

package/dist/types/api/restartPDisk.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/constants.d.ts

@@ -88,3 +88,4 @@ export declare const USE_BACKEND_PARAMS_FOR_TABLES_KEY = "useBackendParamsForTab
 export declare const QUERY_USE_MULTI_SCHEMA_KEY = "queryUseMultiSchema";
 export declare const USE_CLUSTER_BALANCER_AS_BACKEND_KEY = "useClusterBalancerAsBacked";
 export declare const ENABLE_AUTOCOMPLETE = "enableAutocomplete";
+export declare const AUTOCOMPLETE_ON_ENTER = "autocompleteOnEnter";

package/dist/utils/constants.js

@@ -101,3 +101,4 @@ export const USE_BACKEND_PARAMS_FOR_TABLES_KEY = 'useBackendParamsForTables';
 export const QUERY_USE_MULTI_SCHEMA_KEY = 'queryUseMultiSchema';
 export const USE_CLUSTER_BALANCER_AS_BACKEND_KEY = 'useClusterBalancerAsBacked';
 export const ENABLE_AUTOCOMPLETE = 'enableAutocomplete';
+export const AUTOCOMPLETE_ON_ENTER = 'autocompleteOnEnter';

package/dist/utils/monaco/index.js

@@ -1,4 +1,6 @@
 import { registerSExpressionLanguage } from './s-expression/registerLanguage';
+import { registerYqlLanguage } from './yql/registerLanguage';
 export function registerLanguages() {
     registerSExpressionLanguage();
+    registerYqlLanguage();
 }

package/dist/utils/monaco/{yqlSuggestions → yql}/constants.d.ts

@@ -1,3 +1,4 @@
+export declare const LANGUAGE_YQL_ID = "yql";
 export declare const SimpleTypes: string[];
 export declare const SimpleFunctions: string[];
 export declare const AggregateFunctions: string[];

package/dist/utils/monaco/{yqlSuggestions → yql}/constants.js

@@ -1,3 +1,4 @@
+export const LANGUAGE_YQL_ID = 'yql';
 export const SimpleTypes = [
     'String',
     'Bool',

package/dist/utils/monaco/{yqlSuggestions → yql}/generateSuggestions.d.ts

@@ -1,5 +1,5 @@
-import type { ColumnAliasSuggestion, KeywordSuggestion, YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete';
-import type * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import type { ColumnAliasSuggestion, KeywordSuggestion, YQLEntity, YqlAutocompleteResult } from '@gravity-ui/websql-autocomplete';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 export declare function generateColumnsSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumns: YqlAutocompleteResult['suggestColumns'] | undefined, database: string): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateColumnAliasesSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestColumnAliases?: ColumnAliasSuggestion[]): {
     label: string;
@@ -17,7 +17,7 @@ export declare function generateKeywordsSuggestion(rangeToInsertSuggestion: mona
     range: monaco.IRange;
     sortText: string;
 }[];
-export declare function generateEntitiesSuggestion(_rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateEntitiesSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestEntities: YQLEntity[], database: string, prefix?: string): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateSimpleTypesSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
 export declare function generateUdfSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;

package/dist/utils/monaco/{yqlSuggestions → yql}/generateSuggestions.js

@@ -1,3 +1,4 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
 import { AggregateFunctions, Pragmas, SimpleFunctions, SimpleTypes, TableFunction, Udfs, WindowFunctions, } from './constants';
 const CompletionItemKind = {
     Method: 0,
@@ -30,6 +31,27 @@ const CompletionItemKind = {
     Snippet: 27,
 };
 const re = /[\s'"-/@]/;
+const suggestionEntityToAutocomplete = {
+    externalDataSource: ['external_data_source'],
+    replication: ['replication'],
+    table: ['table'],
+    tableStore: ['column_store'],
+    topic: ['pers_queue_group'],
+    view: ['view'],
+    //TODO: add after websql-autocomplete support indexex
+    // index: ['table_index', 'index'],
+};
+const commonSuggestionEntities = ['dir', 'unknown'];
+function filterAutocompleteEntities(autocompleteEntities, suggestions) {
+    const suggestionsSet = suggestions.reduce((acc, el) => {
+        const autocompleteEntity = suggestionEntityToAutocomplete[el];
+        if (autocompleteEntity) {
+            autocompleteEntity.forEach((el) => acc.add(el));
+        }
+        return acc;
+    }, new Set(commonSuggestionEntities));
+    return autocompleteEntities.filter(({ Type }) => suggestionsSet.has(Type));
+}
 function wrapStringToBackticks(value) {
     let result = value;
     if (value.match(re)) {
@@ -38,11 +60,29 @@ function wrapStringToBackticks(value) {
     return result;
 }
 function removeBackticks(value) {
-    let normalizedValue = value;
+    let sliceStart = 0;
+    let sliceEnd = value.length;
     if (value.startsWith('`')) {
-        normalizedValue = value.slice(1, -1);
+        sliceStart = 1;
+    }
+    if (value.endsWith('`')) {
+        sliceEnd = -1;
+    }
+    return value.slice(sliceStart, sliceEnd);
+}
+function removeStartSlash(value) {
+    if (value.startsWith('/')) {
+        return value.slice(1);
+    }
+    return value;
+}
+function normalizeEntityPrefix(value = '', database) {
+    let cleanedValue = removeStartSlash(removeBackticks(value));
+    const cleanedDatabase = removeStartSlash(database);
+    if (cleanedValue.startsWith(cleanedDatabase)) {
+        cleanedValue = cleanedValue.slice(cleanedDatabase.length);
     }
-    return normalizedValue;
+    return removeStartSlash(cleanedValue);
 }
 const SuggestionsWeight = {
     suggestTemplates: 0,
@@ -58,50 +98,6 @@ const SuggestionsWeight = {
     suggestUdfs: 10,
     suggestSimpleTypes: 11,
 };
-const KEEP_CACHE_MILLIS = 5 * 60 * 1000;
-function getColumnsWithCache() {
-    const cache = new Map();
-    return async (path) => {
-        var _a, _b, _c, _d;
-        const normalizedPath = removeBackticks(path);
-        const existed = cache.get(path);
-        if (existed) {
-            return existed;
-        }
-        const columns = [];
-        const data = await window.api.getDescribe({ path: normalizedPath });
-        if ((data === null || data === void 0 ? void 0 : data.Status) === 'StatusSuccess') {
-            const desc = data.PathDescription;
-            if ((_a = desc === null || desc === void 0 ? void 0 : desc.Table) === null || _a === void 0 ? void 0 : _a.Columns) {
-                for (const c of desc.Table.Columns) {
-                    if (c.Name) {
-                        columns.push(c.Name);
-                    }
-                }
-            }
-            if ((_c = (_b = desc === null || desc === void 0 ? void 0 : desc.ColumnTableDescription) === null || _b === void 0 ? void 0 : _b.Schema) === null || _c === void 0 ? void 0 : _c.Columns) {
-                for (const c of desc.ColumnTableDescription.Schema.Columns) {
-                    if (c.Name) {
-                        columns.push(c.Name);
-                    }
-                }
-            }
-            if ((_d = desc === null || desc === void 0 ? void 0 : desc.ExternalTableDescription) === null || _d === void 0 ? void 0 : _d.Columns) {
-                for (const c of desc.ExternalTableDescription.Columns) {
-                    if (c.Name) {
-                        columns.push(c.Name);
-                    }
-                }
-            }
-        }
-        cache.set(path, columns);
-        setTimeout(() => {
-            cache.delete(path);
-        }, KEEP_CACHE_MILLIS);
-        return columns;
-    };
-}
-const getColumns = getColumnsWithCache();
 function getSuggestionIndex(suggestionType) {
     return SuggestionsWeight[suggestionType];
 }
@@ -127,28 +123,63 @@ async function getSimpleTypes() {
     return SimpleTypes;
 }
 export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggestColumns, database) {
-    var _a;
+    var _a, _b, _c;
     if (!(suggestColumns === null || suggestColumns === void 0 ? void 0 : suggestColumns.tables)) {
         return [];
     }
     const suggestions = [];
     const multi = suggestColumns.tables.length > 1;
-    for (const entity of (_a = suggestColumns.tables) !== null && _a !== void 0 ? _a : []) {
+    const normalizedTableNames = (_b = (_a = suggestColumns.tables) === null || _a === void 0 ? void 0 : _a.map((entity) => {
         let normalizedEntityName = removeBackticks(entity.name);
-        // if it's relative entity path
-        if (!normalizedEntityName.startsWith('/')) {
-            normalizedEntityName = `${database}/${normalizedEntityName}`;
+        if (!normalizedEntityName.endsWith('/')) {
+            normalizedEntityName = `${normalizedEntityName}/`;
         }
-        const fields = await getColumns(normalizedEntityName);
-        fields.forEach((columnName) => {
-            const normalizedName = wrapStringToBackticks(columnName);
+        return normalizeEntityPrefix(normalizedEntityName, database);
+    })) !== null && _b !== void 0 ? _b : [];
+    // remove duplicates if any
+    const filteredTableNames = Array.from(new Set(normalizedTableNames));
+    const autocompleteResponse = await window.api.autocomplete({
+        database,
+        table: filteredTableNames,
+        limit: 1000,
+    });
+    if (!autocompleteResponse.Success) {
+        return [];
+    }
+    const tableNameToAliasMap = (_c = suggestColumns.tables) === null || _c === void 0 ? void 0 : _c.reduce((acc, entity) => {
+        var _a;
+        const normalizedEntityName = normalizeEntityPrefix(removeBackticks(entity.name), database);
+        const aliases = (_a = acc[normalizedEntityName]) !== null && _a !== void 0 ? _a : [];
+        if (entity.alias) {
+            aliases.push(entity.alias);
+        }
+        acc[normalizedEntityName] = aliases;
+        return acc;
+    }, {});
+    autocompleteResponse.Result.Entities.forEach((col) => {
+        if (col.Type !== 'column') {
+            return;
+        }
+        const normalizedName = wrapStringToBackticks(col.Name);
+        const normalizedParentName = normalizeEntityPrefix(col.Parent, database);
+        const aliases = tableNameToAliasMap[normalizedParentName];
+        if (aliases === null || aliases === void 0 ? void 0 : aliases.length) {
+            aliases.forEach((a) => {
+                const columnNameSuggestion = `${a}.${normalizedName}`;
+                suggestions.push({
+                    label: columnNameSuggestion,
+                    insertText: columnNameSuggestion,
+                    kind: CompletionItemKind.Field,
+                    detail: 'Column',
+                    range: rangeToInsertSuggestion,
+                    sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')),
+                });
+            });
+        }
+        else {
             let columnNameSuggestion = normalizedName;
-            if (entity.alias) {
-                columnNameSuggestion = `${entity.alias}.${normalizedName}`;
-            }
-            else if (multi) {
-                // no need to wrap entity.name to backticks, because it's already with them if needed
-                columnNameSuggestion = `${entity.name}.${normalizedName}`;
+            if (multi) {
+                columnNameSuggestion = `${wrapStringToBackticks(normalizedParentName)}.${normalizedName}`;
             }
             suggestions.push({
                 label: columnNameSuggestion,
@@ -158,8 +189,8 @@ export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggest
                 range: rangeToInsertSuggestion,
                 sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')),
             });
-        });
-    }
+        }
+    });
     return suggestions;
 }
 export function generateColumnAliasesSuggestion(rangeToInsertSuggestion, suggestColumnAliases) {
@@ -188,7 +219,36 @@ export function generateKeywordsSuggestion(rangeToInsertSuggestion, suggestKeywo
         sortText: suggestionIndexToWeight(getSuggestionIndex('suggestKeywords')),
     }));
 }
-export async function generateEntitiesSuggestion(_rangeToInsertSuggestion) {
+export async function generateEntitiesSuggestion(rangeToInsertSuggestion, suggestEntities, database, prefix) {
+    const normalizedPrefix = normalizeEntityPrefix(prefix, database);
+    const data = await window.api.autocomplete({ database, prefix: normalizedPrefix, limit: 1000 });
+    const withBackticks = prefix === null || prefix === void 0 ? void 0 : prefix.startsWith('`');
+    if (data.Success) {
+        const filteredEntities = filterAutocompleteEntities(data.Result.Entities, suggestEntities);
+        return filteredEntities.reduce((acc, { Name, Type }) => {
+            const isDir = Type === 'dir';
+            const label = isDir ? `${Name}/` : Name;
+            let labelAsSnippet;
+            if (isDir && !withBackticks) {
+                labelAsSnippet = `\`${label}$0\``;
+            }
+            acc.push({
+                label,
+                insertText: labelAsSnippet !== null && labelAsSnippet !== void 0 ? labelAsSnippet : label,
+                kind: isDir ? CompletionItemKind.Folder : CompletionItemKind.Text,
+                insertTextRules: labelAsSnippet
+                    ? monaco.languages.CompletionItemInsertTextRule.InsertAsSnippet
+                    : monaco.languages.CompletionItemInsertTextRule.None,
+                detail: Type,
+                range: rangeToInsertSuggestion,
+                command: label.endsWith('/')
+                    ? { id: 'editor.action.triggerSuggest', title: '' }
+                    : undefined,
+                sortText: suggestionIndexToWeight(getSuggestionIndex('suggestEntity')),
+            });
+            return acc;
+        }, []);
+    }
     return [];
 }
 export async function generateSimpleFunctionsSuggestion(rangeToInsertSuggestion) {

package/dist/utils/monaco/yql/registerLanguage.d.ts

@@ -0,0 +1 @@
+export declare function registerYqlLanguage(): void;

package/dist/utils/monaco/yql/registerLanguage.js

@@ -0,0 +1,8 @@
+import * as monaco from 'monaco-editor';
+import { LANGUAGE_YQL_ID } from './constants';
+import { conf, getLanguage } from './yql';
+export function registerYqlLanguage() {
+    monaco.languages.register({ id: LANGUAGE_YQL_ID });
+    monaco.languages.setMonarchTokensProvider(LANGUAGE_YQL_ID, getLanguage());
+    monaco.languages.setLanguageConfiguration(LANGUAGE_YQL_ID, conf);
+}

package/dist/utils/monaco/{yqlSuggestions/registerCompletionItemProvider.js → yql/yql.completionItemProvider.js}

@@ -1,4 +1,5 @@
 import * as monaco from 'monaco-editor';
+import { LANGUAGE_YQL_ID } from './constants';
 import { createProvideSuggestionsFunction } from './yqlSuggestions';
 let completionProvider;
 function disableCodeSuggestions() {
@@ -8,8 +9,8 @@ function disableCodeSuggestions() {
 }
 export function registerYQLCompletionItemProvider(database) {
     disableCodeSuggestions();
-    completionProvider = monaco.languages.registerCompletionItemProvider('sql', {
-        triggerCharacters: [' ', '\n', '', ',', '.', '`', '('],
+    completionProvider = monaco.languages.registerCompletionItemProvider(LANGUAGE_YQL_ID, {
+        triggerCharacters: [' ', '', ',', '.', '`', '(', '/'],
         provideCompletionItems: createProvideSuggestionsFunction(database),
     });
 }

package/dist/utils/monaco/yql/yql.d.ts

@@ -0,0 +1,7 @@
+import type * as monaco from 'monaco-editor';
+export declare const conf: monaco.languages.LanguageConfiguration;
+interface LanguageOptions {
+    ansi?: boolean;
+}
+export declare function getLanguage({ ansi, }?: LanguageOptions): monaco.languages.IMonarchLanguage & Record<string, unknown>;
+export {};

package/dist/utils/monaco/yql/yql.js

@@ -0,0 +1,180 @@
+import { builtinFunctions, keywords, typeKeywords } from './yql.keywords';
+export const conf = {
+    comments: {
+        lineComment: '--',
+        blockComment: ['/*', '*/'],
+    },
+    brackets: [
+        ['{', '}'],
+        ['[', ']'],
+        ['(', ')'],
+    ],
+    autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
+    ],
+    surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
+    ],
+    wordPattern: /(-?\d*\.\d\w*)|([^`~!@#%^&*()\-=+[{\]}\\|;:'",./?\s]+)/g,
+};
+export function getLanguage({ ansi = false, } = {}) {
+    return {
+        defaultToken: 'text',
+        ignoreCase: true,
+        brackets: [
+            { open: '[', close: ']', token: 'delimiter.square' },
+            { open: '(', close: ')', token: 'delimiter.parenthesis' },
+            { open: '{', close: '}', token: 'delimiter.curly' },
+        ],
+        keywords,
+        typeKeywords,
+        constants: ['true', 'false'],
+        builtinFunctions,
+        operators: [
+            '+',
+            '-',
+            '/',
+            '//',
+            '%',
+            '<@>',
+            '@>',
+            '<@',
+            '&',
+            '^',
+            '~',
+            '<',
+            '>',
+            '<=',
+            '>=',
+            '=>',
+            '==',
+            '!=',
+            '<>',
+            '=',
+        ],
+        symbols: /[=><!~?:&|+\-*/^%]+/,
+        escapes: /\\(?:[abfnrtv\\"'`]|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+        variables: /[a-zA-Z_]\w*/,
+        tokenizer: {
+            root: [
+                { include: '@whitespace' },
+                { include: '@comments' },
+                { include: '@numbers' },
+                { include: '@tablePath' },
+                { include: '@strings' },
+                // support function
+                [/(@variables)::(@variables)/, 'support.function'],
+                [/[;,.]/, 'delimiter'],
+                [/[(){}[\]]/, '@brackets'],
+                // identifiers and keywords
+                [
+                    /@?[a-zA-Z_$]\w*/,
+                    {
+                        cases: {
+                            '@keywords': 'keyword',
+                            '@typeKeywords': 'keyword.type',
+                            '@constants': 'constant.yql',
+                            '@builtinFunctions': 'constant.other.color',
+                            '[$@][a-zA-Z_]\\w*': 'variable',
+                            '@default': 'identifier',
+                        },
+                    },
+                ],
+                [
+                    /@symbols/,
+                    {
+                        cases: {
+                            '@operators': 'operator.sql',
+                            '@default': '',
+                        },
+                    },
+                ],
+            ],
+            whitespace: [[/\s+/, 'white']],
+            comments: [
+                [/--.*/, 'comment'],
+                [/\/\*/, { token: 'comment.quote', next: ansi ? '@commentAnsi' : '@comment' }],
+            ],
+            comment: [
+                [/[^*/]+/, 'comment'],
+                [/\*\//, { token: 'comment.quote', next: '@pop' }],
+                [/./, 'comment'],
+            ],
+            commentAnsi: [
+                [/\/\*/, { token: 'comment.quote', next: '@comment' }],
+                [/[^*/]+/, 'comment'],
+                [/\*\//, { token: 'comment.quote', next: '@pop' }],
+                [/./, 'comment'],
+            ],
+            numbers: [
+                [/[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?f?\b/, 'number.float'],
+                [/[+-]?(?:\d+|0b[01]+|0o[0-8]+|0x[\da-f]+)(?:u?[lst]?)?\b/, 'number'],
+            ],
+            strings: [
+                [/'/, { token: 'string', next: ansi ? '@stringAnsiSingle' : '@stringSingle' }],
+                [/"/, { token: 'string', next: ansi ? '@stringAnsiDouble' : '@stringDouble' }],
+                [/[@]{2}/, { token: 'string', next: '@multilineString' }],
+            ],
+            stringSingle: [
+                [/[^\\']+/, 'string'],
+                [/@escapes/, 'string.escape'],
+                [/\\./, 'string.escape.invalid'],
+                [/'[uyj]?/, { token: 'string', next: '@pop' }],
+            ],
+            stringAnsiSingle: [
+                [/[^']+/, 'string'],
+                [/''/, 'string'],
+                [/'[uyj]?/, { token: 'string', next: '@pop' }],
+            ],
+            stringDouble: [
+                [/[^\\"]+/, 'string'],
+                [/@escapes/, 'string.escape'],
+                [/\\./, 'string.escape.invalid'],
+                [/"[uyj]?/, { token: 'string', next: '@pop' }],
+            ],
+            stringAnsiDouble: [
+                [/[^"]+/, 'string'],
+                [/""/, 'string'],
+                [/"[uyj]?/, { token: 'string', next: '@pop' }],
+            ],
+            multilineString: [
+                [
+                    /#py/,
+                    { token: 'string.python', nextEmbedded: 'python', next: '@embedded', goBack: 3 },
+                ],
+                [
+                    /\/\/js/,
+                    { token: 'string.js', nextEmbedded: 'javascript', next: '@embedded', goBack: 4 },
+                ],
+                [/[^@]+/, 'string'],
+                [/[@]{4}/, 'string'],
+                [/[@]{2}[uyj]?/, { token: 'string', next: '@pop' }],
+                [/./, 'string'],
+            ],
+            embedded: [
+                [
+                    /([^@]|^)([@]{4})*[@]{2}([@]([^@]|$)|[^@]|$)/,
+                    { token: '@rematch', next: '@pop', nextEmbedded: '@pop' },
+                ],
+            ],
+            tablePath: [[/((`)?[\w/]+\2\s*\.\s*)?`/, { token: 'string.tablepath', next: '@table' }]],
+            table: [
+                [/[^\\`]+/, 'string.tablepath'],
+                [/``/, 'string.tablepath'],
+                [/@escapes/, 'string.escape.tablepath'],
+                [/\\./, 'string.escape.invalid.tablepath'],
+                [/`/, { token: 'string.tablepath', next: '@pop' }],
+            ],
+        },
+    };
+}

package/dist/utils/monaco/yql/yql.keywords.d.ts

@@ -0,0 +1,3 @@
+export declare const keywords: string[];
+export declare const typeKeywords: string[];
+export declare const builtinFunctions: string[];

package/dist/utils/monaco/yql/yql.keywords.js

@@ -0,0 +1,3 @@
+export const keywords = '$row|$rows|action|all|and|any|as|asc|assume|begin|bernoulli|between|by|case|columns|commit|compact|create|cross|cube|declare|define|delete|desc|dict|discard|distinct|do|drop|else|empty_action|end|erase|evaluate|exclusion|exists|export|flatten|for|from|full|group|grouping|having|if|ignore|ilike|import|in|inner|insert|into|is|join|left|like|limit|list|match|not|null|nulls|offset|on|only|optional|or|order|over|partition|pragma|presort|process|reduce|regexp|repeatable|replace|respect|result|return|right|rlike|rollup|sample|schema|select|semi|set|sets|stream|subquery|table|tablesample|then|truncate|union|update|upsert|use|using|values|view|when|where|window|with|without|xor'.split('|');
+export const typeKeywords = 'bool|date|datetime|decimal|double|float|int16|int32|int64|int8|interval|json|string|timestamp|tzdate|tzdatetime|tztimestamp|uint16|uint32|uint64|uint8|utf8|uuid|yson'.split('|');
+export const builtinFunctions = 'abs|aggregate_by|aggregate_list|aggregate_list_distinct|agg_list|agg_list_distinct|as_table|avg|avg_if|adaptivedistancehistogram|adaptivewardhistogram|adaptiveweighthistogram|addmember|addtimezone|aggregateflatten|aggregatetransforminput|aggregatetransformoutput|aggregationfactory|asatom|asdict|asdictstrict|asenum|aslist|asliststrict|asset|assetstrict|asstruct|astagged|astuple|asvariant|atomcode|bitcast|bit_and|bit_or|bit_xor|bool_and|bool_or|bool_xor|bottom|bottom_by|blockwardhistogram|blockweighthistogram|cast|coalesce|concat|concat_strict|correlation|count|count_if|covariance|covariance_population|covariance_sample|callableargument|callableargumenttype|callableresulttype|callabletype|callabletypecomponents|callabletypehandle|choosemembers|combinemembers|countdistinctestimate|currentauthenticateduser|currentoperationid|currentoperationsharedid|currenttzdate|currenttzdatetime|currenttztimestamp|currentutcdate|currentutcdatetime|currentutctimestamp|dense_rank|datatype|datatypecomponents|datatypehandle|dictaggregate|dictcontains|dictcreate|dicthasitems|dictitems|dictkeytype|dictkeys|dictlength|dictlookup|dictpayloadtype|dictpayloads|dicttype|dicttypecomponents|dicttypehandle|each|each_strict|emptydicttype|emptydicttypehandle|emptylisttype|emptylisttypehandle|endswith|ensure|ensureconvertibleto|ensuretype|enum|evaluateatom|evaluatecode|evaluateexpr|evaluatetype|expandstruct|filter|filter_strict|find|first_value|folder|filecontent|filepath|flattenmembers|forceremovemember|forceremovemembers|forcerenamemembers|forcespreadmembers|formatcode|formattype|frombytes|funccode|greatest|grouping|gathermembers|generictype|histogram|hll|hyperloglog|if|if_strict|instanceof|json_exists|json_query|json_value|jointablerow|just|lag|last_value|lead|least|len|length|like|likely|like_strict|lambdaargumentscount|lambdacode|linearhistogram|listaggregate|listall|listany|listavg|listcode|listcollect|listconcat|listcreate|listdistinct|listenumerate|listextend|listextendstrict|listextract|listfilter|listflatmap|listflatten|listfromrange|listhas|listhasitems|listhead|listindexof|listitemtype|listlast|listlength|listmap|listmax|listmin|listnotnull|listreplicate|listreverse|listskip|listskipwhile|listskipwhileinclusive|listsort|listsortasc|listsortdesc|listsum|listtake|listtakewhile|listtakewhileinclusive|listtype|listtypehandle|listunionall|listuniq|listzip|listzipall|loghistogram|logarithmichistogram|max|max_by|max_of|median|min|min_by|min_of|mode|multi_aggregate_by|nanvl|nvl|nothing|nulltype|nulltypehandle|optionalitemtype|optionaltype|optionaltypehandle|percentile|parsefile|parsetype|parsetypehandle|pickle|quotecode|range|range_strict|rank|regexp|regexp_strict|rfind|row_number|random|randomnumber|randomuuid|removemember|removemembers|removetimezone|renamemembers|replacemember|reprcode|resourcetype|resourcetypehandle|resourcetypetag|some|stddev|stddev_population|stddev_sample|substring|sum|sum_if|sessionstart|sessionwindow|setcreate|setdifference|setincludes|setintersection|setisdisjoint|setsymmetricdifference|setunion|spreadmembers|stablepickle|startswith|staticmap|streamitemtype|streamtype|streamtypehandle|structmembertype|structmembers|structtypecomponents|structtypehandle|subqueryextend|subqueryextendfor|subquerymerge|subquerymergefor|subqueryunionall|subqueryunionallfor|subqueryunionmerge|subqueryunionmergefor|top|topfreq|top_by|tablename|tablepath|tablerecordindex|tablerow|taggedtype|taggedtypecomponents|taggedtypehandle|tobytes|todict|tomultidict|toset|tosorteddict|tosortedmultidict|trymember|tupleelementtype|tupletype|tupletypecomponents|tupletypehandle|typehandle|typekind|typeof|udaf|unittype|unpickle|untag|unwrap|variance|variance_population|variance_sample|variant|varianttype|varianttypehandle|variantunderlyingtype|voidtype|voidtypehandle|way|worldcode'.split('|');

package/dist/utils/monaco/{yqlSuggestions → yql}/yqlSuggestions.js

@@ -1,18 +1,24 @@
 import { generateAggregateFunctionsSuggestion, generateColumnAliasesSuggestion, generateColumnsSuggestion, generateEntitiesSuggestion, generateKeywordsSuggestion, generatePragmasSuggestion, generateSimpleFunctionsSuggestion, generateSimpleTypesSuggestion, generateTableFunctionsSuggestion, generateUdfSuggestion, generateWindowFunctionsSuggestion, } from './generateSuggestions';
 export function createProvideSuggestionsFunction(database) {
     return async (model, monacoCursorPosition, _context, _token) => {
-        const cursorPosition = {
-            line: monacoCursorPosition.lineNumber,
-            column: monacoCursorPosition.column,
-        };
         const rangeToInsertSuggestion = getRangeToInsertSuggestion(model, monacoCursorPosition);
-        const suggestions = await getSuggestions(model, cursorPosition, rangeToInsertSuggestion, database);
+        const suggestions = await getSuggestions(model, monacoCursorPosition, rangeToInsertSuggestion, database);
         return { suggestions };
     };
 }
+function getEntityNameAtCursor(model, cursorPosition) {
+    var _a, _b, _c, _d;
+    const prevWord = model.findPreviousMatch('\\s(`?[^\\s]*)', cursorPosition, true, false, null, true);
+    const nextWord = model.findNextMatch('([^\\s]*)`?', cursorPosition, true, false, null, true);
+    return `${(_b = (_a = prevWord === null || prevWord === void 0 ? void 0 : prevWord.matches) === null || _a === void 0 ? void 0 : _a[1]) !== null && _b !== void 0 ? _b : ''}${(_d = (_c = nextWord === null || nextWord === void 0 ? void 0 : nextWord.matches) === null || _c === void 0 ? void 0 : _c[1]) !== null && _d !== void 0 ? _d : ''}`;
+}
 async function getSuggestions(model, cursorPosition, rangeToInsertSuggestion, database) {
     const { parseYqlQuery } = await import('@gravity-ui/websql-autocomplete');
-    const parseResult = parseYqlQuery(model.getValue(), cursorPosition);
+    const cursorForParsing = {
+        line: cursorPosition.lineNumber,
+        column: cursorPosition.column,
+    };
+    const parseResult = parseYqlQuery(model.getValue(), cursorForParsing);
     let entitiesSuggestions = [];
     let functionsSuggestions = [];
     let aggregateFunctionsSuggestions = [];
@@ -22,7 +28,8 @@ async function getSuggestions(model, cursorPosition, rangeToInsertSuggestion, da
     let simpleTypesSuggestions = [];
     let pragmasSuggestions = [];
     if (parseResult.suggestEntity) {
-        entitiesSuggestions = await generateEntitiesSuggestion(rangeToInsertSuggestion);
+        const entityNamePrefix = getEntityNameAtCursor(model, cursorPosition);
+        entitiesSuggestions = await generateEntitiesSuggestion(rangeToInsertSuggestion, parseResult.suggestEntity, database, entityNamePrefix);
     }
     if (parseResult.suggestFunctions) {
         functionsSuggestions = await generateSimpleFunctionsSuggestion(rangeToInsertSuggestion);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-embedded-ui",
-  "version": "6.0.1",
+  "version": "6.1.0",
   "files": [
     "dist"
   ],
@@ -21,7 +21,7 @@
     "@gravity-ui/paranoid": "^1.4.1",
     "@gravity-ui/react-data-table": "^2.0.1",
     "@gravity-ui/uikit": "^6.10.2",
-    "@gravity-ui/websql-autocomplete": "^8.0.2",
+    "@gravity-ui/websql-autocomplete": "^8.1.0",
     "@reduxjs/toolkit": "^2.2.3",
     "axios": "^1.6.8",
     "colord": "^2.9.3",
@@ -70,7 +70,7 @@
     "prepublishOnly": "npm run package",
     "typecheck": "tsc --noEmit",
     "prepare": "husky",
-    "test:e2e:install": "npx playwright install --with-deps chromium",
+    "test:e2e:install": "npx playwright install --with-deps",
     "test:e2e": "npx playwright test --config=playwright.config.ts"
   },
   "lint-staged": {