@gooddata/sdk-maql-language-server 0.0.0-stage → 11.65.0-alpha.10

package/esm/labelElements.js

@@ -0,0 +1,224 @@
+// (C) 2021-2026 GoodData Corporation
+import { AbstractAstVisitor, positionInRange, } from "@gooddata/maql-antlr4ts";
+import { isTigerType, tigerIdTypeToObjectType } from "@gooddata/sdk-backend-tiger";
+import { normalizeMaqlObjectType } from "./maqlObjectTypes.js";
+import { AntlrRange, isMaqlObject, isMaqlString, } from "./tokenRanges.js";
+/**
+ * Uses a visitor to make a depth-first tree-walk of a MAQL parse tree to find a correct "LabelContext"
+ * for a given caret offset
+ */
+export function findLabelContext(metric, position) {
+    const visitor = new LabelContextFinder(position);
+    const ast = metric.ast;
+    visitor.visit(ast);
+    return visitor.caretLabelContext ?? new LabelContext();
+}
+export function labelElementsFinder(metric) {
+    const visitor = new LabelElementsFinder();
+    visitor.visit(metric.ast);
+    return visitor.pairs;
+}
+export class LabelContext {
+    labels = [];
+    strings = [];
+    timeMacros = [];
+    get operands() {
+        return [...this.labels, ...this.strings, ...this.timeMacros];
+    }
+    isEmpty() {
+        return this.operands.length === 0;
+    }
+    addString(text, range) {
+        this.strings.push({
+            string: text,
+            range: range,
+        });
+        return this;
+    }
+    addLabel(maqlType, id, range, _space) {
+        // MAQL spells a computed attribute `computed_attribute`; the Tiger type is what the
+        // elements query and the catalog lookups understand.
+        const type = normalizeMaqlObjectType(maqlType);
+        if (!isTigerType(type)) {
+            return this; // `type "${type}" of the object {${type}${id}${space ? `/${space}` : ""}} is not valid`
+        }
+        // A computed attribute buckets rows into string values like a label does, so its values are
+        // listed and validated the same way. Its ref carries the computedAttribute type, which the
+        // elements query uses to address it (it has no labels of its own).
+        if (type === "attribute" || type === "label" || type === "computedAttribute") {
+            this.labels.push({
+                actualType: type,
+                tigerType: type,
+                id: id,
+                ref: {
+                    type: tigerIdTypeToObjectType[type],
+                    identifier: id,
+                },
+                range: range,
+            });
+        }
+        return this;
+    }
+    addTimeMacro(transformationFunction, granularity, range) {
+        this.timeMacros.push({
+            transformationFunction: transformationFunction,
+            granularity: granularity,
+            range: range,
+        });
+        return this;
+    }
+    add(other) {
+        other.labels.forEach((label) => this.labels.push(label));
+        other.timeMacros.forEach((timeMacro) => this.timeMacros.push(timeMacro));
+        other.strings.forEach((str) => this.strings.push(str));
+        return this;
+    }
+    toString() {
+        return ("# LabelContext:\n## labels:\n" +
+            this.labels.map((label) => `${label.tigerType}/${label.id}`).join("\n") +
+            "\n## strings:\n" +
+            this.strings.map((string) => string.string).join("\n"));
+    }
+}
+class LabelContextMarker extends AbstractAstVisitor {
+    defaultResult() {
+        return new LabelContext();
+    }
+    aggregateResult(aggregate, nextResult) {
+        return aggregate.add(nextResult);
+    }
+    visitFunctionNode(node) {
+        const lc = new LabelContext();
+        if (node.range === undefined)
+            return lc;
+        const name = node.name.toUpperCase();
+        const range = AntlrRange.fromAstRange(node.range);
+        if (node.type === "time macro") {
+            // assume that the first argument of time macro is always granularity
+            const granularity = node.content[0]?.value;
+            if (granularity) {
+                lc.addTimeMacro(name, granularity, range);
+            }
+        }
+        else if (node.type === "function") {
+            // special case for MIN and MAX functions
+            // to remove this special case we would need "source" information in function definition
+            if (name === "MAX" || name === "MIN") {
+                // ignore second argument of MIN/MAX function, as it is just a "witness attribute"
+                const [expr, _witness] = node.content;
+                if (expr) {
+                    lc.add(this.visit(expr));
+                }
+            }
+        }
+        else {
+            this.visitChildren(node);
+        }
+        return lc;
+    }
+    visitIdentifierNode(node) {
+        const lc = new LabelContext();
+        if (node.range === undefined)
+            return lc;
+        const range = AntlrRange.fromAstRange(node.range);
+        lc.addLabel(node.objectType, node.id, range, node.space);
+        return lc;
+    }
+    visitStringLiteralNode(node) {
+        const lc = new LabelContext();
+        if (node.range === undefined)
+            return lc;
+        const range = AntlrRange.fromAstRange(node.range);
+        return lc.addString(node.value, range);
+    }
+}
+/**
+ * Finds a label context relevant to provided caret position
+ */
+class LabelContextFinder extends LabelContextMarker {
+    caretPosition;
+    caretLabelContext;
+    continueTraversal = true;
+    constructor(caretPosition) {
+        super();
+        this.caretPosition = caretPosition;
+    }
+    visit(node) {
+        const lc = super.visit(node);
+        if (this.continueTraversal &&
+            node.contextRange &&
+            positionInRange(this.caretPosition, node.contextRange)) {
+            this.caretLabelContext = lc;
+        }
+        return lc;
+    }
+    visitOperatorNode(node) {
+        // postorder AST traversal
+        const lc = super.visitOperatorNode(node);
+        // if the caret is in the operands of the following operators, use their label context and look no further
+        // idea: it may make sense to add "label context" to type information and unify this with findContext
+        switch (node.type) {
+            case "=":
+            case "<>":
+            case ">=":
+            case "<=":
+            case "<":
+            case ">":
+            case "like":
+            case "ilike":
+            case "not like":
+            case "not ilike":
+            case "between":
+            case "not between":
+            case "in":
+            case "not in":
+                if (this.continueTraversal &&
+                    node.contextRange &&
+                    positionInRange(this.caretPosition, node.contextRange)) {
+                    this.continueTraversal = false;
+                    this.caretLabelContext = lc;
+                }
+        }
+        // the result of filter expression is a boolean value, therefore inner label context is discarded
+        return this.defaultResult();
+    }
+}
+/**
+ * Traverses the AST to collect all instances of strings in relation to labels. This can then be used to validate
+ * label elements.
+ */
+class LabelElementsFinder extends LabelContextMarker {
+    pairs = [];
+    visitOperatorNode(node) {
+        const operandContexts = node.content.map((operand) => this.visit(operand).operands);
+        if (node.type !== "like" && node.type !== "not like") {
+            this.addOperands(operandContexts);
+        }
+        return this.defaultResult();
+    }
+    addOperands(operandContexts) {
+        if (operandContexts.length <= 1) {
+            return;
+        }
+        const head = operandContexts[0];
+        const tail = operandContexts.slice(1);
+        for (const headOp of head) {
+            for (const ops of tail) {
+                for (const op of ops) {
+                    this.pushPair(headOp, op);
+                }
+            }
+        }
+        this.addOperands(tail);
+    }
+    pushPair(left, right) {
+        if (isMaqlObject(left)) {
+            if (isMaqlString(right)) {
+                this.pairs.push([left, right]);
+            }
+        }
+        else if (isMaqlObject(right)) {
+            this.pushPair(right, left);
+        }
+    }
+}

