ydb-embedded-ui 6.4.0 → 6.6.0

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

@@ -0,0 +1,28 @@
+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;
+    insertText: string;
+    kind: monaco.languages.CompletionItemKind;
+    detail: string;
+    range: monaco.IRange;
+    sortText: string;
+}[];
+export declare function generateKeywordsSuggestion(rangeToInsertSuggestion: monaco.IRange, suggestKeywords?: KeywordSuggestion[]): {
+    label: string;
+    insertText: string;
+    kind: monaco.languages.CompletionItemKind;
+    detail: string;
+    range: monaco.IRange;
+    sortText: string;
+}[];
+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[]>;
+export declare function generateWindowFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateTableFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateAggregateFunctionsSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
+export declare function generatePragmasSuggestion(rangeToInsertSuggestion: monaco.IRange): Promise<monaco.languages.CompletionItem[]>;
+export declare function generateEntitySettingsSuggestion(rangeToInsertSuggestion: monaco.IRange, entityType: YQLEntity): Promise<monaco.languages.CompletionItem[]>;

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

@@ -0,0 +1,358 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { AggregateFunctions, EntitySettings, Pragmas, SimpleFunctions, SimpleTypes, TableFunction, Udfs, WindowFunctions, } from './constants';
+const CompletionItemKind = {
+    Method: 0,
+    Function: 1,
+    Constructor: 2,
+    Field: 3,
+    Variable: 4,
+    Class: 5,
+    Struct: 6,
+    Interface: 7,
+    Module: 8,
+    Property: 9,
+    Event: 10,
+    Operator: 11,
+    Unit: 12,
+    Value: 13,
+    Constant: 14,
+    Enum: 15,
+    EnumMember: 16,
+    Keyword: 17,
+    Text: 18,
+    Color: 19,
+    File: 20,
+    Reference: 21,
+    Customcolor: 22,
+    Folder: 23,
+    TypeParameter: 24,
+    User: 25,
+    Issue: 26,
+    Snippet: 27,
+};
+const re = /[\s'"-/@]/;
+const suggestionEntityToAutocomplete = {
+    externalDataSource: ['external_data_source'],
+    externalTable: ['external_table'],
+    replication: ['replication'],
+    table: ['table', 'column_table'],
+    tableStore: ['column_store'],
+    topic: ['pers_queue_group'],
+    view: ['view'],
+    tableIndex: ['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)) {
+        result = `\`${value}\``;
+    }
+    return result;
+}
+function removeBackticks(value) {
+    let sliceStart = 0;
+    let sliceEnd = value.length;
+    if (value.startsWith('`')) {
+        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 removeStartSlash(cleanedValue);
+}
+const SuggestionsWeight = {
+    suggestTemplates: 0,
+    suggestPragmas: 1,
+    suggestEntity: 2,
+    suggestColumns: 3,
+    suggestColumnAliases: 4,
+    suggestTableIndexes: 5,
+    suggestTableHints: 6,
+    suggestEntitySettings: 7,
+    suggestKeywords: 8,
+    suggestAggregateFunctions: 9,
+    suggestTableFunctions: 10,
+    suggestWindowFunctions: 11,
+    suggestFunctions: 12,
+    suggestSimpleTypes: 13,
+    suggestUdfs: 14,
+};
+function getSuggestionIndex(suggestionType) {
+    return SuggestionsWeight[suggestionType];
+}
+async function getSimpleFunctions() {
+    return SimpleFunctions;
+}
+async function getWindowFunctions() {
+    return WindowFunctions;
+}
+async function getTableFunctions() {
+    return TableFunction;
+}
+async function getAggregateFunctions() {
+    return AggregateFunctions;
+}
+async function getPragmas() {
+    return Pragmas;
+}
+async function getEntitySettings(entityType) {
+    return EntitySettings[entityType];
+}
+async function getUdfs() {
+    return Udfs;
+}
+async function getSimpleTypes() {
+    return SimpleTypes;
+}
+export async function generateColumnsSuggestion(rangeToInsertSuggestion, suggestColumns, database) {
+    var _a, _b, _c;
+    if (!(suggestColumns === null || suggestColumns === void 0 ? void 0 : suggestColumns.tables)) {
+        return [];
+    }
+    const suggestions = [];
+    const multi = suggestColumns.tables.length > 1;
+    const normalizedTableNames = (_b = (_a = suggestColumns.tables) === null || _a === void 0 ? void 0 : _a.map((entity) => {
+        let normalizedEntityName = removeBackticks(entity.name);
+        if (!normalizedEntityName.endsWith('/')) {
+            normalizedEntityName = `${normalizedEntityName}/`;
+        }
+        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 (multi) {
+                columnNameSuggestion = `${wrapStringToBackticks(normalizedParentName)}.${normalizedName}`;
+            }
+            suggestions.push({
+                label: columnNameSuggestion,
+                insertText: columnNameSuggestion,
+                kind: CompletionItemKind.Field,
+                detail: 'Column',
+                range: rangeToInsertSuggestion,
+                sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumns')),
+            });
+        }
+    });
+    return suggestions;
+}
+export function generateColumnAliasesSuggestion(rangeToInsertSuggestion, suggestColumnAliases) {
+    if (!suggestColumnAliases) {
+        return [];
+    }
+    return suggestColumnAliases === null || suggestColumnAliases === void 0 ? void 0 : suggestColumnAliases.map((columnAliasSuggestion) => ({
+        label: columnAliasSuggestion.name,
+        insertText: columnAliasSuggestion.name,
+        kind: CompletionItemKind.Field,
+        detail: 'Column alias',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestColumnAliases')),
+    }));
+}
+export function generateKeywordsSuggestion(rangeToInsertSuggestion, suggestKeywords) {
+    if (!suggestKeywords) {
+        return [];
+    }
+    return suggestKeywords === null || suggestKeywords === void 0 ? void 0 : suggestKeywords.map((keywordSuggestion) => ({
+        label: keywordSuggestion.value,
+        insertText: keywordSuggestion.value,
+        kind: CompletionItemKind.Keyword,
+        detail: 'Keyword',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestKeywords')),
+    }));
+}
+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) {
+    const functions = await getSimpleFunctions();
+    return functions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.Function,
+        detail: 'Function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestFunctions')),
+    }));
+}
+export async function generateSimpleTypesSuggestion(rangeToInsertSuggestion) {
+    const simpleTypes = await getSimpleTypes();
+    return simpleTypes.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.TypeParameter,
+        detail: 'Type',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestSimpleTypes')),
+    }));
+}
+export async function generateUdfSuggestion(rangeToInsertSuggestion) {
+    const udfs = await getUdfs();
+    return udfs.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.Function,
+        detail: 'UDF',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestUdfs')),
+    }));
+}
+export async function generateWindowFunctionsSuggestion(rangeToInsertSuggestion) {
+    const windowFunctions = await getWindowFunctions();
+    return windowFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.Function,
+        detail: 'Window function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestWindowFunctions')),
+    }));
+}
+export async function generateTableFunctionsSuggestion(rangeToInsertSuggestion) {
+    const tableFunctions = await getTableFunctions();
+    return tableFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.Function,
+        detail: 'Table function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestTableFunctions')),
+    }));
+}
+export async function generateAggregateFunctionsSuggestion(rangeToInsertSuggestion) {
+    const aggreagteFunctions = await getAggregateFunctions();
+    return aggreagteFunctions.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.Function,
+        detail: 'Aggregate function',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestAggregateFunctions')),
+    }));
+}
+export async function generatePragmasSuggestion(rangeToInsertSuggestion) {
+    const pragmas = await getPragmas();
+    return pragmas.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.Module,
+        detail: 'Pragma',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestPragmas')),
+    }));
+}
+export async function generateEntitySettingsSuggestion(rangeToInsertSuggestion, entityType) {
+    const entitySettings = await getEntitySettings(entityType);
+    return entitySettings.map((el) => ({
+        label: el,
+        insertText: el,
+        kind: CompletionItemKind.Property,
+        detail: 'Setting',
+        range: rangeToInsertSuggestion,
+        sortText: suggestionIndexToWeight(getSuggestionIndex('suggestEntitySettings')),
+    }));
+}
+const alphabet = 'abcdefghijklmnopqrstuvwxyz';
+function suggestionIndexToWeight(index) {
+    const characterInsideAlphabet = alphabet[index];
+    if (characterInsideAlphabet) {
+        return characterInsideAlphabet;
+    }
+    const duplicateTimes = Math.floor(index / alphabet.length);
+    const remains = index % alphabet.length;
+    const lastCharacter = alphabet.slice(-1);
+    return lastCharacter.repeat(duplicateTimes) + alphabet[remains];
+}

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

