ydb-embedded-ui 6.4.0 → 6.6.0

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

@@ -1,27 +0,0 @@
-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[]>;

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

@@ -1,341 +0,0 @@
-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,
-    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'],
-    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)) {
-        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,
-    suggestKeywords: 5,
-    suggestAggregateFunctions: 6,
-    suggestTableFunctions: 7,
-    suggestWindowFunctions: 8,
-    suggestFunctions: 9,
-    suggestUdfs: 10,
-    suggestSimpleTypes: 11,
-};
-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 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')),
-    }));
-}
-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/utils/monaco/yql/yqlSuggestions.js

@@ -1,85 +0,0 @@
-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 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 = [];
-    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);
-    }
-    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,
-    ];
-    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/utils/query.d.ts

@@ -1,28 +0,0 @@
-import type { AnyExecuteResponse, AnyExplainResponse, KeyValueRow, QueryPlan, ScriptPlan } from '../types/api/query';
-import type { IQueryResult, QueryErrorResponse, 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 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 function prepareQueryError(error: QueryErrorResponse): string | undefined;
-export {};

package/dist/utils/query.js

@@ -1,171 +0,0 @@
-import { __rest } from "tslib";
-import { YQLType } from '../types';
-export const QUERY_ACTIONS = {
-    execute: 'execute',
-    explain: 'explain',
-};
-export const QUERY_MODES = {
-    scan: 'scan',
-    script: 'script',
-    data: 'data',
-    query: 'query',
-    pg: 'pg',
-};
-export const QUERY_MODES_TITLES = {
-    scan: 'Scan',
-    script: 'YQL Script',
-    data: 'Data',
-    query: 'YQL - QueryService',
-    pg: 'PostgreSQL',
-};
-export const QUERY_SYNTAX = {
-    yql: 'yql_v1',
-    pg: 'pg',
-};
-// eslint-disable-next-line complexity
-export const getColumnType = (type) => {
-    switch (type.replace(/\?$/, '')) {
-        case YQLType.Bool:
-            return 'boolean';
-        case YQLType.Int8:
-        case YQLType.Int16:
-        case YQLType.Int32:
-        case YQLType.Int64:
-        case YQLType.Uint8:
-        case YQLType.Uint16:
-        case YQLType.Uint32:
-        case YQLType.Uint64:
-        case YQLType.Float:
-        case YQLType.Double:
-        case YQLType.Decimal:
-            return 'number';
-        case YQLType.String:
-        case YQLType.Utf8:
-        case YQLType.Json:
-        case YQLType.JsonDocument:
-        case YQLType.Yson:
-        case YQLType.Uuid:
-            return 'string';
-        case YQLType.Date:
-        case YQLType.Datetime:
-        case YQLType.Timestamp:
-        case YQLType.Interval:
-        case YQLType.TzDate:
-        case YQLType.TzDateTime:
-        case YQLType.TzTimestamp:
-            return 'date';
-        default:
-            return undefined;
-    }
-};
-/** parse response result from ArrayRow to KeyValueRow */
-const parseModernResult = (rows, columns) => {
-    return rows.map((row) => {
-        return row.reduce((newRow, cellData, columnIndex) => {
-            const { name } = columns[columnIndex];
-            newRow[name] = cellData;
-            return newRow;
-        }, {});
-    });
-};
-const parseExecuteModernResponse = (data) => {
-    const { result, columns } = data, restData = __rest(data, ["result", "columns"]);
-    return Object.assign({ result: result && columns && parseModernResult(result, columns), columns }, restData);
-};
-const parseExecuteMultiResponse = (data) => {
-    const { result } = data, restData = __rest(data, ["result"]);
-    const parsedResult = result === null || result === void 0 ? void 0 : result.map((resultSet) => {
-        const { rows, columns } = resultSet;
-        let parsedRows;
-        if (columns) {
-            // Result shouldn't be null if there are columns
-            parsedRows = [];
-        }
-        if (rows && columns) {
-            parsedRows = parseModernResult(rows, columns);
-        }
-        return {
-            columns: columns,
-            result: parsedRows,
-        };
-    });
-    return Object.assign({ resultSets: parsedResult }, restData);
-};
-const isModern = (response) => Boolean(response &&
-    !Array.isArray(response) &&
-    Array.isArray(response.result) &&
-    Array.isArray(response.columns));
-const isMulti = (response) => Boolean(response &&
-    !Array.isArray(response) &&
-    Array.isArray(response.result) &&
-    typeof response.result[0] === 'object' &&
-    'rows' in response.result[0] &&
-    'columns' in response.result[0]);
-const isUnsupportedType = (data) => {
-    return Boolean(!data ||
-        typeof data !== 'object' ||
-        Array.isArray(data) ||
-        ('result' in data && !Array.isArray(data.result)));
-};
-// Although schema is set in request, if schema is not supported default schema for the version will be used
-// So we should additionally parse response
-export const parseQueryAPIExecuteResponse = (data) => {
-    if (isUnsupportedType(data)) {
-        return {};
-    }
-    if (isMulti(data)) {
-        return parseExecuteMultiResponse(data);
-    }
-    if (isModern(data)) {
-        return parseExecuteModernResponse(data);
-    }
-    return data;
-};
-export const parseQueryAPIExplainResponse = (data) => {
-    if (isUnsupportedType(data)) {
-        return {};
-    }
-    return data;
-};
-const isExplainScriptPlan = (plan) => Boolean(plan && 'queries' in plan);
-export const parseQueryExplainPlan = (plan) => {
-    if (isExplainScriptPlan(plan)) {
-        if (!plan.queries || !plan.queries.length) {
-            return { meta: plan.meta };
-        }
-        return {
-            Plan: plan.queries[0].Plan,
-            tables: plan.queries[0].tables,
-            meta: plan.meta,
-        };
-    }
-    return plan;
-};
-export const prepareQueryResponse = (data) => {
-    if (!Array.isArray(data)) {
-        return [];
-    }
-    return data.map((row) => {
-        const formattedData = {};
-        for (const field in row) {
-            if (Object.prototype.hasOwnProperty.call(row, field)) {
-                const type = typeof row[field];
-                // Although typeof null == 'object'
-                // null result should be preserved
-                if ((row[field] !== null && type === 'object') ||
-                    type === 'boolean' ||
-                    Array.isArray(row[field])) {
-                    formattedData[field] = JSON.stringify(row[field]);
-                }
-                else {
-                    formattedData[field] = row[field];
-                }
-            }
-        }
-        return formattedData;
-    });
-};
-export function prepareQueryError(error) {
-    var _a, _b;
-    return ((_b = (_a = error.data) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.message) || error.statusText;
-}