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

package/esm/types/typeChecking.js

@@ -0,0 +1,296 @@
+// (C) 2022-2026 GoodData Corporation
+import MaqlPkg from "@gooddata/maql-antlr4ts";
+const { AbstractAstVisitor } = MaqlPkg;
+import { isTigerType } from "@gooddata/sdk-backend-tiger";
+import { normalizeMaqlObjectType } from "../maqlObjectTypes.js";
+import { MaqlType, abstractValueTypes, isSubtype, lowestCommonAncestor } from "./hierarchy.js";
+import { CallNotation, MaqlCallSignature, findFunctionDefinitions, getCustomDefinitions, } from "./signatures.js";
+export class TypedAstNode {
+    type;
+    node;
+    constructor(type, node) {
+        this.type = type;
+        this.node = node;
+    }
+}
+export class AstTypeChecker extends AbstractAstVisitor {
+    model;
+    constructor(model) {
+        super();
+        this.model = model;
+    }
+    typeConstraintsViolations = [];
+    defaultResult() {
+        return new TypedAstNode(MaqlType.UNIT, null);
+    }
+    mergeResultWithParent(parentNode, result) {
+        return {
+            // oxlint-disable-next-line typescript-eslint/no-misused-spread
+            ...result,
+            node: parentNode,
+        };
+    }
+    visitEmptyNode(node) {
+        const message = "Missing expression" + (node.value === "" ? "" : `. ${node.value}`);
+        this.logViolation(message, node.range);
+        return new TypedAstNode(MaqlType.ALL, node);
+    }
+    visitSelectNode(node) {
+        if (node.by) {
+            this.visit(node.by);
+        }
+        if (node.forEach) {
+            this.visit(node.forEach);
+        }
+        if (node.datetimeTransformation) {
+            this.visit(node.datetimeTransformation);
+        }
+        if (node.filter) {
+            this.visit(node.filter);
+        }
+        if (node.using) {
+            this.visit(node.using);
+        }
+        if (node.parentFilterModification) {
+            this.visit(node.parentFilterModification);
+        }
+        return this.visit(node.expression);
+    }
+    visitExpressionNode(node) {
+        return this.visit(node.expression);
+    }
+    visitOperatorNode(node) {
+        const operands = node.content.map((operand) => this.visit(operand));
+        switch (node.type) {
+            case "not":
+                return this.checkBySignature(node, node.type, operands, CallNotation.PREFIX, getCustomDefinitions(node.type));
+            case "+":
+            case "-":
+            case "*":
+            case "/":
+            case "and":
+            case "or":
+            case "=":
+            case "<>":
+            case ">=":
+            case "<=":
+            case "<":
+            case ">":
+            case "like":
+            case "ilike":
+            case "not like":
+            case "not ilike":
+                return this.checkBySignature(node, node.type, operands, CallNotation.INFIX, getCustomDefinitions(node.type));
+            case "neg":
+                return this.checkUnaryMinusOperator(node, operands);
+            case "between":
+            case "not between":
+                return this.checkBetween(node, operands);
+            case "in":
+            case "not in":
+                return this.checkIn(node, operands);
+        }
+    }
+    checkUnaryMinusOperator(node, operands) {
+        if (!this.checkOperandCount(node, operands.length, 1, "Unary operator '-'")) {
+            return new TypedAstNode(MaqlType.NUMERIC, node);
+        }
+        const operand = operands[0];
+        // Propagate the type of the operand if it is a subtype of NUMERIC
+        // e.g. if it is INTEGER_LITERAL, keep it
+        const returnType = this.checkType(operand, MaqlType.NUMERIC) ? operand.type : MaqlType.NUMERIC;
+        return new TypedAstNode(returnType, node);
+    }
+    checkBetween(node, operands) {
+        if (!this.checkOperandCount(node, operands.length, 3, `Operator ${node.type.toUpperCase()}`)) {
+            return new TypedAstNode(MaqlType.BOOLEAN, node);
+        }
+        const [expr, from, to] = operands;
+        this.checkType(expr, ...abstractValueTypes);
+        // if we can't determine the type of the expression, don't validate the types of from and to
+        if (expr.type !== MaqlType.ALL) {
+            this.checkType(from, expr.type);
+            this.checkType(to, expr.type);
+        }
+        return new TypedAstNode(MaqlType.BOOLEAN, node);
+    }
+    checkIn(node, operands) {
+        if (!this.checkOperandCount(node, operands.length, 2, `Operator ${node.type.toUpperCase()}`)) {
+            return new TypedAstNode(MaqlType.BOOLEAN, node);
+        }
+        const [expr, list] = operands;
+        this.checkType(expr, ...abstractValueTypes);
+        // if we can't determine the type of the expression, don't validate the type of list
+        if (expr.type !== MaqlType.ALL) {
+            this.checkType(list, expr.type);
+        }
+        return new TypedAstNode(MaqlType.BOOLEAN, node);
+    }
+    visitListNode(node) {
+        if (node.content.length > 0) {
+            return this.visitChildren(node);
+        }
+        return new TypedAstNode(MaqlType.ALL, node);
+    }
+    visitFunctionNode(node) {
+        const defs = findFunctionDefinitions(node.type, node.name);
+        if (defs.length === 0) {
+            this.logViolation(`No definition for function '${node.name}'`, node.range);
+            return new TypedAstNode(MaqlType.ALL, node);
+        }
+        const args = node.content.map((arg) => this.visit(arg));
+        return this.checkBySignature(node, node.name, args, CallNotation.FUNCTION, defs);
+    }
+    /**
+     * Checks functions and operators that have defined signatures.
+     */
+    checkBySignature(node, name, args, notation, defs) {
+        const signature = new MaqlCallSignature(name, args, notation);
+        const validDefs = this.findValidDefinitions(signature, defs, node.range);
+        if (validDefs.length === 0) {
+            // if all available definitions have the same return type we can use it
+            const commonReturnType = defs.length > 0 && defs.every((def) => def.returns.type === defs[0].returns.type)
+                ? defs[0].returns.type
+                : MaqlType.ALL;
+            return new TypedAstNode(commonReturnType, node);
+        }
+        // If multiple valid definitions remain, use the first one
+        const def = validDefs[0];
+        return new TypedAstNode(def.returns.type, node);
+    }
+    findValidDefinitions(signature, defs, range) {
+        const validDefs = defs
+            .filter((def) => {
+            return def.parameters.length === signature.parameters.length || def.vararg;
+        })
+            .filter((def) => {
+            const argTypes = signature.parameters.map((arg) => arg.type);
+            // get the function signature or if the definition is `vararg` then match the number of arguments
+            const paramTypes = def.vararg
+                ? Array(argTypes.length).fill(def.parameters[0].type)
+                : def.parameters.map((param) => param.type);
+            return argTypes.every((argType, idx) => {
+                const paramType = paramTypes[idx];
+                return isSubtype(argType, paramType);
+            });
+        });
+        if (validDefs.length === 0) {
+            const receivedSignature = signature.toString();
+            const expectedSignatures = defs.map((def) => def.toString());
+            this.logViolation(`The call expression '${receivedSignature}' has invalid arguments\n` +
+                "Possible definitions:\n" +
+                expectedSignatures.join("\n"), range);
+        }
+        return validDefs;
+    }
+    visitRunningFunctionNode(node) {
+        if (node.within) {
+            this.visit(node.within);
+        }
+        if (node.rollWindow) {
+            this.visit(node.rollWindow);
+        }
+        return this.visit(node.functionNode);
+    }
+    visitRankFunctionNode(node) {
+        if (node.within) {
+            this.visit(node.within);
+        }
+        return this.visit(node.functionNode);
+    }
+    visitLastFirstValueFunctionNode(node) {
+        if (node.orderBy) {
+            this.visit(node.orderBy);
+        }
+        if (node.within) {
+            this.visit(node.within);
+        }
+        return this.visit(node.functionNode);
+    }
+    visitOrderByElement(node) {
+        this.checkType(this.visit(node.content[0]), ...abstractValueTypes);
+        return new TypedAstNode(MaqlType.UNIT, node);
+    }
+    visitRankingFilterNode(node) {
+        this.checkType(this.visit(node.rankSpec), MaqlType.NUMERIC_LITERAL);
+        node.operands.forEach((operand) => this.visit(operand));
+        if (node.within) {
+            this.visit(node.within);
+        }
+        return new TypedAstNode(MaqlType.BOOLEAN, node);
+    }
+    visitCaseNode(node) {
+        const branchTypes = node.content.map((branch) => this.visit(branch).type);
+        const exprType = this.findCompatibleSupertype(branchTypes);
+        return new TypedAstNode(exprType, node);
+    }
+    visitConditionalNode(node) {
+        this.checkType(this.visit(node.condition), MaqlType.BOOLEAN);
+        const exprType = this.visit(node.expression);
+        this.checkType(exprType, ...abstractValueTypes);
+        return exprType;
+    }
+    visitIdentifierNode(node) {
+        // The AST carries the object type as the author spelled it in MAQL, in any casing.
+        const objectType = normalizeMaqlObjectType(node.objectType.toLowerCase());
+        if (isTigerType(objectType)) {
+            return new TypedAstNode(this.model.getType(objectType, node.id), node);
+        }
+        return new TypedAstNode(MaqlType.ALL, node);
+    }
+    visitBooleanLiteralNode(node) {
+        return new TypedAstNode(MaqlType.BOOLEAN, node);
+    }
+    visitNumberLiteralNode(node) {
+        const numberType = node.format === "integer" ? MaqlType.INTEGER_LITERAL : MaqlType.NUMERIC_LITERAL;
+        return new TypedAstNode(numberType, node);
+    }
+    visitStringLiteralNode(node) {
+        return new TypedAstNode(MaqlType.STRING_LITERAL, node);
+    }
+    visitNullLiteralNode(node) {
+        return new TypedAstNode(MaqlType.NULL_LITERAL, node);
+    }
+    visitGranularityNode(node) {
+        const granularityType = this.model.granularities.getType(node.value);
+        if (granularityType === MaqlType.GRANULARITY) {
+            // granularity not recognized - either `DatetimeGranularities` does not contain all granularities
+            // or error node is encountered
+            this.logViolation(`Unrecognized datetime granularity '${node.value}'`, node.range);
+        }
+        return new TypedAstNode(granularityType, node);
+    }
+    visitFilterNode(node) {
+        this.checkType(this.visit(node.condition), MaqlType.BOOLEAN);
+        return new TypedAstNode(MaqlType.UNIT, node);
+    }
+    findCompatibleSupertype(types) {
+        return types.reduce((left, right) => lowestCommonAncestor(left, right));
+    }
+    checkOperandCount(node, actualCount, expectedCount, nodeName) {
+        if (actualCount !== expectedCount) {
+            this.logUnexpectedOperandCount(actualCount, node.range, `${nodeName} expects ${expectedCount} operands`);
+            return false;
+        }
+        return true;
+    }
+    checkType(marker, ...expected) {
+        const isValid = expected.some((expectedType) => isSubtype(marker.type, expectedType));
+        if (!isValid) {
+            this.logIncompatibleSubtype(expected, marker.type, marker.node?.range);
+        }
+        return isValid;
+    }
+    logIncompatibleSubtype(expected, received, range) {
+        const expMessage = expected.map((type) => `'${MaqlType[type]}'`).join(" or ");
+        const message = `Type mismatch: Expected ${expMessage}, but got '${MaqlType[received]}'`;
+        this.logViolation(message, range);
+    }
+    logUnexpectedOperandCount(count, range, extraInfo = "") {
+        const message = [`Unexpected count of operands: ${count}`, extraInfo].join(". ");
+        this.logViolation(message, range);
+    }
+    logViolation(message, range) {
+        this.typeConstraintsViolations.push({ message, range });
+    }
+}

