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

package/esm/metadata/model.js

@@ -0,0 +1,137 @@
+// (C) 2021-2026 GoodData Corporation
+import { objectTypeToTigerIdType } from "@gooddata/sdk-backend-tiger";
+import { areObjRefsEqual, } from "@gooddata/sdk-model";
+export function isITigerAttribute(object) {
+    return object.tigerType === "attribute";
+}
+export function isITigerLabel(object) {
+    return object.tigerType === "label";
+}
+export function isITigerDateLabel(object) {
+    return isITigerLabel(object) && object.tigerTypeModifier === "date";
+}
+export function isITigerFact(object) {
+    return object.tigerType === "fact";
+}
+export function isITigerMetric(object) {
+    return object.tigerType === "metric";
+}
+export function isITigerComputedAttribute(object) {
+    return object.tigerType === "computedAttribute";
+}
+export function isITigerParameter(object) {
+    return object.tigerType === "parameter";
+}
+export class LdmObjects {
+    attributes;
+    labels;
+    facts;
+    metrics;
+    computedAttributes;
+    parameters;
+    datasets;
+    size;
+    constructor(attributes, facts, metrics, parameters, dates, datasets, computedAttributes = []) {
+        const processedAttributes = this.processAttributes(attributes);
+        const processedDates = this.processDates(dates);
+        const regularAttributes = processedAttributes.flatMap((item) => item.attributes);
+        const dateAttributes = processedDates.flatMap((item) => item.attributes);
+        this.attributes = {
+            regular: regularAttributes,
+            date: dateAttributes,
+            all: regularAttributes.concat(dateAttributes),
+        };
+        const regularLabels = processedAttributes.flatMap((item) => item.labels);
+        const dateLabels = processedDates.flatMap((item) => item.labels);
+        this.labels = {
+            regular: regularLabels,
+            date: dateLabels,
+            all: regularLabels.concat(dateLabels),
+        };
+        this.facts = facts.map((fact) => LdmObjects.toTigerMetadataObject(fact.fact));
+        this.metrics = metrics.map((metric) => LdmObjects.toTigerMetadataObject(metric.measure));
+        this.computedAttributes = computedAttributes.map((computedAttribute) => LdmObjects.toTigerMetadataObject(computedAttribute));
+        this.parameters = parameters.map((parameter) => LdmObjects.toTigerMetadataObject(parameter));
+        this.datasets = datasets.map((dataset) => LdmObjects.toTigerDataset(dataset));
+        this.size =
+            this.attributes.all.length +
+                this.labels.all.length +
+                this.facts.length +
+                this.metrics.length +
+                this.computedAttributes.length +
+                this.parameters.length;
+    }
+    get(type, typeModifier = "all") {
+        switch (type) {
+            case "attribute":
+                return this.attributes[typeModifier];
+            case "fact":
+                return this.facts;
+            case "metric":
+                return this.metrics;
+            case "computedAttribute":
+                return this.computedAttributes;
+            case "parameter":
+                return this.parameters;
+            case "dataset":
+                return this.datasets;
+            case "label":
+                return this.labels[typeModifier];
+            default:
+                return undefined;
+        }
+    }
+    findObject(object) {
+        if (!object.tigerType) {
+            return undefined;
+        }
+        const objects = this.get(object.tigerType);
+        return objects?.find((tigerObject) => areObjRefsEqual(tigerObject.ref, object.ref));
+    }
+    findById(type, id) {
+        return this.get(type)?.find((object) => object.id === id);
+    }
+    processAttributes(attributes) {
+        return attributes.flatMap((attribute) => ({
+            attributes: [LdmObjects.toTigerMetadataObject(attribute.attribute)],
+            labels: attribute.displayForms.flatMap((label) => LdmObjects.toTigerMetadataObject(label)),
+        }));
+    }
+    processDates(dates) {
+        return dates.flatMap((date) => ({
+            attributes: dates.flatMap((date) => date.dateAttributes.map((attr) => ({
+                tigerTypeModifier: "date",
+                granularity: attr.granularity,
+                ...LdmObjects.toTigerMetadataObject(attr.attribute),
+            }))),
+            labels: date.dateAttributes.flatMap((dateAttr) => dateAttr.attribute.displayForms.map((label) => ({
+                tigerTypeModifier: "date",
+                granularity: dateAttr.granularity,
+                ...LdmObjects.toTigerMetadataObject(label),
+            }))),
+        }));
+    }
+    static toTigerMetadataObject(metadataObject) {
+        return {
+            tigerType: objectTypeToTigerIdType[metadataObject.type],
+            ...metadataObject,
+        };
+    }
+    static toTigerDataset(dataset) {
+        return {
+            type: "dataSet",
+            tigerType: "dataset",
+            id: dataset.id,
+            title: dataset.title,
+            description: dataset.description || "",
+            deprecated: false,
+            production: true,
+            ref: {
+                type: "dataSet",
+                identifier: dataset.id,
+            },
+            unlisted: false,
+            uri: "",
+        };
+    }
+}

