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

package/esm/types/hierarchy.js

@@ -0,0 +1,165 @@
+// (C) 2021-2026 GoodData Corporation
+export var MaqlType;
+(function (MaqlType) {
+    /** Top type (supertype of all types) */
+    MaqlType[MaqlType["ANY"] = 0] = "ANY";
+    /** Abstract granularity type */
+    MaqlType[MaqlType["GRANULARITY"] = 1] = "GRANULARITY";
+    MaqlType[MaqlType["PERIODICAL_GRANULARITY"] = 2] = "PERIODICAL_GRANULARITY";
+    MaqlType[MaqlType["CHRONOLOGICAL_GRANULARITY"] = 3] = "CHRONOLOGICAL_GRANULARITY";
+    /** Abstract numeric type - facts, numbers, null */
+    MaqlType[MaqlType["NUMERIC"] = 4] = "NUMERIC";
+    /** Abstract string type - labels, strings, null */
+    MaqlType[MaqlType["STRING"] = 5] = "STRING";
+    /** Abstract date type - date labels, date strings, null */
+    MaqlType[MaqlType["DATE"] = 6] = "DATE";
+    /** Intersection of string and date, can be used as both */
+    MaqlType[MaqlType["STRING_AND_DATE"] = 7] = "STRING_AND_DATE";
+    MaqlType[MaqlType["NUMERIC_LITERAL"] = 8] = "NUMERIC_LITERAL";
+    MaqlType[MaqlType["INTEGER_LITERAL"] = 9] = "INTEGER_LITERAL";
+    MaqlType[MaqlType["STRING_LITERAL"] = 10] = "STRING_LITERAL";
+    MaqlType[MaqlType["NULL_LITERAL"] = 11] = "NULL_LITERAL";
+    MaqlType[MaqlType["DATASET"] = 12] = "DATASET";
+    MaqlType[MaqlType["BOOLEAN"] = 13] = "BOOLEAN";
+    /** Unit type - used for statements */
+    MaqlType[MaqlType["UNIT"] = 14] = "UNIT";
+    /** Bottom type (subtype of all types) - used for unresolvable nodes */
+    MaqlType[MaqlType["ALL"] = 15] = "ALL";
+})(MaqlType || (MaqlType = {}));
+/**
+ * Types representing values, such as numbers, texts, timestamps etc.
+ */
+export const abstractValueTypes = [MaqlType.NUMERIC, MaqlType.STRING, MaqlType.DATE];
+/**
+ * Direct supertypes of a type. `MaqlType.ANY` is always implicitly a supertype.
+ * All types are implicitly supertypes of `MaqlType.ALL`
+ */
+const supertypes = {
+    [MaqlType.ANY]: [],
+    [MaqlType.GRANULARITY]: [],
+    [MaqlType.NUMERIC]: [],
+    [MaqlType.STRING]: [],
+    [MaqlType.DATE]: [],
+    [MaqlType.STRING_AND_DATE]: [MaqlType.STRING, MaqlType.DATE],
+    [MaqlType.DATASET]: [],
+    [MaqlType.PERIODICAL_GRANULARITY]: [MaqlType.GRANULARITY],
+    [MaqlType.CHRONOLOGICAL_GRANULARITY]: [MaqlType.GRANULARITY],
+    [MaqlType.NUMERIC_LITERAL]: [MaqlType.NUMERIC],
+    [MaqlType.INTEGER_LITERAL]: [MaqlType.NUMERIC_LITERAL],
+    [MaqlType.STRING_LITERAL]: [MaqlType.STRING_AND_DATE],
+    [MaqlType.NULL_LITERAL]: [MaqlType.NUMERIC, MaqlType.STRING_AND_DATE],
+    [MaqlType.BOOLEAN]: [],
+    [MaqlType.UNIT]: [],
+    [MaqlType.ALL]: [],
+};
+/**
+ * MAQL types placed in a tree structure, where a child node is a subtype of the parent
+ */
+const typeHierarchy = constructTypeHierarchy();
+function constructTypeHierarchy() {
+    const typeMap = new Map();
+    Object.entries(supertypes).forEach(([type, supers]) => {
+        const maqlType = parseInt(type);
+        // do not use MaqlType.ALL and MaqlType.ANY in hierarchy, as they have special-case handling
+        if (supers.length === 0 && maqlType !== MaqlType.ANY && maqlType !== MaqlType.ALL) {
+            const children = typeMap.get(MaqlType.ANY) ?? [];
+            children.push(maqlType);
+            typeMap.set(MaqlType.ANY, children);
+        }
+        else {
+            supers.forEach((sup) => {
+                const children = typeMap.get(sup) ?? [];
+                children.push(maqlType);
+                typeMap.set(sup, children);
+            });
+        }
+    });
+    return typeHierarchyNode(MaqlType.ANY, typeMap);
+}
+function typeHierarchyNode(type, typeMap, depth = 0) {
+    const childTypes = typeMap.get(type) ?? [];
+    return {
+        type,
+        children: childTypes.map((childType) => typeHierarchyNode(childType, typeMap, depth + 1)),
+        depth,
+    };
+}
+const hierarchyPath = walk(typeHierarchy);
+/**
+ * Depth-first walk of the type hierarchy, which stores the path to the `path` argument. Includes repeated visits.
+ */
+function walk(node, path = []) {
+    path.push(node);
+    for (const child of node.children) {
+        walk(child, path);
+        path.push(node);
+    }
+    return path;
+}
+function handleSpecialCases(t1, t2) {
+    if (t1 === MaqlType.ANY || t2 === MaqlType.ANY) {
+        return MaqlType.ANY;
+    }
+    if (t1 === t2 || t2 === MaqlType.ALL) {
+        return t1;
+    }
+    if (t1 === MaqlType.ALL) {
+        return t2;
+    }
+    return null;
+}
+function updateRangesAccumulator(acc, node, idx) {
+    const isNewRange = acc.type !== undefined && node.type !== acc.type;
+    if (isNewRange) {
+        acc.ranges.push([acc.index ?? 0, idx]);
+    }
+    acc.type = node.type;
+    acc.index = idx;
+}
+// find the ranges between the occurrences of the types `t1` and `t2` on a DFS walk on the type hierarchy
+function findRangesBetweenTypes(t1, t2) {
+    const isTargetType = (type) => type === t1 || type === t2;
+    return hierarchyPath.reduce((acc, node, idx) => {
+        if (isTargetType(node.type)) {
+            updateRangesAccumulator(acc, node, idx);
+        }
+        return acc;
+    }, { ranges: [] }).ranges;
+}
+// for each range find a node in the hierarchy with the lowest depth - the roots of subtrees
+function findSubtreeRoots(ranges) {
+    return ranges.map(([start, end]) => {
+        // get the slice of the path between the two indexes
+        const pathRange = hierarchyPath.slice(start, end + 1);
+        return pathRange.reduce((min, next) => (next.depth < min.depth ? next : min));
+    });
+}
+// choose the deepest node from the roots - the lowest root that is ancestor to both `t1` and `t2`
+function findDeepestNode(nodes) {
+    return nodes.reduce((max, next) => (next.depth > max.depth ? next : max));
+}
+/**
+ * Solves the lowest common ancestor (LCA) problem on the MAQL type hierarchy tree for the types `t1` and `t2`
+ * Complexity: O(n*b) where n = number of types, b = branching factor (average number of subtypes per type)
+ */
+export function lowestCommonAncestor(t1, t2) {
+    const specialCase = handleSpecialCases(t1, t2);
+    if (specialCase !== null) {
+        return specialCase;
+    }
+    const ranges = findRangesBetweenTypes(t1, t2);
+    const subtreeRoots = findSubtreeRoots(ranges);
+    const deepestAncestor = findDeepestNode(subtreeRoots);
+    return deepestAncestor.type;
+}
+export function isSubtype(type, supertype) {
+    if (type === MaqlType.ALL) {
+        // special case - MaqlType.ALL is implicitly subtype of every type
+        return true;
+    }
+    return withSupertypes(type).includes(supertype);
+}
+function withSupertypes(type) {
+    const sups = supertypes[type].flatMap((supertype) => withSupertypes(supertype)) ?? [];
+    return [type, ...(sups.length > 0 ? sups : [MaqlType.ANY])];
+}

