fix: simplify interface

Raubzeug · Raubzeug · commit be7fc5d97dbf · 2025-02-06T17:32:37.000+03:00
diff --git a/src/utils/monaco/yql/autocomplete/registerProvider.ts b/src/utils/monaco/yql/autocomplete/registerProvider.ts
@@ -0,0 +1,26 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+
+import {getSuggestionsGetter} from './yqlAutocomplete';
+import type {YQLAutocompleteConfig} from './yqlAutocomplete';
+
+const completionProvider = new Map<string, monaco.IDisposable>();
+
+function disableCodeSuggestions(langId: string): void {
+    const provider = completionProvider.get(langId);
+    if (provider) {
+        provider.dispose();
+    }
+}
+
+export function registerCompletionItemProvider(
+    langId: string,
+    triggerCharacters: string[],
+    config: YQLAutocompleteConfig,
+) {
+    disableCodeSuggestions(langId);
+    const provider = monaco.languages.registerCompletionItemProvider(langId, {
+        triggerCharacters: triggerCharacters,
+        provideCompletionItems: getSuggestionsGetter(config),
+    });
+    completionProvider.set(langId, provider);
+}
diff --git a/src/utils/monaco/yql/autocomplete/types.ts b/src/utils/monaco/yql/autocomplete/types.ts
@@ -11,19 +11,3 @@ export type FetchedEntity = {
 };
 
 export type FetchedColumn = {name: string; detail?: string; parent: string};
-
-type ConstantsGetter = () => string[] | Promise<string[]>;
-
-export type AutocompleteConstant =
-    | 'types'
-    | 'windowFunctions'
-    | 'udfs'
-    | 'pragmas'
-    | 'simpleFunctions'
-    | 'tableFunctions'
-    | 'aggregateFunctions';
-
-export type AutocompleteConstantsInit = Partial<
-    Record<AutocompleteConstant, string[] | ConstantsGetter>
->;
-export type AutocompleteConstants = Partial<Record<AutocompleteConstant, string[]>>;
diff --git a/src/utils/monaco/yql/autocomplete/yqlAutocomplete.ts b/src/utils/monaco/yql/autocomplete/yqlAutocomplete.ts
@@ -17,14 +17,7 @@ import {
     generateVariableSuggestion,
     generateWindowFunctionsSuggestion,
 } from './generateSuggestions';