package/esm/metadata/parameters.d.ts

@@ -0,0 +1,16 @@
+import { type IParameterDefinition } from "@gooddata/sdk-model";
+export declare function parameterTypeLabel(definition: IParameterDefinition): string;
+export declare function parameterDefaultLabel(definition: IParameterDefinition): string;
+export declare function parameterSummary(definition: IParameterDefinition): string;
+/**
+ * Whether a definition describes a default that can be written into MAQL. A parameter file being
+ * edited reaches us with a type it has not finished, or a default of the wrong kind for the type it
+ * declares, neither of which the declared type admits.
+ */
+export declare function isRenderableDefinition(definition: unknown): definition is IParameterDefinition;
+/**
+ * The parameter's default as it would be written in MAQL: string defaults quoted and escaped,
+ * numeric ones bare.
+ */
+export declare function parameterMaqlLiteral(definition: IParameterDefinition): string;
+//# sourceMappingURL=parameters.d.ts.map

package/esm/metadata/parameters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../src/metadata/parameters.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,KAAK,oBAAoB,EAA+B,MAAM,qBAAqB,CAAC;AAI7F,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,CAE3E;AAED,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,CAE9E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,CAEzE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,OAAO,GAAG,UAAU,IAAI,oBAAoB,CAU9F;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,CAI7E"}

package/esm/metadata/parameters.js

@@ -0,0 +1,38 @@
+// (C) 2026 GoodData Corporation
+import MaqlPkg from "@gooddata/maql-antlr4ts";
+import { isStringParameterDefinition } from "@gooddata/sdk-model";
+const { escapeString } = MaqlPkg;
+export function parameterTypeLabel(definition) {
+    return definition.type.toLowerCase();
+}
+export function parameterDefaultLabel(definition) {
+    return JSON.stringify(definition.defaultValue);
+}
+export function parameterSummary(definition) {
+    return `${parameterTypeLabel(definition)}, default: ${parameterDefaultLabel(definition)}`;
+}
+/**
+ * Whether a definition describes a default that can be written into MAQL. A parameter file being
+ * edited reaches us with a type it has not finished, or a default of the wrong kind for the type it
+ * declares, neither of which the declared type admits.
+ */
+export function isRenderableDefinition(definition) {
+    const candidate = definition;
+    switch (candidate?.type) {
+        case "STRING":
+            return typeof candidate.defaultValue === "string";
+        case "NUMBER":
+            return typeof candidate.defaultValue === "number";
+        default:
+            return false;
+    }
+}
+/**
+ * The parameter's default as it would be written in MAQL: string defaults quoted and escaped,
+ * numeric ones bare.
+ */
+export function parameterMaqlLiteral(definition) {
+    return isStringParameterDefinition(definition)
+        ? escapeString(definition.defaultValue, '"')
+        : String(definition.defaultValue);
+}

package/esm/metadata/types.d.ts