package/esm/types/signatures.d.ts

@@ -0,0 +1,40 @@
+import { type AstType, type FunctionAstType, type FunctionDefinition } from "@gooddata/maql-antlr4ts";
+import { MaqlType } from "./hierarchy.js";
+export interface IMaqlCallParameter {
+    type: MaqlType;
+}
+export declare enum CallNotation {
+    FUNCTION = 0,
+    PREFIX = 1,
+    INFIX = 2,
+    POSTFIX = 3
+}
+/**
+ * All necessary information to infer which function or operator should be used
+ */
+export declare class MaqlCallSignature {
+    readonly parameters: IMaqlCallParameter[];
+    readonly notation: CallNotation;
+    readonly name: string;
+    constructor(name: string, parameters: IMaqlCallParameter[], notation: CallNotation);
+    toString(): string;
+}
+/**
+ * Function or operator call definition, including its return parameter
+ */
+export declare class MaqlCallDefinition extends MaqlCallSignature {
+    readonly returns: IMaqlCallParameter;
+    readonly vararg: boolean;
+    constructor(name: string, parameters: IMaqlCallParameter[], returns: IMaqlCallParameter, notation: CallNotation, vararg: boolean);
+    static create(name: string, returnType: MaqlType, parameterTypes: MaqlType[], notation?: CallNotation, vararg?: boolean): MaqlCallDefinition;
+    toString(): string;
+}
+/**
+ * Returns MAQL function definitions of the given `astType` with `name` or empty array if none exist.
+ * @param astType -
+ * @param name -
+ */
+export declare function findFunctionDefinitions(astType: FunctionAstType, name: string): MaqlCallDefinition[];
+export declare function transformFunctionDefinition(definition: FunctionDefinition, name: string): MaqlCallDefinition;
+export declare function getCustomDefinitions(astType: AstType): MaqlCallDefinition[];
+//# sourceMappingURL=signatures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signatures.d.ts","sourceRoot":"","sources":["../../src/types/signatures.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,KAAK,OAAO,EACZ,KAAK,eAAe,EACpB,KAAK,kBAAkB,EAK1B,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,MAAM,WAAW,kBAAkB;IAC/B,IAAI,EAAE,QAAQ,CAAC;CAClB;AAED,oBAAY,YAAY;IACpB,QAAQ,IAAA;IACR,MAAM,IAAA;IACN,KAAK,IAAA;IACL,OAAO,IAAA;CACV;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAKtB,QAAQ,CAAC,UAAU,EAAE,kBAAkB,EAAE;IACzC,QAAQ,CAAC,QAAQ,EAAE,YAAY;IALnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,YACI,IAAI,EAAE,MAAM,EACH,UAAU,EAAE,kBAAkB,EAAE,EAChC,QAAQ,EAAE,YAAY,EAGlC;IAED,QAAQ,IAAI,MAAM,CAcjB;CACJ;AAED;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,iBAAiB;IAIjD,QAAQ,CAAC,OAAO,EAAE,kBAAkB;IAEpC,QAAQ,CAAC,MAAM,EAAE,OAAO;IAL5B,YACI,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,kBAAkB,EAAE,EACvB,OAAO,EAAE,kBAAkB,EACpC,QAAQ,EAAE,YAAY,EACb,MAAM,EAAE,OAAO,EAG3B;IAED,MAAM,CAAC,MAAM,CACT,IAAI,EAAE,MAAM,EACZ,UAAU,EAAE,QAAQ,EACpB,cAAc,EAAE,QAAQ,EAAE,EAC1B,QAAQ,eAAwB,EAChC,MAAM,UAAQ,GACf,kBAAkB,CAQpB;IAEQ,QAAQ,IAAI,MAAM,CAI1B;CACJ;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,eAAe,EAAE,IAAI,EAAE,MAAM,GAAG,kBAAkB,EAAE,CASpG;AAED,wBAAgB,2BAA2B,CACvC,UAAU,EAAE,kBAAkB,EAC9B,IAAI,EAAE,MAAM,GACb,kBAAkB,CAQpB;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,kBAAkB,EAAE,CA2E3E"}

