feat: move autocomplete logic to library

Raubzeug · Raubzeug · commit 12ba299193b3 · 2025-02-04T17:28:05.000+03:00
diff --git a/src/utils/monaco/yql/autocomplete/generateSuggestions.ts b/src/utils/monaco/yql/autocomplete/generateSuggestions.ts
@@ -10,6 +10,8 @@ import type {FetchedColumn, FetchedEntity} from './types';
 import {
     getSuggestionIndex,
     isVariable,
+    removeBackticks,
+    removeStringDuplicates,
     suggestionIndexToWeight,
     wrapStringToBackticks,
 } from './utils';
@@ -31,7 +33,7 @@ export async function generateSimpleTypesSuggestion(
 export async function generateEntitiesSuggestion(
     rangeToInsertSuggestion: monaco.IRange,
     fetchedEntities: FetchedEntity[],
-    prefix: string,
+    prefix = '',
 ): Promise<monaco.languages.CompletionItem[]> {
     const withBackticks = prefix?.startsWith('`');
 
@@ -70,11 +72,8 @@ export async function generateEntitiesSuggestion(
 
 export function generateKeywordsSuggestion(
     rangeToInsertSuggestion: monaco.IRange,
-    suggestKeywords?: KeywordSuggestion[],
+    suggestKeywords: KeywordSuggestion[] = [],
 ) {
-    if (!suggestKeywords) {
-        return [];
-    }
     return suggestKeywords.map((keywordSuggestion) => ({
         label: keywordSuggestion.value,
         insertText: keywordSuggestion.value,
@@ -87,11 +86,8 @@ export function generateKeywordsSuggestion(
 
 export function generateVariableSuggestion(
     rangeToInsertSuggestion: monaco.IRange,
-    suggestVariables?: VariableSuggestion[],
+    suggestVariables: VariableSuggestion[] = [],
 ) {
-    if (!suggestVariables) {
-        return [];
-    }
     return suggestVariables.map(({name}) => {
         const variable = '$' + name;
         return {
@@ -231,7 +227,7 @@ export async function generateColumnsSuggestion(
     const multi = suggestColumns.tables.length > 1;
 
     const tableNames = suggestColumns.tables.map((entity) => entity.name);
-    const filteredTableNames = Array.from(new Set(tableNames));
+    const filteredTableNames = removeStringDuplicates(tableNames);
 
     const variableSources = filteredTableNames.filter(isVariable);
 
@@ -268,7 +264,7 @@ export async function generateColumnsSuggestion(
 
     const tableNameToAliasMap = suggestColumns.tables?.reduce(
         (acc, entity) => {
-            const name = entity.name;
+            const name = removeBackticks(entity.name);
             const aliases = acc[name] ?? [];
             if (entity.alias) {
                 aliases.push(entity.alias);
@@ -282,7 +278,7 @@ export async function generateColumnsSuggestion(
     [...fetchedColumns, ...columnsFromVariable, ...predefinedColumns].forEach((col) => {
         const normalizedName = wrapStringToBackticks(col.name);
 
-        const aliases = tableNameToAliasMap[col.parent];
+        const aliases = tableNameToAliasMap[removeBackticks(col.parent)];
         const currentSuggestionIndex = suggestions.length;
         if (aliases?.length) {
             aliases.forEach((a) => {
diff --git a/src/utils/monaco/yql/autocomplete/types.ts b/src/utils/monaco/yql/autocomplete/types.ts
@@ -6,8 +6,7 @@ export type AutocompleteEntityType = YQLEntity | 'directory';
 
 export type FetchedEntity = {
     value: string;
-    autocompleteType?: AutocompleteEntityType;
-    isDir?: boolean;
+    isDir: boolean;
     detail?: string;
 };
 
diff --git a/src/utils/monaco/yql/autocomplete/utils.ts b/src/utils/monaco/yql/autocomplete/utils.ts
@@ -48,19 +48,38 @@ export function isVariable(value: string) {
     return value.startsWith('$');
 }
 
+export function removeStringDuplicates(value: string[] = []) {
+    return Array.from(new Set(value));
+}
+
 export function getEntitiesToFetchColumns(suggestColumns: YqlAutocompleteResult['suggestColumns']) {
     const names = suggestColumns?.tables?.map((entity) => entity.name);
     // remove duplicates if any
-    const filteredTableNames = Array.from(new Set(names));
+    const filteredTableNames = removeStringDuplicates(names);
     return filteredTableNames.filter((name) => !isVariable(name));
 }
 
 const specialSymbols = /[\s'"-/@]/;
 
 export function wrapStringToBackticks(value: string) {
+    if (value.startsWith('`') && value.endsWith('`')) {
+        return value;
+    }
     let result = value;
     if (value.match(specialSymbols)) {
         result = `\`${value}\``;
     }
     return result;
 }
+
+export function removeBackticks(value: string) {
+    let sliceStart = 0;
+    let sliceEnd = value.length;
+    if (value.startsWith('`')) {
+        sliceStart = 1;
+    }
+    if (value.endsWith('`')) {
+        sliceEnd = -1;
+    }
+    return value.slice(sliceStart, sliceEnd);
+}
diff --git a/src/utils/monaco/yql/autocomplete/yqlAutocomplete.ts b/src/utils/monaco/yql/autocomplete/yqlAutocomplete.ts
@@ -1,5 +1,5 @@
 import type {CursorPosition as BaseCursorPosition} from '@gravity-ui/websql-autocomplete/shared';
-import type {YQLEntity, YqlAutocompleteResult} from '@gravity-ui/websql-autocomplete/yql';
+import type {YQLEntity} from '@gravity-ui/websql-autocomplete/yql';
 import type Monaco from 'monaco-editor';
 
 import {
@@ -27,8 +27,6 @@ import type {
 } from './types';
 import {getEntitiesToFetchColumns} from './utils';
 
-const prefixRegexp = /([^\s]+)$/;
-
 function getCursorPosition(input: string, offset: number): CursorPosition {
     const lines = input.slice(0, offset).split('\n');
     // parser suggest to get cursor position where lineNumber and column starts from 1
@@ -38,19 +36,23 @@ function getCursorPosition(input: string, offset: number): CursorPosition {
     };
 }
 
-function getCursorPrefix(input: string, offset: number) {
+const prefixRegexp = /([^\s]+)$/;
+
+function getCursorPrefix(input: string, offset: number, re = prefixRegexp) {
     const prevText = input.slice(0, offset);
 
-    const match = prevText.match(prefixRegexp);
+    const match = prevText.match(re);
     if (match && match[1]) {
         return match[1];
     }
     return '';
 }
 
+const prefixToReplaceRegexp = /([^\\/\s`]+)$/;
+
 function getRangeToInsertSuggestion(input: string, offset: number) {
     const cursorPosition = getCursorPosition(input, offset);
-    const cursorPrefix = getCursorPrefix(input, offset);
+    const cursorPrefix = getCursorPrefix(input, offset, prefixToReplaceRegexp);
     return {
         startColumn: cursorPosition.column - cursorPrefix.length,
         startLineNumber: cursorPosition.lineNumber,
@@ -59,6 +61,12 @@ function getRangeToInsertSuggestion(input: string, offset: number) {
     };
 }
 
+/**
+ * YQLAutocomplete class provides autocompletion suggestions for YQL queries.
+ * It uses a set of constants to generate suggestions for various YQL elements.
+ * The class is abstract and needs to be extended to provide implementation for
+ * fetching entities and columns.
+ */
 export abstract class YQLAutocomplete {
     private readonly constants: AutocompleteConstants = {};
 
@@ -82,21 +90,8 @@ export abstract class YQLAutocomplete {
         });
     }
 
-    removeBackticks(value: string) {
-        let sliceStart = 0;
-        let sliceEnd = value.length;
-        if (value.startsWith('`')) {
-            sliceStart = 1;
-        }
-        if (value.endsWith('`')) {
-            sliceEnd = -1;
-        }
-        return value.slice(sliceStart, sliceEnd);
-    }
-
     async getSuggestions(input: string, offset: number) {
         const parseResult = await this.parseInput(input, offset);
-
         let entitiesSuggestions: Monaco.languages.CompletionItem[] = [];
         let functionsSuggestions: Monaco.languages.CompletionItem[] = [];
         let aggregateFunctionsSuggestions: Monaco.languages.CompletionItem[] = [];
@@ -111,23 +106,24 @@ export abstract class YQLAutocomplete {
 
         const rangeToInsertSuggestion = getRangeToInsertSuggestion(input, offset);
 
+        const cursorPrefix = getCursorPrefix(input, offset);
+
         if (parseResult.suggestSimpleTypes) {
+            const simpleTypes = await this.getSimpleTypes(cursorPrefix);
             simpleTypesSuggestions = await generateSimpleTypesSuggestion(
                 rangeToInsertSuggestion,
-                this.constants.types,
+                simpleTypes,
             );
         }
         if (parseResult.suggestEntity) {
-            const entityNamePrefix = getCursorPrefix(input, offset);
-
             const fetchedEntities = await this.fetchEntities(
-                entityNamePrefix,
+                cursorPrefix,
                 parseResult.suggestEntity,
             );
             entitiesSuggestions = await generateEntitiesSuggestion(
                 rangeToInsertSuggestion,
                 fetchedEntities,
-                entityNamePrefix,
+                cursorPrefix,
             );
         }
         if (parseResult.suggestVariables) {
@@ -138,41 +134,41 @@ export abstract class YQLAutocomplete {
         }
 
         if (parseResult.suggestFunctions) {
+            const simpleFunctions = await this.getSimpleFunctions(cursorPrefix);
             functionsSuggestions = await generateSimpleFunctionsSuggestion(
                 rangeToInsertSuggestion,
-                this.constants.simpleFunctions,
+                simpleFunctions,
             );
         }
         if (parseResult.suggestAggregateFunctions) {
+            const aggregateFunctions = await this.getAggregateFunctions(cursorPrefix);
             aggregateFunctionsSuggestions = await generateAggregateFunctionsSuggestion(
                 rangeToInsertSuggestion,
-                this.constants.aggregateFunctions,
+                aggregateFunctions,
             );
         }
         if (parseResult.suggestWindowFunctions) {
+            const windowFunctions = await this.getWindowFunctions(cursorPrefix);
             windowFunctionsSuggestions = await generateWindowFunctionsSuggestion(
                 rangeToInsertSuggestion,
-                this.constants.windowFunctions,
+                windowFunctions,
             );
         }
         if (parseResult.suggestTableFunctions) {
+            const tableFunctions = await this.getTableFunctions(cursorPrefix);
             tableFunctionsSuggestions = await generateTableFunctionsSuggestion(
                 rangeToInsertSuggestion,
-                this.constants.tableFunctions,
+                tableFunctions,
             );
         }
 
         if (parseResult.suggestUdfs) {
-            udfsSuggestions = await generateUdfSuggestion(
-                rangeToInsertSuggestion,
-                this.constants.udfs,
-            );
+            const udfs = await this.getUdfs(cursorPrefix);
+            udfsSuggestions = await generateUdfSuggestion(rangeToInsertSuggestion, udfs);
         }
         if (parseResult.suggestPragmas) {
-            pragmasSuggestions = await generatePragmasSuggestion(
-                rangeToInsertSuggestion,
-                this.constants.pragmas,
-            );
+            const pragmas = await this.getPragmas(cursorPrefix);
+            pragmasSuggestions = await generatePragmasSuggestion(rangeToInsertSuggestion, pragmas);
         }
         if (parseResult.suggestEntitySettings) {
             const entitySettings = await this.getEntitySettings(parseResult.suggestEntitySettings);
@@ -193,19 +189,12 @@ export abstract class YQLAutocomplete {
         );
 
         if (parseResult.suggestColumns) {
-            const normalizedSuggestions: YqlAutocompleteResult['suggestColumns'] = {
-                ...parseResult.suggestColumns,
-                tables: parseResult.suggestColumns.tables?.map((table) => ({
-                    ...table,
-                    name: this.normalizeTableName(table.name),
-                })),
-            };
-            const entities = getEntitiesToFetchColumns(normalizedSuggestions);
+            const entities = getEntitiesToFetchColumns(parseResult.suggestColumns);
             const fetchedColumns = await this.fetchEntityColumns(entities);
 
             columnsSuggestions = await generateColumnsSuggestion(
                 rangeToInsertSuggestion,
-                normalizedSuggestions,
+                parseResult.suggestColumns,
                 parseResult.suggestVariables,
                 fetchedColumns,
             );
@@ -233,24 +222,65 @@ export abstract class YQLAutocomplete {
     async parseInput(input: string, offset: number) {
         const cursorPosition = getCursorPosition(input, offset);
 
-        const {parseYqlQuery} = await import('@gravity-ui/websql-autocomplete/yql');
+        const parseQuery = await this.getQueryParser();
         const cursorForParsing: BaseCursorPosition = {
             line: cursorPosition.lineNumber,
             column: cursorPosition.column,
         };
-        return parseYqlQuery(input, cursorForParsing);
+        return parseQuery(input, cursorForParsing);
     }
 
-    abstract getEntitySettings(entityType: YQLEntity): string[] | Promise<string[]>;
+    async getQueryParser() {
+        const {parseYqlQuery: parseQuery} = await import('@gravity-ui/websql-autocomplete/yql');
+        return parseQuery;
+    }
+
+    async getSimpleTypes(_prefix?: string) {
+        return this.constants.types;
+    }
+
+    async getUdfs(_prefix?: string) {
+        return this.constants.udfs;
+    }
+
+    async getPragmas(_prefix?: string) {
+        return this.constants.pragmas;
+    }
+    async getWindowFunctions(_prefix?: string) {
+        return this.constants.windowFunctions;
+    }
 
+    async getTableFunctions(_prefix?: string) {
+        return this.constants.tableFunctions;
+    }
+    async getAggregateFunctions(_prefix?: string) {
+        return this.constants.aggregateFunctions;
+    }
+
+    async getSimpleFunctions(_prefix?: string) {
+        return this.constants.simpleFunctions;
+    }
+
+    /**
+     * Fetches entity settings based on provided entity type.
+     * @param entityType
+     * @returns  A promise that resolves to an array of entity settings.
+     */
+    abstract getEntitySettings(entityType: YQLEntity): Promise<string[]>;
+    /**
+     * Fetches entities based on the provided prefix and needed entity types.
+     * @param prefix - The prefix to filter entities.
+     * @param neededEntityTypes - An array of entity types to fetch.
+     * @returns A promise that resolves to an array of fetched entities.
+     */
     abstract fetchEntities(
         prefix: string,
         neededEntityTypes: YQLEntity[],
     ): Promise<FetchedEntity[]>;
-
+    /**
+     * Fetches columns for the specified entities.
+     * @param entityNames - An array of entity names to fetch columns for.
+     * @returns A promise that resolves to an array of fetched columns.
+     */
     abstract fetchEntityColumns(entityNames: string[]): Promise<FetchedColumn[]>;
-
-    normalizeTableName(value: string) {
-        return this.removeBackticks(value);
-    }
 }
diff --git a/src/utils/monaco/yql/generateSuggestions.ts b/src/utils/monaco/yql/generateSuggestions.ts
diff --git a/src/utils/monaco/yql/yqlSuggestions.ts b/src/utils/monaco/yql/yqlSuggestions.ts