@@ -0,0 +1,14 @@
+import { type IAttributeOrMeasure } from "@gooddata/sdk-model";
+import { type LabelElementsFunc, type LdmObjects } from "./model.js";
+/**
+ * Interface to connect to Metadata API
+ * Internals do not matter for the service, only needed is the fact that
+ * the language service can asynchronously get typed identifiers and that it is able
+ * to force a refresh of the stored model
+ */
+export interface IMetadataInterface {
+    updateModel(): void;
+    getLdmObjects(items?: IAttributeOrMeasure[]): Promise<LdmObjects>;
+    getLabelElementsFunction(): Promise<LabelElementsFunc>;
+}
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/metadata/types.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAE/D,OAAO,EAAE,KAAK,iBAAiB,EAAE,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAErE;;;;;GAKG;AACH,MAAM,WAAW,kBAAkB;IAC/B,WAAW,IAAI,IAAI,CAAC;IAEpB,aAAa,CAAC,KAAK,CAAC,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAElE,wBAAwB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAAC;CAC1D"}

package/esm/metadata/types.js

@@ -0,0 +1,2 @@
+// (C) 2023-2026 GoodData Corporation
+export {};

package/esm/metadataService.d.ts

@@ -0,0 +1,50 @@
+import { type IAnalyticalBackend } from "@gooddata/sdk-backend-spi";
+import { type IAttributeOrMeasure } from "@gooddata/sdk-model";
+import { type LabelElementsFunc, LdmObjects } from "./metadata/model.js";
+import { type IMetadataInterface } from "./metadata/types.js";
+export interface IMetadataServiceOptions {
+    /**
+     * Resolved value of the enableComputedAttributes workspace setting. The computed-attributes
+     * catalog listing is gated by it on the backend, so when the host knows the setting is off the
+     * service does not request the type at all. Leave undefined when the setting is unknown: the
+     * service then requests computed attributes and degrades to the default type set on refusal.
+     */
+    enableComputedAttributes?: boolean;
+}
+export declare class MetadataService implements IMetadataInterface {
+    readonly workspaceId: string;
+    readonly backend: IAnalyticalBackend;
+    private readonly options;
+    private catalog?;
+    private ldmObjects;
+    private datasets;
+    private parameters;
+    /**
+     * The only construction path: the service runs on the backend injected by the host — the same
+     * instance (auth provider, caches and all) every other consumer of the host uses.
+     */
+    static withBackend(workspaceId: string, backend: IAnalyticalBackend, options?: IMetadataServiceOptions): MetadataService;
+    private constructor();
+    /**
+     * Gets all objects (facts, metrics, attributes and labels) from the
+     * declarative model retrieved from Metadata API.
+     */
+    getLdmObjects(items?: IAttributeOrMeasure[]): Promise<LdmObjects>;
+    /**
+     * Makes a new request to Metadata API for an updated declarative model.
+     * Refreshes stored objects from the received model.
+     */
+    updateModel(): void;
+    /**
+     * Makes a request to Catalog API to slice datasets for
+     * available items; doesn't update model with fresh data!
+     * Only updates ldmObjects.
+     */
+    sliceModel(items: IAttributeOrMeasure[]): Promise<LdmObjects>;
+    private getWholeCatalog;
+    /**
+     * Returns a function to later retrieve label elements
+     */
+    getLabelElementsFunction(): Promise<LabelElementsFunc>;
+}
+//# sourceMappingURL=metadataService.d.ts.map

package/esm/metadataService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadataService.d.ts","sourceRoot":"","sources":["../src/metadataService.ts"],"names":[],"mappings":"AAEA,OAAO,EAEH,KAAK,kBAAkB,EAI1B,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAEH,KAAK,mBAAmB,EAE3B,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAIH,KAAK,iBAAiB,EACtB,UAAU,EACb,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAAE,KAAK,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,MAAM,WAAW,uBAAuB;IACpC;;;;;OAKG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED,qBAAa,eAAgB,YAAW,kBAAkB;IAmBlD,QAAQ,CAAC,WAAW,EAAE,MAAM;IAC5B,QAAQ,CAAC,OAAO,EAAE,kBAAkB;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO;IApB5B,OAAO,CAAC,OAAO,CAAC,CAAoB;IACpC,OAAO,CAAC,UAAU,CAAsB;IACxC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,UAAU,CAAkC;IAEpD;;;OAGG;IACH,OAAc,WAAW,CACrB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,GAAE,uBAA4B,mBAGxC;IAED,OAAO,eASN;IAED;;;OAGG;IACU,aAAa,CAAC,KAAK,CAAC,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAE7E;IAED;;;OAGG;IACI,WAAW,IAAI,IAAI,CAEzB;IAED;;;;OAIG;IACI,UAAU,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,OAAO,CAAC,UAAU,CAAC,CAqBnE;YAEa,eAAe;IAkE7B;;OAEG;IACI,wBAAwB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CAgD5D;CACJ"}