package/esm/maqlLanguageService.d.ts

@@ -0,0 +1,56 @@
+import { type CompletionItem, type CompletionList, type Diagnostic, type FormattingOptions, type InitializeResult, type SemanticTokens, type TextEdit } from "vscode-languageserver";
+import { type Position, type Range, type TextDocument } from "vscode-languageserver-textdocument";
+import { type IDecoration } from "./decorations.js";
+import { type Locale } from "./docs/index.js";
+import { type HighlightToken } from "./highlight/semanticsHighlight.js";
+import { type HoverWithData } from "./hover.js";
+import { type IMetadataInterface } from "./metadata/types.js";
+/**
+ * @internal
+ */
+export interface ILanguageService {
+    initialize(): InitializeResult;
+    doValidation(textDocument: TextDocument): Promise<Diagnostic[]>;
+    doCompletion(textDocument: TextDocument, position: Position): Promise<CompletionList>;
+    doCompletionResolve(item: CompletionItem): Promise<CompletionItem>;
+    doHighlightTokens(textDocument: TextDocument): Promise<HighlightToken[]>;
+    doSemanticTokens(textDocument: TextDocument): Promise<SemanticTokens>;
+    doDecoration(textDocument: TextDocument): Promise<IDecoration[]>;
+    doFormat(textDocument: TextDocument, options: FormattingOptions): Promise<TextEdit[]>;
+    doFormatRange(textDocument: TextDocument, range: Range, options: FormattingOptions): Promise<TextEdit[]>;
+}
+/**
+ * MAQL Language Service class
+ * A service to manage the capabilities of the MAQL language server
+ * Can be supplied by Metadata API credentials to automatically
+ * retrieve typed ldmObjects from the Logical Data Model (LDM)
+ *
+ * @internal
+ */
+export declare class MaqlLanguageService implements ILanguageService {
+    constructor(locale?: Locale, metadataService?: IMetadataInterface);
+    private _locale;
+    get locale(): Locale;
+    set locale(locale: string);
+    private metadataService?;
+    private ldmObjects;
+    private labelElementsFunc?;
+    private docs;
+    private isValidLocale;
+    private setMetadataServiceMethods;
+    /**
+     * A method to get information about the capabilities of the service
+     */
+    initialize(): InitializeResult;
+    doCompletion(textDocument: TextDocument, position: Position): Promise<CompletionList>;
+    doCompletionResolve(item: CompletionItem): Promise<CompletionItem>;
+    doHighlightTokens(textDocument: TextDocument): Promise<HighlightToken[]>;
+    doSemanticTokens(textDocument: TextDocument): Promise<SemanticTokens>;
+    doValidation(textDocument: TextDocument): Promise<Diagnostic[]>;
+    doDecoration(textDocument: TextDocument): Promise<IDecoration[]>;
+    doHover(textDocument: TextDocument, position: Position): Promise<HoverWithData | null>;
+    doFormat(textDocument: TextDocument, options: FormattingOptions): Promise<TextEdit[]>;
+    doFormatRange(textDocument: TextDocument, range: Range, options: FormattingOptions): Promise<TextEdit[]>;
+    private handleMetadataServiceError;
+}
+//# sourceMappingURL=maqlLanguageService.d.ts.map