package/esm/types/typeModel.d.ts

@@ -0,0 +1,18 @@
+import type { TigerObjectType } from "@gooddata/sdk-backend-tiger";
+import { MaqlType } from "./hierarchy.js";
+/**
+ * Simplified logical model which holds MAQL type information
+ */
+export declare class TypeModel {
+    readonly granularities: DatetimeGranularities;
+    private readonly labelSet;
+    private readonly dateLabelSet;
+    constructor(labels?: string[], dateLabels?: string[]);
+    getType(objectType: TigerObjectType, id: string): MaqlType;
+}
+export declare class DatetimeGranularities {
+    readonly chronologicalGranularities: Set<string>;
+    readonly periodicalGranularities: Set<string>;
+    getType(granularity: string): MaqlType;
+}
+//# sourceMappingURL=typeModel.d.ts.map

package/esm/types/typeModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typeModel.d.ts","sourceRoot":"","sources":["../../src/types/typeModel.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C;;GAEG;AACH,qBAAa,SAAS;IAClB,QAAQ,CAAC,aAAa,wBAA+B;IACrD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAc;IACvC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAc;IAE3C,YAAY,MAAM,GAAE,MAAM,EAAO,EAAE,UAAU,GAAE,MAAM,EAAO,EAG3D;IAED,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,EAAE,EAAE,MAAM,GAAG,QAAQ,CAyBzD;CACJ;AAED,qBAAa,qBAAqB;IAC9B,QAAQ,CAAC,0BAA0B,cAahC;IACH,QAAQ,CAAC,uBAAuB,cAa7B;IAEH,OAAO,CAAC,WAAW,EAAE,MAAM,GAAG,QAAQ,CASrC;CACJ"}