package/esm/types/signatures.js

@@ -0,0 +1,141 @@
+// (C) 2021-2026 GoodData Corporation
+import { functionDefinitions, isMaqlFunctionName, } from "@gooddata/maql-antlr4ts";
+import { MaqlType } from "./hierarchy.js";
+export var CallNotation;
+(function (CallNotation) {
+    CallNotation[CallNotation["FUNCTION"] = 0] = "FUNCTION";
+    CallNotation[CallNotation["PREFIX"] = 1] = "PREFIX";
+    CallNotation[CallNotation["INFIX"] = 2] = "INFIX";
+    CallNotation[CallNotation["POSTFIX"] = 3] = "POSTFIX";
+})(CallNotation || (CallNotation = {}));
+/**
+ * All necessary information to infer which function or operator should be used
+ */
+export class MaqlCallSignature {
+    parameters;
+    notation;
+    name;
+    constructor(name, parameters, notation) {
+        this.parameters = parameters;
+        this.notation = notation;
+        this.name = name.toUpperCase();
+    }
+    toString() {
+        const paramTypes = this.parameters.map((param) => MaqlType[param.type]);
+        switch (this.notation) {
+            case CallNotation.FUNCTION:
+                return `${this.name}(${paramTypes.join(", ")})`;
+            case CallNotation.PREFIX:
+                return `${this.name} ${paramTypes.join(" ")}`;
+            case CallNotation.INFIX:
+                return paramTypes.length > 1
+                    ? paramTypes.join(` ${this.name} `)
+                    : `${this.name} ${paramTypes[0]}`;
+            case CallNotation.POSTFIX:
+                return `${paramTypes.join(" ")} ${this.name}`;
+        }
+    }
+}
+/**
+ * Function or operator call definition, including its return parameter
+ */
+export class MaqlCallDefinition extends MaqlCallSignature {
+    returns;
+    vararg;
+    constructor(name, parameters, returns, notation, vararg) {
+        super(name, parameters, notation);
+        this.returns = returns;
+        this.vararg = vararg;
+    }
+    static create(name, returnType, parameterTypes, notation = CallNotation.FUNCTION, vararg = false) {
+        return new MaqlCallDefinition(name, parameterTypes.map((type) => ({ type })), { type: returnType }, notation, vararg);
+    }
+    toString() {
+        const returnType = MaqlType[this.returns.type];
+        const signature = super.toString();
+        return `${signature} -> ${returnType}`;
+    }
+}
+/**
+ * Returns MAQL function definitions of the given `astType` with `name` or empty array if none exist.
+ * @param astType -
+ * @param name -
+ */
+export function findFunctionDefinitions(astType, name) {
+    const funcName = name.toUpperCase();
+    if (!isMaqlFunctionName(funcName, astType)) {
+        return [];
+    }
+    const astDefs = functionDefinitions[astType];
+    const funcDefs = astDefs[funcName] ?? [];
+    return funcDefs.map((def) => transformFunctionDefinition(def, funcName));
+}
+export function transformFunctionDefinition(definition, name) {
+    return new MaqlCallDefinition(name, definition.operands.map((param) => transformParameter(param)), transformParameter(definition.returns), CallNotation.FUNCTION, definition.vararg ?? false);
+}
+export function getCustomDefinitions(astType) {
+    switch (astType) {
+        case "+":
+        case "-":
+        case "*":
+        case "/":
+            return [
+                MaqlCallDefinition.create(astType, MaqlType.NUMERIC, [MaqlType.NUMERIC, MaqlType.NUMERIC], CallNotation.INFIX),
+            ];
+        case "not":
+            return [
+                MaqlCallDefinition.create(astType, MaqlType.BOOLEAN, [MaqlType.BOOLEAN], CallNotation.PREFIX),
+            ];
+        case "and":
+        case "or":
+            return [
+                MaqlCallDefinition.create(astType, MaqlType.BOOLEAN, [MaqlType.BOOLEAN, MaqlType.BOOLEAN], CallNotation.INFIX),
+            ];
+        case "=":
+        case "<>":
+        case ">=":
+        case "<=":
+        case "<":
+        case ">":
+            return [
+                MaqlCallDefinition.create(astType, MaqlType.BOOLEAN, [MaqlType.NUMERIC, MaqlType.NUMERIC], CallNotation.INFIX),
+                MaqlCallDefinition.create(astType, MaqlType.BOOLEAN, [MaqlType.STRING, MaqlType.STRING], CallNotation.INFIX),
+                MaqlCallDefinition.create(astType, MaqlType.BOOLEAN, [MaqlType.DATE, MaqlType.DATE], CallNotation.INFIX),
+            ];
+        case "like":
+        case "ilike":
+        case "not like":
+        case "not ilike":
+            return [
+                MaqlCallDefinition.create(astType, MaqlType.BOOLEAN, [MaqlType.STRING, MaqlType.STRING_LITERAL], CallNotation.INFIX),
+                MaqlCallDefinition.create(astType, MaqlType.BOOLEAN, [MaqlType.DATE, MaqlType.STRING_LITERAL], CallNotation.INFIX),
+            ];
+        default:
+            return [];
+    }
+}
+function transformParameter(parameter) {
+    return {
+        type: toMaqlType(parameter.type),
+    };
+}
+function toMaqlType(type) {
+    switch (type) {
+        case "NUMERIC":
+            return MaqlType.NUMERIC;
+        case "STRING":
+            return MaqlType.STRING;
+        case "DATE":
+            return MaqlType.DATE;
+        case "DATASET":
+            return MaqlType.DATASET;
+        case "GRANULARITY_LITERAL":
+            return MaqlType.GRANULARITY;
+        case "CHRONOLOGICAL_GRANULARITY_LITERAL":
+            return MaqlType.CHRONOLOGICAL_GRANULARITY;
+        case "NUMERIC_LITERAL":
+            return MaqlType.NUMERIC_LITERAL;
+        case "INTEGER_LITERAL":
+            return MaqlType.INTEGER_LITERAL;
+    }
+}