package/esm/maqlLanguageService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maqlLanguageService.d.ts","sourceRoot":"","sources":["../src/maqlLanguageService.ts"],"names":[],"mappings":"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"}

package/esm/maqlLanguageService.js

@@ -0,0 +1,104 @@
+// (C) 2021-2026 GoodData Corporation
+import { TextDocumentSyncKind, } from "vscode-languageserver";
+import { complete, resolve } from "./completions/complete.js";
+import { decorate } from "./decorations.js";
+import { validate } from "./diagnostics.js";
+import { docsIndex, locales } from "./docs/index.js";
+import { format, formatRange } from "./format.js";
+import { convertToSemanticTokens } from "./highlight/convert.js";
+import { semanticTokensLegend, semanticsFull } from "./highlight/semanticsHighlight.js";
+import { hover } from "./hover.js";
+/**
+ * MAQL Language Service class
+ * A service to manage the capabilities of the MAQL language server
+ * Can be supplied by Metadata API credentials to automatically
+ * retrieve typed ldmObjects from the Logical Data Model (LDM)
+ *
+ * @internal
+ */
+export class MaqlLanguageService {
+    constructor(locale = "en-us", metadataService) {
+        this._locale = locale;
+        this.metadataService = metadataService;
+        this.setMetadataServiceMethods();
+    }
+    _locale;
+    get locale() {
+        return this._locale;
+    }
+    set locale(locale) {
+        const lowercaseLocale = locale.toLowerCase();
+        if (this.isValidLocale(lowercaseLocale)) {
+            this._locale = lowercaseLocale;
+        }
+    }
+    metadataService;
+    ldmObjects = Promise.resolve();
+    labelElementsFunc;
+    docs = docsIndex;
+    isValidLocale(locale) {
+        return locales.includes(locale);
+    }
+    setMetadataServiceMethods() {
+        if (this.metadataService) {
+            this.ldmObjects = this.metadataService
+                .getLdmObjects()
+                .catch((reason) => this.handleMetadataServiceError(reason));
+            this.labelElementsFunc = this.metadataService
+                .getLabelElementsFunction()
+                .catch((reason) => this.handleMetadataServiceError(reason));
+        }
+    }
+    /**
+     * A method to get information about the capabilities of the service
+     */
+    initialize() {
+        return {
+            capabilities: {
+                textDocumentSync: TextDocumentSyncKind.Full,
+                completionProvider: {
+                    resolveProvider: true,
+                    triggerCharacters: [" ", "(", "/", "{"],
+                },
+                semanticTokensProvider: {
+                    legend: semanticTokensLegend,
+                    full: true,
+                    range: false,
+                },
+                hoverProvider: true,
+                documentFormattingProvider: true,
+                documentRangeFormattingProvider: true,
+            },
+        };
+    }
+    async doCompletion(textDocument, position) {
+        return complete(textDocument.getText(), textDocument.offsetAt(position), (await this.ldmObjects) || undefined, (await this.labelElementsFunc) || undefined);
+    }
+    async doCompletionResolve(item) {
+        return resolve(item, (resolveTag) => Promise.resolve(this.docs[this._locale][resolveTag]));
+    }
+    doHighlightTokens(textDocument) {
+        return Promise.resolve(semanticsFull(textDocument.getText()));
+    }
+    async doSemanticTokens(textDocument) {
+        return convertToSemanticTokens(await this.doHighlightTokens(textDocument));
+    }
+    async doValidation(textDocument) {
+        return validate(textDocument.getText(), (await this.ldmObjects) || undefined, (await this.labelElementsFunc) || undefined);
+    }
+    async doDecoration(textDocument) {
+        return decorate(textDocument.getText(), (await this.ldmObjects) || undefined);
+    }
+    async doHover(textDocument, position) {
+        return hover(textDocument.getText(), position, (await this.ldmObjects) || undefined);
+    }
+    doFormat(textDocument, options) {
+        return Promise.resolve(format(textDocument.getText(), options));
+    }
+    doFormatRange(textDocument, range, options) {
+        return Promise.resolve(formatRange(textDocument.getText(), range, options));
+    }
+    handleMetadataServiceError(_reason) {
+        // TODO: log failures (dependent on environment - web/node)
+    }
+}