package/esm/types/typeModel.js

@@ -0,0 +1,84 @@
+// (C) 2022-2026 GoodData Corporation
+import { MaqlType } from "./hierarchy.js";
+/**
+ * Simplified logical model which holds MAQL type information
+ */
+export class TypeModel {
+    granularities = new DatetimeGranularities();
+    labelSet;
+    dateLabelSet;
+    constructor(labels = [], dateLabels = []) {
+        this.labelSet = new Set(labels);
+        this.dateLabelSet = new Set(dateLabels);
+    }
+    getType(objectType, id) {
+        switch (objectType) {
+            case "dataset":
+                return MaqlType.DATASET;
+            case "fact":
+                return MaqlType.NUMERIC;
+            case "attribute":
+            case "label":
+                if (this.labelSet.has(id)) {
+                    return MaqlType.STRING;
+                }
+                else if (this.dateLabelSet.has(id)) {
+                    return MaqlType.DATE;
+                }
+                else {
+                    // Unrecognized ID, we can make no further claims
+                    return MaqlType.STRING_AND_DATE;
+                }
+            case "computedAttribute":
+                // A computed attribute buckets rows into string values.
+                return MaqlType.STRING;
+            case "metric":
+                // TODO add option to resolve metric type
+                return MaqlType.ALL;
+            default:
+                return MaqlType.ALL;
+        }
+    }
+}
+export class DatetimeGranularities {
+    chronologicalGranularities = new Set([
+        "timestamp",
+        "second",
+        "minute",
+        "hour",
+        "day",
+        "month",
+        "year",
+        "quarter",
+        "week",
+        "fiscalyear",
+        "fiscalquarter",
+        "fiscalmonth",
+    ]);
+    periodicalGranularities = new Set([
+        "secondofminute",
+        "secondofday",
+        "minuteofhour",
+        "minuteofday",
+        "hourofday",
+        "dayofweek",
+        "dayofmonth",
+        "dayofquarter",
+        "dayofyear",
+        "weekofyear",
+        "monthofyear",
+        "quarterofyear",
+    ]);
+    getType(granularity) {
+        const value = granularity.toLowerCase();
+        if (this.chronologicalGranularities.has(value)) {
+            return MaqlType.CHRONOLOGICAL_GRANULARITY;
+        }
+        else if (this.periodicalGranularities.has(value)) {
+            return MaqlType.PERIODICAL_GRANULARITY;
+        }
+        else {
+            return MaqlType.GRANULARITY;
+        }
+    }
+}