@@ -0,0 +1,90 @@
+import { generateAggregateFunctionsSuggestion, generateColumnAliasesSuggestion, generateColumnsSuggestion, generateEntitiesSuggestion, generateEntitySettingsSuggestion, generateKeywordsSuggestion, generatePragmasSuggestion, generateSimpleFunctionsSuggestion, generateSimpleTypesSuggestion, generateTableFunctionsSuggestion, generateUdfSuggestion, generateWindowFunctionsSuggestion, } from './generateSuggestions';
+export function createProvideSuggestionsFunction(database) {
+    return async (model, monacoCursorPosition, _context, _token) => {
+        const rangeToInsertSuggestion = getRangeToInsertSuggestion(model, monacoCursorPosition);
+        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 cursorForParsing = {
+        line: cursorPosition.lineNumber,
+        column: cursorPosition.column,
+    };
+    const parseResult = parseYqlQuery(model.getValue(), cursorForParsing);
+    let entitiesSuggestions = [];
+    let functionsSuggestions = [];
+    let aggregateFunctionsSuggestions = [];
+    let windowFunctionsSuggestions = [];
+    let tableFunctionsSuggestions = [];
+    let udfsSuggestions = [];
+    let simpleTypesSuggestions = [];
+    let pragmasSuggestions = [];
+    let entitySettingsSuggestions = [];
+    if (parseResult.suggestEntity) {
+        const entityNamePrefix = getEntityNameAtCursor(model, cursorPosition);
+        entitiesSuggestions = await generateEntitiesSuggestion(rangeToInsertSuggestion, parseResult.suggestEntity, database, entityNamePrefix);
+    }
+    if (parseResult.suggestFunctions) {
+        functionsSuggestions = await generateSimpleFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestAggregateFunctions) {
+        aggregateFunctionsSuggestions =
+            await generateAggregateFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestWindowFunctions) {
+        windowFunctionsSuggestions =
+            await generateWindowFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestTableFunctions) {
+        tableFunctionsSuggestions = await generateTableFunctionsSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestSimpleTypes) {
+        simpleTypesSuggestions = await generateSimpleTypesSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestUdfs) {
+        udfsSuggestions = await generateUdfSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestPragmas) {
+        pragmasSuggestions = await generatePragmasSuggestion(rangeToInsertSuggestion);
+    }
+    if (parseResult.suggestEntitySettings) {
+        entitySettingsSuggestions = await generateEntitySettingsSuggestion(rangeToInsertSuggestion, parseResult.suggestEntitySettings);
+    }
+    const columnAliasSuggestion = await generateColumnAliasesSuggestion(rangeToInsertSuggestion, parseResult.suggestColumnAliases);
+    const columnsSuggestions = await generateColumnsSuggestion(rangeToInsertSuggestion, parseResult.suggestColumns, database);
+    const keywordsSuggestions = generateKeywordsSuggestion(rangeToInsertSuggestion, parseResult.suggestKeywords);
+    const suggestions = [
+        ...entitiesSuggestions,
+        ...functionsSuggestions,
+        ...windowFunctionsSuggestions,
+        ...tableFunctionsSuggestions,
+        ...udfsSuggestions,
+        ...simpleTypesSuggestions,
+        ...pragmasSuggestions,
+        ...columnAliasSuggestion,
+        ...columnsSuggestions,
+        ...keywordsSuggestions,
+        ...aggregateFunctionsSuggestions,
+        ...entitySettingsSuggestions,
+    ];
+    return suggestions;
+}
+function getRangeToInsertSuggestion(model, cursorPosition) {
+    const { startColumn: lastWordStartColumn, endColumn: lastWordEndColumn } = model.getWordUntilPosition(cursorPosition);
+    // https://github.com/microsoft/Monaco-editor/discussions/3639#discussioncomment-5190373 if user already typed "$" sign, it should not be duplicated
+    const dollarBeforeLastWordStart = model.getLineContent(cursorPosition.lineNumber)[lastWordStartColumn - 2] === '$' ? 1 : 0;
+    return {
+        startColumn: lastWordStartColumn - dollarBeforeLastWordStart,
+        startLineNumber: cursorPosition.lineNumber,
+        endColumn: lastWordEndColumn,
+        endLineNumber: cursorPosition.lineNumber,
+    };
+}

package/dist/src/utils/query.d.ts

@@ -0,0 +1,30 @@
+import type { AnyExecuteResponse, AnyExplainResponse, ErrorResponse, KeyValueRow, QueryPlan, ScriptPlan } from '../types/api/query';
+import type { IQueryResult, QueryMode } from '../types/store/query';
+export declare const QUERY_ACTIONS: {
+    readonly execute: "execute";
+    readonly explain: "explain";
+};
+export declare const QUERY_MODES: {
+    readonly scan: "scan";
+    readonly script: "script";
+    readonly data: "data";
+    readonly query: "query";
+    readonly pg: "pg";
+};
+export declare const QUERY_MODES_TITLES: Record<QueryMode, string>;
+export declare const QUERY_SYNTAX: {
+    readonly yql: "yql_v1";
+    readonly pg: "pg";
+};
+export declare const getColumnType: (type: string) => "boolean" | "number" | "string" | "date" | undefined;
+type UnsupportedQueryResponseFormat = Array<unknown> | string | null | undefined | {
+    result: string | Record<string, unknown>;
+};
+export declare function isQueryErrorResponse(data: unknown): data is ErrorResponse;
+export declare const parseQueryAPIExecuteResponse: (data: AnyExecuteResponse | UnsupportedQueryResponseFormat) => IQueryResult;
+export declare const parseQueryAPIExplainResponse: (data: AnyExplainResponse | UnsupportedQueryResponseFormat) => IQueryResult;
+export declare const parseQueryExplainPlan: (plan: ScriptPlan | QueryPlan) => QueryPlan;
+export declare const prepareQueryResponse: (data?: KeyValueRow[]) => KeyValueRow[];
+export declare const parseQueryError: (error: unknown) => ErrorResponse | string | undefined;
+export declare const parseQueryErrorToString: (error: unknown) => string | undefined;
+export {};