package/esm/maqlObjectTypes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Translates an object type as written in MAQL into the Tiger entity type it denotes. Types that
+ * are spelled identically on both sides are returned unchanged, so this is safe to apply to any
+ * `{type/id}` token before looking the type up.
+ *
+ * Keep the MAQL spelling for anything user-facing (diagnostics quote what the author wrote).
+ *
+ * @internal
+ */
+export declare function normalizeMaqlObjectType(maqlObjectType: string): string;
+/**
+ * Translates a Tiger entity type into the way MAQL spells it. Use it whenever a `{type/id}`
+ * reference is written back into MAQL text - a catalog object carries the Tiger type, which the
+ * parser would reject for computed attributes.
+ */
+export declare function toMaqlObjectType(tigerType: string): string;
+//# sourceMappingURL=maqlObjectTypes.d.ts.map

package/esm/maqlObjectTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maqlObjectTypes.d.ts","sourceRoot":"","sources":["../src/maqlObjectTypes.ts"],"names":[],"mappings":"AAeA;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAEtE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D"}

package/esm/maqlObjectTypes.js

@@ -0,0 +1,30 @@
+// (C) 2026 GoodData Corporation
+/**
+ * MAQL spells the computed-attribute object type with an underscore (`{computed_attribute/id}`),
+ * while the Tiger entity type it maps onto is camelCase (`computedAttribute`). Every other MAQL
+ * object type is spelled the same on both sides, so this is the only bridge the two need.
+ */
+const MAQL_OBJECT_TYPE_TO_TIGER_TYPE = {
+    computed_attribute: "computedAttribute",
+};
+const TIGER_TYPE_TO_MAQL_OBJECT_TYPE = Object.fromEntries(Object.entries(MAQL_OBJECT_TYPE_TO_TIGER_TYPE).map(([maqlType, tigerType]) => [tigerType, maqlType]));
+/**
+ * Translates an object type as written in MAQL into the Tiger entity type it denotes. Types that
+ * are spelled identically on both sides are returned unchanged, so this is safe to apply to any
+ * `{type/id}` token before looking the type up.
+ *
+ * Keep the MAQL spelling for anything user-facing (diagnostics quote what the author wrote).
+ *
+ * @internal
+ */
+export function normalizeMaqlObjectType(maqlObjectType) {
+    return MAQL_OBJECT_TYPE_TO_TIGER_TYPE[maqlObjectType] ?? maqlObjectType;
+}
+/**
+ * Translates a Tiger entity type into the way MAQL spells it. Use it whenever a `{type/id}`
+ * reference is written back into MAQL text - a catalog object carries the Tiger type, which the
+ * parser would reject for computed attributes.
+ */
+export function toMaqlObjectType(tigerType) {
+    return TIGER_TYPE_TO_MAQL_OBJECT_TYPE[tigerType] ?? tigerType;
+}