-import type {
-    AutocompleteConstant,
-    AutocompleteConstants,
-    AutocompleteConstantsInit,
-    CursorPosition,
-    FetchedColumn,
-    FetchedEntity,
-} from './types';
+import type {CursorPosition, FetchedColumn, FetchedEntity} from './types';
 import {getEntitiesToFetchColumns} from './utils';
 
 function getCursorPosition(input: string, offset: number): CursorPosition {
@@ -61,33 +54,67 @@ 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 = {};
-
-    async init(constants: AutocompleteConstantsInit) {
-        const constantsArray = Object.keys(constants) as AutocompleteConstant[];
-        const promises: (string[] | Promise<string[]>)[] = [];
-        constantsArray.forEach((c) => {
-            const value = constants[c];
-            if (typeof value === 'function') {
-                promises.push(value());
-            } else if (value) {
-                promises.push(value);
-            }
-        });
-        const result = await Promise.allSettled(promises);
-        result.forEach((item, index) => {
-            if (item.status === 'fulfilled') {
-                const constantName = constantsArray[index];
-                this.constants[constantName] = item.value;
-            }
-        });
+export type YQLAutocompleteConfig = {
+    getQueryParser?: YQLAutocomplete['getQueryParser'];
+    getUdfs?: YQLAutocomplete['getUdfs'];
+    getSimpleTypes?: YQLAutocomplete['getSimpleTypes'];
+    getPragmas?: YQLAutocomplete['getPragmas'];
+    getWindowFunctions?: YQLAutocomplete['getWindowFunctions'];
+    getTableFunctions?: YQLAutocomplete['getTableFunctions'];
+    getAggregateFunctions?: YQLAutocomplete['getAggregateFunctions'];
+    getSimpleFunctions?: YQLAutocomplete['getSimpleFunctions'];
+    getEntitySettings?: YQLAutocomplete['getEntitySettings'];
+    fetchEntities?: YQLAutocomplete['fetchEntities'];
+    fetchEntityColumns?: YQLAutocomplete['fetchEntityColumns'];
+};
+
+export class YQLAutocomplete {
+    constructor({
+        getQueryParser,
+        getUdfs,
+        getSimpleTypes,
+        getPragmas,
+        getWindowFunctions,
+        getTableFunctions,
+        getAggregateFunctions,
+        getSimpleFunctions,
+        getEntitySettings,
+        fetchEntities,
+        fetchEntityColumns,
+    }: YQLAutocompleteConfig) {
+        if (getQueryParser) {
+            this.getQueryParser = getQueryParser;
+        }
+        if (getUdfs) {
+            this.getUdfs = getUdfs;
+        }
+        if (getSimpleTypes) {
+            this.getSimpleTypes = getSimpleTypes;
+        }
+        if (getPragmas) {
+            this.getPragmas = getPragmas;
+        }
+        if (getWindowFunctions) {
+            this.getWindowFunctions = getWindowFunctions;
+        }
+        if (getTableFunctions) {
+            this.getTableFunctions = getTableFunctions;
+        }
+        if (getAggregateFunctions) {
+            this.getAggregateFunctions = getAggregateFunctions;
+        }
+        if (getSimpleFunctions) {
+            this.getSimpleFunctions = getSimpleFunctions;
+        }
+        if (getEntitySettings) {
+            this.getEntitySettings = getEntitySettings;
+        }
+        if (fetchEntities) {
+            this.fetchEntities = fetchEntities;
+        }
+        if (fetchEntityColumns) {
+            this.fetchEntityColumns = fetchEntityColumns;
+        }
     }
 
     async getSuggestions(input: string, offset: number) {
@@ -235,52 +262,75 @@ export abstract class YQLAutocomplete {
         return parseQuery;
     }
 
-    async getSimpleTypes(_prefix?: string) {
-        return this.constants.types;
+    async getSimpleTypes(_prefix?: string): Promise<string[]> {
+        return [];
     }
 
-    async getUdfs(_prefix?: string) {
-        return this.constants.udfs;
+    async getUdfs(_prefix?: string): Promise<string[]> {
+        return [];
     }
 
-    async getPragmas(_prefix?: string) {
-        return this.constants.pragmas;
+    async getPragmas(_prefix?: string): Promise<string[]> {
+        return [];
     }
-    async getWindowFunctions(_prefix?: string) {
-        return this.constants.windowFunctions;
+    async getWindowFunctions(_prefix?: string): Promise<string[]> {
+        return [];
     }
 
-    async getTableFunctions(_prefix?: string) {
-        return this.constants.tableFunctions;
+    async getTableFunctions(_prefix?: string): Promise<string[]> {
+        return [];
     }
-    async getAggregateFunctions(_prefix?: string) {
-        return this.constants.aggregateFunctions;
+    async getAggregateFunctions(_prefix?: string): Promise<string[]> {
+        return [];
     }
 
-    async getSimpleFunctions(_prefix?: string) {
-        return this.constants.simpleFunctions;
+    async getSimpleFunctions(_prefix?: string): Promise<string[]> {
+        return [];
     }
 
     /**
      * 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[]>;
+    async getEntitySettings(_entityType: YQLEntity): Promise<string[]> {
+        return [];
+    }
     /**
      * 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[]>;
+    async fetchEntities(
+        _prefix: string,
+        _neededEntityTypes: YQLEntity[],
+    ): Promise<FetchedEntity[]> {
+        return [];
+    }
     /**
      * 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[]>;
+    async fetchEntityColumns(_entityNames: string[]): Promise<FetchedColumn[]> {
+        return [];
+    }
+}
+
+export function getSuggestionsGetter(config: YQLAutocompleteConfig = {}) {
+    const autocompleteInstance = new YQLAutocomplete(config);
+    return async (
+        model: Monaco.editor.ITextModel,
+        monacoCursorPosition: Monaco.Position,
+        _context: Monaco.languages.CompletionContext,
+        _token: Monaco.CancellationToken,
+    ) => {
+        const suggestions = await autocompleteInstance.getSuggestions(
+            model.getValue(),
+            model.getOffsetAt(monacoCursorPosition),
+        );
+
+        return {suggestions};
+    };
 }
diff --git a/src/utils/monaco/yql/yql.completionItemProvider.ts b/src/utils/monaco/yql/yql.completionItemProvider.ts
@@ -1,20 +1,81 @@
-import * as monaco from 'monaco-editor';
+import type {YQLEntity} from '@gravity-ui/websql-autocomplete/yql';
 import {LANGUAGE_ID} from 'monaco-yql-languages/build/yql/yql.contribution';
 
-import {createProvideSuggestionsFunction} from './yqlSuggestions';
+import {isAutocompleteColumn} from '../../../types/api/autocomplete';
+import type {TAutocompleteEntity} from '../../../types/api/autocomplete';
 
-let completionProvider: monaco.IDisposable | undefined;
-
-function disableCodeSuggestions(): void {
-    if (completionProvider) {
-        completionProvider.dispose();
-    }
-}
+import {registerCompletionItemProvider} from './autocomplete/registerProvider';
+import type {FetchedColumn} from './autocomplete/types';
+import {removeBackticks} from './autocomplete/utils';
+import {
+    checkIsDirectory,
+    filterAutocompleteEntities,
+    getAggregateFunctions,
+    getColumnDetails,
+    getEntitySettings,
+    getPragmas,
+    getSimpleFunctions,
+    getSimpleTypes,
+    getTableFunctions,
+    getUdfs,
+    getWindowFunctions,
+    normalizeEntityNames,
+} from './generateSuggestions';
 
 export function registerYQLCompletionItemProvider(database: string) {
-    disableCodeSuggestions();
-    completionProvider = monaco.languages.registerCompletionItemProvider(LANGUAGE_ID, {
-        triggerCharacters: [' ', '.', '`', '(', '/'],
-        provideCompletionItems: createProvideSuggestionsFunction(database),
+    const fetchEntities = async (prefix: string, neededTypes: YQLEntity[]) => {
+        const data = await window.api.viewer.autocomplete({
+            database,
+            prefix: removeBackticks(prefix),
+            limit: 1000,
+        });
+        if (!data.Success || !data.Result.Entities) {
+            return [];
+        }
+        const filteredEntities = filterAutocompleteEntities(data.Result.Entities, neededTypes);
+        return (
+            filteredEntities?.map(({Name, Type}) => ({
+                value: Name,
+                detail: Type,
+                isDir: checkIsDirectory(Type),
+            })) ?? []
+        );
+    };
+
+    const fetchEntityColumns = async (entityNames: string[]) => {
+        let autocompleteEntities: TAutocompleteEntity[] = [];
+        const normalizedNames = normalizeEntityNames(entityNames, database);
+        const autocompleteResponse = await window.api.viewer.autocomplete({
+            database,
+            table: normalizedNames,
+            limit: 1000,
+        });
+        if (autocompleteResponse.Success) {
+            autocompleteEntities = autocompleteResponse.Result.Entities ?? [];
+        }
+        const result: FetchedColumn[] = [];
+        autocompleteEntities.forEach((entity) => {
+            if (isAutocompleteColumn(entity)) {
+                result.push({
+                    name: entity.Name,
+                    detail: getColumnDetails(entity),
+                    parent: entity.Parent,
+                });
+            }
+        });
+        return result;
+    };
+
+    registerCompletionItemProvider(LANGUAGE_ID, [' ', '.', '`', '(', '/'], {
+        fetchEntities,
+        fetchEntityColumns,
+        getEntitySettings,
+        getPragmas,
+        getSimpleFunctions,
+        getAggregateFunctions,
+        getTableFunctions,
+        getWindowFunctions,
+        getUdfs,
+        getSimpleTypes,
     });
 }
diff --git a/src/utils/monaco/yql/yqlSuggestions.ts b/src/utils/monaco/yql/yqlSuggestions.ts