package/esm/metadataService.js

@@ -0,0 +1,156 @@
+// (C) 2021-2026 GoodData Corporation
+import { DefaultWorkspaceCatalogTypes, } from "@gooddata/sdk-backend-spi";
+import { LdmObjects, } from "./metadata/model.js";
+export class MetadataService {
+    workspaceId;
+    backend;
+    options;
+    catalog; // holds the entire unprocessed catalog
+    ldmObjects; // LDM objects holds latest parsed objects to be used further
+    datasets = [];
+    parameters = [];
+    /**
+     * The only construction path: the service runs on the backend injected by the host — the same
+     * instance (auth provider, caches and all) every other consumer of the host uses.
+     */
+    static withBackend(workspaceId, backend, options = {}) {
+        return new MetadataService(workspaceId, backend, options);
+    }
+    constructor(workspaceId, backend, options) {
+        this.workspaceId = workspaceId;
+        this.backend = backend;
+        this.options = options;
+        this.catalog = undefined;
+        this.ldmObjects = this.getWholeCatalog();
+        this.sliceModel = this.sliceModel.bind(this);
+        this.getLdmObjects = this.getLdmObjects.bind(this);
+    }
+    /**
+     * Gets all objects (facts, metrics, attributes and labels) from the
+     * declarative model retrieved from Metadata API.
+     */
+    async getLdmObjects(items) {
+        return items && items.length > 0 ? this.sliceModel(items) : this.ldmObjects;
+    }
+    /**
+     * Makes a new request to Metadata API for an updated declarative model.
+     * Refreshes stored objects from the received model.
+     */
+    updateModel() {
+        this.ldmObjects = this.getWholeCatalog();
+    }
+    /**
+     * Makes a request to Catalog API to slice datasets for
+     * available items; doesn't update model with fresh data!
+     * Only updates ldmObjects.
+     */
+    sliceModel(items) {
+        if (!this.catalog || items.length === 0) {
+            return this.ldmObjects;
+        }
+        return this.catalog
+            .availableItems()
+            .forItems(items)
+            .load()
+            .then((catalog) => {
+            return new LdmObjects(catalog.availableAttributes(), catalog.availableFacts(), catalog.availableMeasures(), this.parameters, catalog.availableDateDatasets(), this.datasets, catalog.availableComputedAttributes().map((item) => item.computedAttribute));
+            // TODO: Handling errors (when nothing is found, etc.)
+        })
+            .catch(() => this.ldmObjects);
+    }
+    async getWholeCatalog() {
+        // Origin ALL includes the datasets inherited from parent workspaces. Completion lists the
+        // NORMAL and AUXILIARY datasets; date datasets come from the catalog. A backend without the
+        // service throws synchronously, and a failed listing removes only the dataset completion.
+        const listDatasets = (dataSetType) => this.backend
+            .workspace(this.workspaceId)
+            .datasets()
+            .getDatasetsQuery()
+            .withOrigin("ALL")
+            .withFilter({ dataSetType })
+            .withSize(1000)
+            .query()
+            .then((result) => result.all());
+        const datasetsPromise = Promise.resolve()
+            .then(() => Promise.all([listDatasets("NORMAL"), listDatasets("AUXILIARY")]))
+            .then((lists) => lists.flat())
+            .catch(() => []);
+        const parametersPromise = this.backend
+            .workspace(this.workspaceId)
+            .parameters()
+            .getParametersQuery()
+            .withSize(2000)
+            .query()
+            .then((result) => result.all())
+            .catch(() => []);
+        // Computed attributes are opt-in on the catalog, so the default type set must be requested
+        // alongside them; the requested types also drive what availableItems() (used by
+        // sliceModel) asks the backend to validate. The listing is gated by the
+        // enableComputedAttributes setting: when the host resolved it as off, skip the request
+        // entirely (the backend would refuse it with a 400 logged to the console). Otherwise a
+        // backend can still reject it (setting race, older backend), and a single rejected loader
+        // fails the whole catalog load - fall back to the default type set rather than losing
+        // completion and validation entirely.
+        const catalogFactory = this.backend.workspace(this.workspaceId).catalog();
+        const catalogPromise = this.options.enableComputedAttributes === false
+            ? catalogFactory.load()
+            : catalogFactory
+                .forTypes([...DefaultWorkspaceCatalogTypes, "computedAttribute"])
+                .load()
+                .catch(() => catalogFactory.load());
+        const [datasets, catalog, parameters] = await Promise.all([
+            datasetsPromise,
+            catalogPromise,
+            parametersPromise,
+        ]);
+        this.datasets = datasets;
+        this.catalog = catalog;
+        this.parameters = parameters;
+        return new LdmObjects(catalog.attributes(), catalog.facts(), catalog.measures(), parameters, catalog.dateDatasets(), this.datasets, catalog.computedAttributes().map((item) => item.computedAttribute));
+    }
+    /**
+     * Returns a function to later retrieve label elements
+     */
+    getLabelElementsFunction() {
+        const queryFactory = this.backend.workspace(this.workspaceId).attributes().elements();
+        return Promise.resolve(async (labels, excluded, options, limit, offset) => {
+            const settled = await Promise.allSettled(labels.map((label) => {
+                let query = queryFactory.forDisplayForm(label.ref).withOptions(options);
+                if (limit)
+                    query = query.withLimit(limit);
+                if (offset)
+                    query = query.withOffset(offset);
+                return query.query();
+            }));
+            const rejected = [];
+            const rejectionReasons = new Map();
+            const results = settled
+                .map((result, idx) => {
+                if (result.status === "fulfilled") {
+                    return result.value;
+                }
+                else if (result.status === "rejected") {
+                    rejected.push(labels[idx]);
+                    rejectionReasons.set(labels[idx], result.reason);
+                }
+                return null;
+            })
+                .filter((elements) => !!elements);
+            const elements = results
+                .map((result) => result.items)
+                .flat()
+                .filter((element) => element.title === null || !excluded.includes(element.title)); // Filter out already typed strings
+            const isIncomplete = results
+                .map((result) => result.offset + result.limit < result.totalCount)
+                .reduce((prev, curr) => prev || curr, false);
+            return {
+                list: {
+                    elements: elements,
+                    isIncomplete: isIncomplete,
+                },
+                rejected: rejected,
+                rejectionReasons: rejectionReasons,
+            };
+        });
+    }
+}