package/esm/types/typeChecking.d.ts

@@ -0,0 +1,54 @@
+import { AbstractAstVisitor, type AstNode, type BooleanLiteralNode, type CaseNode, type ConditionalNode, type EmptyNode, type ExpressionNode, type FilterNode, type FunctionNode, type GranularityNode, type IRange, type IdentifierNode, type LastFirstValueFunctionNode, type ListNode, type NullLiteralNode, type NumberLiteralNode, type OperatorNode, type OrderByElementNode, type RankFunctionNode, type RankingFilterNode, type RunningFunctionNode, type SelectNode, type StringLiteralNode } from "@gooddata/maql-antlr4ts";
+import { MaqlType } from "./hierarchy.js";
+import { type TypeModel } from "./typeModel.js";
+export interface ITypeConstraintsViolation {
+    readonly message: string;
+    readonly range?: IRange;
+}
+export declare class TypedAstNode {
+    readonly type: MaqlType;
+    readonly node: AstNode | null;
+    constructor(type: MaqlType, node: AstNode | null);
+}
+export declare class AstTypeChecker extends AbstractAstVisitor<TypedAstNode> {
+    readonly model: TypeModel;
+    constructor(model: TypeModel);
+    readonly typeConstraintsViolations: ITypeConstraintsViolation[];
+    defaultResult(): TypedAstNode;
+    protected mergeResultWithParent(parentNode: AstNode, result: TypedAstNode): TypedAstNode;
+    visitEmptyNode(node: EmptyNode): TypedAstNode;
+    visitSelectNode(node: SelectNode): TypedAstNode;
+    visitExpressionNode(node: ExpressionNode): TypedAstNode;
+    visitOperatorNode(node: OperatorNode): TypedAstNode;
+    private checkUnaryMinusOperator;
+    private checkBetween;
+    private checkIn;
+    visitListNode(node: ListNode): TypedAstNode;
+    visitFunctionNode(node: FunctionNode): TypedAstNode;
+    /**
+     * Checks functions and operators that have defined signatures.
+     */
+    private checkBySignature;
+    private findValidDefinitions;
+    visitRunningFunctionNode(node: RunningFunctionNode): TypedAstNode;
+    visitRankFunctionNode(node: RankFunctionNode): TypedAstNode;
+    visitLastFirstValueFunctionNode(node: LastFirstValueFunctionNode): TypedAstNode;
+    visitOrderByElement(node: OrderByElementNode): TypedAstNode;
+    visitRankingFilterNode(node: RankingFilterNode): TypedAstNode;
+    visitCaseNode(node: CaseNode): TypedAstNode;
+    visitConditionalNode(node: ConditionalNode): TypedAstNode;
+    visitIdentifierNode(node: IdentifierNode): TypedAstNode;
+    visitBooleanLiteralNode(node: BooleanLiteralNode): TypedAstNode;
+    visitNumberLiteralNode(node: NumberLiteralNode): TypedAstNode;
+    visitStringLiteralNode(node: StringLiteralNode): TypedAstNode;
+    visitNullLiteralNode(node: NullLiteralNode): TypedAstNode;
+    visitGranularityNode(node: GranularityNode): TypedAstNode;
+    visitFilterNode(node: FilterNode): TypedAstNode;
+    private findCompatibleSupertype;
+    private checkOperandCount;
+    private checkType;
+    private logIncompatibleSubtype;
+    private logUnexpectedOperandCount;
+    private logViolation;
+}
+//# sourceMappingURL=typeChecking.d.ts.map

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

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