package/esm/maqlServer.d.ts

@@ -0,0 +1,4 @@
+import { type Connection } from "vscode-languageserver";
+import { type IMetadataInterface } from "./metadata/types.js";
+export declare function startServer(connection: Connection, metadataService?: IMetadataInterface): void;
+//# sourceMappingURL=maqlServer.d.ts.map

package/esm/maqlServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maqlServer.d.ts","sourceRoot":"","sources":["../src/maqlServer.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,UAAU,EAAiB,MAAM,uBAAuB,CAAC;AAIvE,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,wBAAgB,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,eAAe,CAAC,EAAE,kBAAkB,QAuFvF"}

package/esm/maqlServer.js

@@ -0,0 +1,78 @@
+// (C) 2021-2026 GoodData Corporation
+import { TextDocuments } from "vscode-languageserver";
+import { TextDocument } from "vscode-languageserver-textdocument";
+import { MaqlLanguageService } from "./maqlLanguageService.js";
+export function startServer(connection, metadataService) {
+    const languageService = new MaqlLanguageService("en-us", metadataService);
+    const documents = new TextDocuments(TextDocument);
+    documents.listen(connection);
+    connection.onInitialize((params) => {
+        connection.tracer.log("initialize");
+        if (params.locale) {
+            languageService.locale = params.locale;
+        }
+        return languageService.initialize();
+    });
+    connection.onInitialized(() => { });
+    documents.onDidOpen(() => { });
+    documents.onDidClose(() => { });
+    documents.onDidChangeContent((params) => {
+        languageService
+            .doValidation(params.document)
+            .then((diagnostics) => {
+            connection.tracer.log(`validateTextDocument uri=${params.document.uri}`);
+            void connection.sendDiagnostics({
+                uri: params.document.uri,
+                diagnostics: diagnostics,
+            });
+        })
+            .catch((reason) => {
+            connection.console.error(`FAILED validateTextDocument uri=${params.document.uri} ${reason}`);
+            // clear diagnostics, because no diagnostics is better than false diagnostics
+            void connection.sendDiagnostics({
+                uri: params.document.uri,
+                diagnostics: [],
+            });
+        });
+    });
+    documents.onDidSave(() => { });
+    connection.onCompletion((params) => {
+        const document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return null;
+        }
+        return languageService.doCompletion(document, params.position);
+    });
+    connection.onCompletionResolve((item) => languageService.doCompletionResolve(item));
+    connection.languages.semanticTokens.on(async (params) => {
+        const document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return {
+                data: [],
+            };
+        }
+        return await languageService.doSemanticTokens(document);
+    });
+    connection.onHover((params) => {
+        const document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return null;
+        }
+        return languageService.doHover(document, params.position);
+    });
+    connection.onDocumentFormatting((params) => {
+        const document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return null;
+        }
+        return languageService.doFormat(document, params.options);
+    });
+    connection.onDocumentRangeFormatting((params) => {
+        const document = documents.get(params.textDocument.uri);
+        if (!document) {
+            return null;
+        }
+        return languageService.doFormatRange(document, params.range, params.options);
+    });
+    connection.listen();
+}