package/package.json

@@ -1,6 +1,92 @@
 {
   "name": "@gooddata/sdk-maql-language-server",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "11.65.0-alpha.4",
+  "license": "MIT",
+  "author": {
+    "name": "Stellar",
+    "email": "stellar@gooddata.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/gooddata/gooddata-ui-sdk.git",
+    "directory": "libs/sdk-maql-language-server"
+  },
+  "files": [
+    "esm",
+    "README.md"
+  ],
+  "type": "module",
+  "main": "esm/index.js",
+  "browser": "esm/index.js",
+  "types": "esm/index.d.ts",
+  "dependencies": {
+    "@gooddata/maql-antlr4ts": "0.5.1-02977c25.0",
+    "antlr4-c3": "1.1.16",
+    "antlr4ts": "0.5.0-alpha.4",
+    "assert": "2.1.0",
+    "lodash-es": "^4.17.23",
+    "util": "0.12.5",
+    "vscode-languageserver": "8.1.0",
+    "vscode-languageserver-textdocument": "1.0.12",
+    "@gooddata/sdk-backend-base": "11.65.0-alpha.4",
+    "@gooddata/sdk-backend-spi": "11.65.0-alpha.4",
+    "@gooddata/sdk-backend-tiger": "11.65.0-alpha.4",
+    "@gooddata/sdk-model": "11.65.0-alpha.4"
+  },
+  "devDependencies": {
+    "@types/isomorphic-fetch": "0.0.39",
+    "@types/lodash-es": "4.17.12",
+    "@types/node": "24.12.0",
+    "@typescript-eslint/eslint-plugin": "8.58.0",
+    "@typescript-eslint/parser": "8.58.0",
+    "@vitest/coverage-v8": "5.0.4",
+    "colors": "1.4.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-headers": "1.3.3",
+    "eslint-plugin-import-esm": "1.2.1",
+    "eslint-plugin-jsdoc": "62.1.0",
+    "eslint-plugin-no-barrel-files": "1.2.2",
+    "eslint-plugin-no-only-tests": "3.3.0",
+    "eslint-plugin-regexp": "1.15.0",
+    "eslint-plugin-sonarjs": "3.0.6",
+    "eslint-plugin-tsdoc": "0.2.14",
+    "glob": "13.0.2",
+    "jiti": "2.6.1",
+    "lint-staged": "10.5.4",
+    "npm-run-all": "4.1.5",
+    "oxfmt": "0.68.0",
+    "oxlint": "1.83.0",
+    "oxlint-plugin-eslint": "1.82.0",
+    "oxlint-tsgolint": "7.0.2001",
+    "process": "0.11.10",
+    "rolldown": "1.0.3",
+    "ts-dedent": "2.3.0",
+    "ts-node": "10.9.2",
+    "tslib": "2.8.1",
+    "typescript": "7.0.2",
+    "vite": "8.0.16",
+    "vitest": "5.0.4",
+    "@gooddata/eslint-config": "11.65.0-alpha.4",
+    "@gooddata/api-client-tiger": "11.65.0-alpha.4",
+    "@gooddata/oxlint-config": "11.65.0-alpha.4",
+    "@gooddata/stylelint-config": "11.65.0-alpha.4"
+  },
+  "scripts": {
+    "_phase:build": "npm run build",
+    "_phase:test": "npm run test-once",
+    "_phase:validate": "npm run validate",
+    "build": "npm-run-all -p build-check build-ts",
+    "build-check": "tsc -p tsconfig.check.json",
+    "build-ts": "tsc -p ./tsconfig.build.json",
+    "clean": "../../common/scripts/clean-command-state.sh && rm -rf esm *.log",
+    "format-check": "oxfmt --check .",
+    "format-write": "oxfmt .",
+    "lint": "oxlint . --quiet && eslint .",
+    "lint-fix": "oxlint . --quiet --fix && eslint . --fix",
+    "test": "vitest",
+    "test-once": "vitest run",
+    "update-docs": "tsc -p ./scripts && node scripts/build/docsParser.js src/docs",
+    "validate": "npm run lint && npm run format-check",
+    "watch": "tsc -watch -p ./tsconfig.build.json"
+  }
 }