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

package/esm/metadata/model.d.ts

@@ -0,0 +1,162 @@
+import { type IElementsQueryOptions } from "@gooddata/sdk-backend-spi";
+import { type TigerObjectType } from "@gooddata/sdk-backend-tiger";
+import { type DateAttributeGranularity, type IAttributeDisplayFormMetadataObject, type IAttributeElement, type IAttributeMetadataObject, type ICatalogAttribute, type ICatalogDateDataset, type ICatalogFact, type ICatalogMeasure, type IComputedAttributeMetadataObject, type IFactMetadataObject, type IMeasureMetadataObject, type IMetadataObject, type IParameterMetadataObject } from "@gooddata/sdk-model";
+/**
+ * @internal
+ */
+export interface ITigerMetadataObject extends IMetadataObject {
+    tigerType: TigerObjectType;
+}
+/**
+ * @internal
+ */
+export type ITigerMetadataObjectStub = Pick<ITigerMetadataObject, "id" | "ref"> & Partial<ITigerMetadataObject>;
+/**
+ * @internal
+ */
+export interface ITigerAttribute extends IAttributeMetadataObject, ITigerMetadataObject {
+    type: "attribute";
+    tigerType: "attribute";
+    tigerTypeModifier?: "date";
+    granularity?: DateAttributeGranularity;
+}
+/**
+ * @internal
+ */
+export interface ITigerLabel extends IAttributeDisplayFormMetadataObject, ITigerMetadataObject {
+    type: "displayForm";
+    tigerType: "label";
+    tigerTypeModifier?: "date";
+    granularity?: DateAttributeGranularity;
+}
+export interface ITigerDateLabel extends ITigerLabel {
+    tigerTypeModifier: "date";
+}
+/**
+ * @internal
+ */
+export interface ITigerFact extends IFactMetadataObject, ITigerMetadataObject {
+    type: "fact";
+    tigerType: "fact";
+}
+/**
+ * @internal
+ */
+export interface ITigerDataset extends ITigerMetadataObject {
+    type: "dataSet";
+    tigerType: "dataset";
+}
+/**
+ * @internal
+ */
+export interface ITigerMetric extends IMeasureMetadataObject, ITigerMetadataObject {
+    type: "measure";
+    tigerType: "metric";
+}
+/**
+ * A computed attribute is referenced from MAQL by its own type rather than through a label - it has
+ * no real labels. In MAQL text the type is spelled `computed_attribute`, which
+ * {@link normalizeMaqlObjectType} translates into the `computedAttribute` Tiger type used here.
+ *
+ * @internal
+ */
+export interface ITigerComputedAttribute extends IComputedAttributeMetadataObject, ITigerMetadataObject {
+    type: "computedAttribute";
+    tigerType: "computedAttribute";
+}
+/**
+ * @internal
+ */
+export interface ITigerParameter extends IParameterMetadataObject, ITigerMetadataObject {
+    type: "parameter";
+    tigerType: "parameter";
+}
+export declare function isITigerAttribute(object: ITigerMetadataObject): object is ITigerAttribute;
+export declare function isITigerLabel(object: ITigerMetadataObject): object is ITigerLabel;
+export declare function isITigerDateLabel(object: ITigerMetadataObject): object is ITigerDateLabel;
+export declare function isITigerFact(object: ITigerMetadataObject): object is ITigerFact;
+export declare function isITigerMetric(object: ITigerMetadataObject): object is ITigerMetric;
+export declare function isITigerComputedAttribute(object: ITigerMetadataObject): object is ITigerComputedAttribute;
+/**
+ * @internal
+ */
+export declare function isITigerParameter(object: ITigerMetadataObject): object is ITigerParameter;
+/**
+ * The dataset fields that MAQL completion uses. SPI dataset metadata objects and declarative
+ * datasets both have them.
+ *
+ * @internal
+ */
+export interface ILdmDataset {
+    id: string;
+    title: string;
+    description?: string;
+}
+/**
+ * @internal
+ */
+export declare class LdmObjects {
+    private readonly attributes;
+    private readonly labels;
+    private readonly facts;
+    private readonly metrics;
+    private readonly computedAttributes;
+    private readonly parameters;
+    private readonly datasets;
+    readonly size: number;
+    constructor(attributes: ICatalogAttribute[], facts: ICatalogFact[], metrics: ICatalogMeasure[], parameters: IParameterMetadataObject[], dates: ICatalogDateDataset[], datasets: ILdmDataset[], computedAttributes?: IComputedAttributeMetadataObject[]);
+    get(type: "attribute", typeModifier?: TypeModifiers): ITigerAttribute[];
+    get(type: "label", typeModifier?: TypeModifiers): ITigerLabel[];
+    get(type: "fact", typeModifier?: undefined): ITigerFact[];
+    get(type: "dataset", typeModifier?: undefined): ITigerDataset[];
+    get(type: "metric", typeModifier?: undefined): ITigerMetric[];
+    get(type: "computedAttribute", typeModifier?: undefined): ITigerComputedAttribute[];
+    get(type: "parameter", typeModifier?: undefined): ITigerParameter[];
+    get(type: TigerObjectType, typeModifier?: TypeModifiers): ITigerMetadataObject[] | undefined;
+    findObject(object: ITigerMetadataObjectStub): ITigerMetadataObject | undefined;
+    findById(type: "metric", id: string): ITigerMetric | undefined;
+    findById(type: "parameter", id: string): ITigerParameter | undefined;
+    findById(type: TigerObjectType, id: string): ITigerMetadataObject | undefined;
+    private processAttributes;
+    private processDates;
+    private static toTigerMetadataObject;
+    private static toTigerDataset;
+}
+/**
+ * @internal
+ */
+export interface IMetadataObjectStruct<T extends IMetadataObject> {
+    regular: T[];
+    date: T[];
+    all: T[];
+}
+/**
+ * @internal
+ */
+export type TypeModifiers = keyof IMetadataObjectStruct<IMetadataObject>;
+/**
+ * @param labels - label objects for which to get elements
+ * @param excluded - label elements which should be filtered out from the result
+ * @param options - label elements API advanced query options
+ * @internal
+ */
+export type LabelElementsFunc = <T extends ITigerMetadataObjectStub>(labels: T[], excluded: string[], options: IElementsQueryOptions, limit?: number, offset?: number) => Promise<ILabelElementsFuncResult<T>>;
+/**
+ * @internal
+ */
+export interface ILabelElementsFuncResult<T extends ITigerMetadataObjectStub> {
+    list: ILabelElementList;
+    rejected: T[];
+    /**
+     * Errors the elements queries of the rejected labels failed with
+     */
+    rejectionReasons?: Map<T, unknown>;
+}
+/**
+ * @internal
+ */
+export interface ILabelElementList {
+    elements: IAttributeElement[];
+    isIncomplete: boolean;
+}
+//# sourceMappingURL=model.d.ts.map

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

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

package/esm/metadata/model.js

@@ -0,0 +1,143 @@
+// (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";
+}
+/**
+ * @internal
+ */
+export function isITigerParameter(object) {
+    return object.tigerType === "parameter";
+}
+/**
+ * @internal
+ */
+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;AAE7F,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,37 @@
+// (C) 2026 GoodData Corporation
+import { escapeString } from "@gooddata/maql-antlr4ts";
+import { isStringParameterDefinition } from "@gooddata/sdk-model";
+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,16 @@
+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
+ *
+ * @internal
+ */
+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;;;;;;;GAOG;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,56 @@
+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";
+/**
+ * @internal
+ */
+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;
+}
+/**
+ * @internal
+ */
+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;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACpC;;;;;OAKG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACtC;AAED;;GAEG;AACH,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,159 @@
+// (C) 2021-2026 GoodData Corporation
+import { DefaultWorkspaceCatalogTypes, } from "@gooddata/sdk-backend-spi";
+import { LdmObjects, } from "./metadata/model.js";
+/**
+ * @internal
+ */
+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"}