package/esm/node/main.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=main.d.ts.map

package/esm/node/main.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.d.ts","sourceRoot":"","sources":["../../src/node/main.ts"],"names":[],"mappings":""}

package/esm/node/main.js

@@ -0,0 +1,18 @@
+// (C) 2021-2026 GoodData Corporation
+import * as process from "process";
+import { ProposedFeatures, createConnection } from "vscode-languageserver/node.js";
+import { TigerTokenAuthProvider, tigerFactory } from "@gooddata/sdk-backend-tiger";
+import { startServer } from "../maqlServer.js";
+import { MetadataService } from "../metadataService.js";
+const connection = createConnection(ProposedFeatures.all);
+connection.tracer.log("Connected to the MAQL language server");
+const endpoint = process.env["TIGER_ENDPOINT"] ?? "http://localhost:3000";
+const workspaceId = process.env["TIGER_WORKSPACE_ID"] ?? "demo";
+const apiToken = process.env["TIGER_API_TOKEN"] ?? "YWRtaW46Ym9vdHN0cmFwOmFkbWluMTIz";
+// The standalone Node entry is its own host, so building a backend here is legitimate — this is
+// the one place in the package that owns authentication.
+const backend = tigerFactory(undefined, { packageName: "@gooddata/sdk-maql-language-server" })
+    .onHostname(endpoint)
+    .withAuthentication(new TigerTokenAuthProvider(apiToken));
+const metadataService = MetadataService.withBackend(workspaceId, backend);
+startServer(connection, metadataService);

package/esm/parameterConstraints.d.ts

@@ -0,0 +1,5 @@
+import { Diagnostic } from "vscode-languageserver";
+import { type LdmObjects } from "./metadata/model.js";
+import { type MaqlMetric } from "./parseMaql.js";
+export declare function validateParameterConstraints(metric: MaqlMetric, ldmObjects: LdmObjects): Diagnostic[];
+//# sourceMappingURL=parameterConstraints.d.ts.map

package/esm/parameterConstraints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parameterConstraints.d.ts","sourceRoot":"","sources":["../src/parameterConstraints.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAkC,MAAM,uBAAuB,CAAC;AAcnF,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,EAAE,CAarG"}

package/esm/parameterConstraints.js

@@ -0,0 +1,198 @@
+// (C) 2026 GoodData Corporation
+import { groupBy } from "lodash-es";
+import { Diagnostic, DiagnosticSeverity } from "vscode-languageserver";
+import MaqlPkg from "@gooddata/maql-antlr4ts";
+const { MaqlLexer } = MaqlPkg;
+import { isStringParameterDefinition } from "@gooddata/sdk-model";
+import { ErrorCodes, diagnosticsSource } from "./constants.js";
+import { AntlrRange, tokenRange } from "./tokenRanges.js";
+export function validateParameterConstraints(metric, ldmObjects) {
+    const hasConstrainedParameter = ldmObjects
+        .get("parameter")
+        .some((parameter) => isStringParameterDefinition(parameter.definition) &&
+        parameter.definition.constraints?.allowedValues?.length);
+    if (!hasConstrainedParameter) {
+        return [];
+    }
+    const caseNodes = findCaseNodes(metric.ast);
+    return caseNodes.flatMap((caseNode) => validateCase(caseNode, metric, ldmObjects));
+}
+function validateCase(caseNode, metric, ldmObjects) {
+    const { pairs, otherUse } = collectParameterUsage(caseNode);
+    const anchor = keywordRange(caseNode, metric);
+    const diagnostics = [];
+    for (const [parameterId, parameterPairs] of Object.entries(groupBy(pairs, (pair) => pair.parameterId))) {
+        const allowedValues = allowedValuesOf(parameterId, ldmObjects);
+        if (!allowedValues) {
+            continue;
+        }
+        for (const pair of parameterPairs) {
+            const notAllowed = notAllowedDiagnostic(pair, allowedValues);
+            if (notAllowed) {
+                diagnostics.push(notAllowed);
+            }
+        }
+        if (!anchor || otherUse.has(parameterId)) {
+            continue;
+        }
+        const covered = parameterPairs.map((pair) => pair.literal.value);
+        const uncovered = allowedValues.filter((value) => !covered.includes(value));
+        if (uncovered.length > 0) {
+            diagnostics.push(uncoveredDiagnostic(parameterId, uncovered, anchor));
+        }
+    }
+    return diagnostics;
+}
+function collectParameterUsage(caseNode) {
+    const usage = { pairs: [], otherUse: new Set() };
+    for (const branch of caseNode.branches) {
+        if (!isConditionalNode(branch)) {
+            continue;
+        }
+        const purePairs = pureEqualityPairs(branch.condition);
+        if (purePairs) {
+            usage.pairs.push(...purePairs);
+        }
+        else {
+            collectFromCondition(branch.condition, usage);
+        }
+    }
+    return usage;
+}
+function pureEqualityPairs(condition) {
+    if (isParenthesizedNode(condition)) {
+        const [inner] = condition.content;
+        return inner && condition.content.length === 1 ? pureEqualityPairs(inner) : undefined;
+    }
+    if (isEqualityNode(condition)) {
+        const pair = asParameterEquality(condition);
+        return pair ? [pair] : undefined;
+    }
+    if (isDisjunctionNode(condition)) {
+        const childPairs = [];
+        for (const child of condition.content) {
+            const pairs = pureEqualityPairs(child);
+            if (!pairs) {
+                return undefined;
+            }
+            childPairs.push(...pairs);
+        }
+        const [first, ...rest] = childPairs;
+        return first && rest.every((pair) => pair.parameterId === first.parameterId) ? childPairs : undefined;
+    }
+    return undefined;
+}
+function collectFromCondition(node, usage) {
+    if (isCaseNode(node)) {
+        return;
+    }
+    if (isNegationNode(node)) {
+        for (const child of node.content) {
+            collectOpaqueUse(child, usage);
+        }
+        return;
+    }
+    if (isEqualityNode(node)) {
+        const pair = asParameterEquality(node);
+        if (pair) {
+            usage.pairs.push(pair);
+            usage.otherUse.add(pair.parameterId);
+            return;
+        }
+    }
+    const parameter = parameterIdentifierOf(node);
+    if (parameter) {
+        usage.otherUse.add(parameter.id);
+        return;
+    }
+    for (const child of node.content) {
+        collectFromCondition(child, usage);
+    }
+}
+function collectOpaqueUse(node, usage) {
+    if (isCaseNode(node)) {
+        return;
+    }
+    const parameter = parameterIdentifierOf(node);
+    if (parameter) {
+        usage.otherUse.add(parameter.id);
+        return;
+    }
+    for (const child of node.content) {
+        collectOpaqueUse(child, usage);
+    }
+}
+function asParameterEquality(node) {
+    if (node.content.length !== 2) {
+        return undefined;
+    }
+    const [left, right] = node.content;
+    const parameter = parameterIdentifierOf(left) ?? parameterIdentifierOf(right);
+    const literal = [left, right].find(isStringLiteralNode);
+    return parameter && literal ? { parameterId: parameter.id, literal } : undefined;
+}
+function parameterIdentifierOf(node) {
+    return isIdentifierNode(node) && node.objectType === "parameter" ? node : undefined;
+}
+function keywordRange(caseNode, metric) {
+    const astRange = caseNode.range;
+    if (!astRange) {
+        return undefined;
+    }
+    const token = metric.tokenStream
+        .getTokens()
+        .find((candidate) => candidate.line - 1 === astRange.start.line &&
+        candidate.charPositionInLine === astRange.start.character &&
+        (candidate.type === MaqlLexer.CASE || candidate.type === MaqlLexer.IF));
+    return token ? tokenRange(token) : undefined;
+}
+function allowedValuesOf(parameterId, ldmObjects) {
+    const parameter = ldmObjects.get("parameter").find((candidate) => candidate.id === parameterId);
+    if (!parameter || !isStringParameterDefinition(parameter.definition)) {
+        return undefined;
+    }
+    const allowedValues = parameter.definition.constraints?.allowedValues;
+    return allowedValues?.length ? allowedValues.map((allowed) => allowed.value) : undefined;
+}
+function notAllowedDiagnostic(pair, allowedValues) {
+    if (!pair.literal.range || allowedValues.includes(pair.literal.value)) {
+        return undefined;
+    }
+    return Diagnostic.create(AntlrRange.fromAstRange(pair.literal.range).toRange(), `"${pair.literal.value}" is not an allowed value of parameter '${pair.parameterId}' ` +
+        `(allowed: ${quoteValues(allowedValues)}) — this comparison can never match`, DiagnosticSeverity.Warning, ErrorCodes.ParameterValueNotAllowed, diagnosticsSource);
+}
+function uncoveredDiagnostic(parameterId, uncovered, anchor) {
+    return Diagnostic.create(anchor, `parameter '${parameterId}': allowed values ${quoteValues(uncovered)} ` +
+        "have no matching branch — they fall through to ELSE/NULL", DiagnosticSeverity.Information, ErrorCodes.ParameterValueUncovered, diagnosticsSource);
+}
+function quoteValues(allowedValues) {
+    return allowedValues.map((value) => `"${value}"`).join(", ");
+}
+function isCaseNode(node) {
+    return node.type === "case";
+}
+function isConditionalNode(node) {
+    return node.type === "when";
+}
+function isEqualityNode(node) {
+    return node.type === "=";
+}
+function isNegationNode(node) {
+    return node.type === "not";
+}
+function isDisjunctionNode(node) {
+    return node.type === "or";
+}
+function isParenthesizedNode(node) {
+    return node.type === "()";
+}
+function isIdentifierNode(node) {
+    return node.type === "identifier" || node.type === "raw identifier";
+}
+function isStringLiteralNode(node) {
+    return node.type === "string";
+}
+function findCaseNodes(node) {
+    const nested = node.content.flatMap(findCaseNodes);
+    return isCaseNode(node) ? [node, ...nested] : nested;
+}