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

package/esm/sdk-maql-language-server.d.ts

@@ -0,0 +1,496 @@
+import { CompletionItem } from 'vscode-languageserver';
+import { CompletionList } from 'vscode-languageserver';
+import { DateAttributeGranularity } from '@gooddata/sdk-model';
+import { Diagnostic } from 'vscode-languageserver';
+import { FormattingOptions } from 'vscode-languageserver';
+import { Hover } from 'vscode-languageserver';
+import { IAnalyticalBackend } from '@gooddata/sdk-backend-spi';
+import { IAttributeDisplayFormMetadataObject } from '@gooddata/sdk-model';
+import { IAttributeElement } from '@gooddata/sdk-model';
+import { IAttributeMetadataObject } from '@gooddata/sdk-model';
+import { IAttributeOrMeasure } from '@gooddata/sdk-model';
+import { ICatalogAttribute } from '@gooddata/sdk-model';
+import { ICatalogDateDataset } from '@gooddata/sdk-model';
+import { ICatalogFact } from '@gooddata/sdk-model';
+import { ICatalogMeasure } from '@gooddata/sdk-model';
+import { IComputedAttributeMetadataObject } from '@gooddata/sdk-model';
+import { IElementsQueryOptions } from '@gooddata/sdk-backend-spi';
+import { IFactMetadataObject } from '@gooddata/sdk-model';
+import { IMeasureMetadataObject } from '@gooddata/sdk-model';
+import { IMetadataObject } from '@gooddata/sdk-model';
+import { InitializeResult } from 'vscode-languageserver';
+import { IParameterMetadataObject } from '@gooddata/sdk-model';
+import { MarkupContent } from 'vscode-languageserver';
+import { ObjRef } from '@gooddata/sdk-model';
+import { Position } from 'vscode-languageserver-textdocument';
+import { Range as Range_2 } from 'vscode-languageserver';
+import { Range as Range_3 } from 'vscode-languageserver-textdocument';
+import { SemanticTokens } from 'vscode-languageserver';
+import { SemanticTokensLegend } from 'vscode-languageserver';
+import { TextDocument } from 'vscode-languageserver-textdocument';
+import { TextEdit } from 'vscode-languageserver';
+import { TigerObjectType } from '@gooddata/sdk-backend-tiger';
+
+/**
+ * @internal
+ */
+export declare type DecorationType = ITigerMetadataObject["tigerType"] | "dateAttribute" | "dateLabel";
+
+/**
+ * @internal
+ */
+export declare type HighlightToken = {
+    position: Range_2;
+    type: string;
+    modifiers: string[];
+};
+
+/**
+ * @internal
+ */
+export declare type HoverWithData = Hover & {
+    object: ObjectContent | null;
+};
+
+/**
+ * The decorations as defined in this file are heavily inspired by Monaco editor decorations.
+ */
+/**
+ * A decoration in the model.
+ *
+ * @internal
+ */
+export declare interface IDecoration {
+    /**
+     * Range that this decoration covers.
+     */
+    range: Range_2;
+    /**
+     * Options associated with this decoration.
+     */
+    options: IDecorationOptions;
+}
+
+/**
+ * Options for a decoration.
+ *
+ * @internal
+ */
+export declare interface IDecorationOptions {
+    /**
+     * Array of MarkdownString to render as the decoration message.
+     */
+    hoverMessage?: MarkupContent | MarkupContent[];
+    /**
+     * If set, text will be injected in the view after the range.
+     */
+    label: string;
+    /**
+     * Type of current decorator
+     */
+    type: DecorationType;
+}
+
+/**
+ * @internal
+ */
+export declare interface ILabelElementList {
+    elements: IAttributeElement[];
+    isIncomplete: boolean;
+}
+
+/**
+ * @internal
+ */
+export declare 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 declare interface ILanguageService {
+    initialize(): InitializeResult;
+    doValidation(textDocument: TextDocument): Promise<Diagnostic[]>;
+    doCompletion(textDocument: TextDocument, position: Position): Promise<CompletionList>;
+    doCompletionResolve(item: CompletionItem): Promise<CompletionItem>;
+    doHighlightTokens(textDocument: TextDocument): Promise<HighlightToken[]>;
+    doSemanticTokens(textDocument: TextDocument): Promise<SemanticTokens>;
+    doDecoration(textDocument: TextDocument): Promise<IDecoration[]>;
+    doFormat(textDocument: TextDocument, options: FormattingOptions): Promise<TextEdit[]>;
+    doFormatRange(textDocument: TextDocument, range: Range_3, options: FormattingOptions): Promise<TextEdit[]>;
+}
+
+/**
+ * The dataset fields that MAQL completion uses. SPI dataset metadata objects and declarative
+ * datasets both have them.
+ *
+ * @internal
+ */
+export declare interface ILdmDataset {
+    id: string;
+    title: string;
+    description?: string;
+}
+
+/**
+ * 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 declare interface IMetadataInterface {
+    updateModel(): void;
+    getLdmObjects(items?: IAttributeOrMeasure[]): Promise<LdmObjects>;
+    getLabelElementsFunction(): Promise<LabelElementsFunc>;
+}
+
+/**
+ * @internal
+ */
+export declare interface IMetadataObjectStruct<T extends IMetadataObject> {
+    regular: T[];
+    date: T[];
+    all: T[];
+}
+
+/**
+ * @internal
+ */
+export declare 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;
+}
+
+/**
+ * A MAQL template rendered with its parameters' defaults. `unresolved` lists the ids of references
+ * that could not be turned into a literal; those are left untouched in `maql`.
+ *
+ * @internal
+ */
+export declare interface IRenderedMaql {
+    maql: string;
+    unresolved: string[];
+}
+
+/**
+ * A parameter resolved to its default value. `value` is absent when the default cannot be
+ * determined; `title` is absent when the parameter is unknown.
+ *
+ * @internal
+ */
+export declare interface IResolvedParameter {
+    id: string;
+    title?: string;
+    value?: string | number;
+}
+
+/**
+ * @internal
+ */
+export declare function isITigerParameter(object: ITigerMetadataObject): object is ITigerParameter;
+
+/**
+ * @internal
+ */
+export declare interface ITigerAttribute extends IAttributeMetadataObject, ITigerMetadataObject {
+    type: "attribute";
+    tigerType: "attribute";
+    tigerTypeModifier?: "date";
+    granularity?: DateAttributeGranularity;
+}
+
+/**
+ * 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 declare interface ITigerComputedAttribute extends IComputedAttributeMetadataObject, ITigerMetadataObject {
+    type: "computedAttribute";
+    tigerType: "computedAttribute";
+}
+
+/**
+ * @internal
+ */
+export declare interface ITigerDataset extends ITigerMetadataObject {
+    type: "dataSet";
+    tigerType: "dataset";
+}
+
+/**
+ * @internal
+ */
+export declare interface ITigerFact extends IFactMetadataObject, ITigerMetadataObject {
+    type: "fact";
+    tigerType: "fact";
+}
+
+/**
+ * @internal
+ */
+export declare interface ITigerLabel extends IAttributeDisplayFormMetadataObject, ITigerMetadataObject {
+    type: "displayForm";
+    tigerType: "label";
+    tigerTypeModifier?: "date";
+    granularity?: DateAttributeGranularity;
+}
+
+/**
+ * @internal
+ */
+export declare interface ITigerMetadataObject extends IMetadataObject {
+    tigerType: TigerObjectType;
+}
+
+/**
+ * @internal
+ */
+export declare type ITigerMetadataObjectStub = Pick<ITigerMetadataObject, "id" | "ref"> & Partial<ITigerMetadataObject>;
+
+/**
+ * @internal
+ */
+export declare interface ITigerMetric extends IMeasureMetadataObject, ITigerMetadataObject {
+    type: "measure";
+    tigerType: "metric";
+}
+
+/**
+ * @internal
+ */
+export declare interface ITigerParameter extends IParameterMetadataObject, ITigerMetadataObject {
+    type: "parameter";
+    tigerType: "parameter";
+}
+
+/**
+ * @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 declare type LabelElementsFunc = <T extends ITigerMetadataObjectStub>(labels: T[], excluded: string[], options: IElementsQueryOptions, limit?: number, offset?: number) => Promise<ILabelElementsFuncResult<T>>;
+
+/**
+ * @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 declare type Locale = (typeof locales)[number];
+
+/**
+ * IETF BCP 47 language tags for supported locales in documentation
+ *
+ * @internal
+ */
+export declare const locales: readonly ["en-us"];
+
+/**
+ * MAQL Language Service class
+ * A service to manage the capabilities of the MAQL language server
+ * Can be supplied by Metadata API credentials to automatically
+ * retrieve typed ldmObjects from the Logical Data Model (LDM)
+ *
+ * @internal
+ */
+export declare class MaqlLanguageService implements ILanguageService {
+    constructor(locale?: Locale, metadataService?: IMetadataInterface);
+    private _locale;
+    get locale(): Locale;
+    set locale(locale: string);
+    private metadataService?;
+    private ldmObjects;
+    private labelElementsFunc?;
+    private docs;
+    private isValidLocale;
+    private setMetadataServiceMethods;
+    /**
+     * A method to get information about the capabilities of the service
+     */
+    initialize(): InitializeResult;
+    doCompletion(textDocument: TextDocument, position: Position): Promise<CompletionList>;
+    doCompletionResolve(item: CompletionItem): Promise<CompletionItem>;
+    doHighlightTokens(textDocument: TextDocument): Promise<HighlightToken[]>;
+    doSemanticTokens(textDocument: TextDocument): Promise<SemanticTokens>;
+    doValidation(textDocument: TextDocument): Promise<Diagnostic[]>;
+    doDecoration(textDocument: TextDocument): Promise<IDecoration[]>;
+    doHover(textDocument: TextDocument, position: Position): Promise<HoverWithData | null>;
+    doFormat(textDocument: TextDocument, options: FormattingOptions): Promise<TextEdit[]>;
+    doFormatRange(textDocument: TextDocument, range: Range_3, options: FormattingOptions): Promise<TextEdit[]>;
+    private handleMetadataServiceError;
+}
+
+/**
+ * @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>;
+}
+
+/**
+ * @internal
+ */
+export declare enum ModifierTypes {
+    Deprecated = 0
+}
+
+/**
+ * @internal
+ */
+export declare const ModifierTypesList: string[];
+
+/**
+ * Translates an object type as written in MAQL into the Tiger entity type it denotes. Types that
+ * are spelled identically on both sides are returned unchanged, so this is safe to apply to any
+ * `{type/id}` token before looking the type up.
+ *
+ * Keep the MAQL spelling for anything user-facing (diagnostics quote what the author wrote).
+ *
+ * @internal
+ */
+export declare function normalizeMaqlObjectType(maqlObjectType: string): string;
+
+/**
+ * @internal
+ */
+export declare type ObjectContent = {
+    id: string;
+    ref: ObjRef;
+    title: string;
+    description: string;
+    maql: string;
+    format: string;
+    isLocked?: boolean;
+};
+
+/**
+ * Replaces every `{parameter/id}` reference in `maql` with its default value, so the template can be
+ * previewed as the MAQL that would actually execute. String defaults are rendered as quoted literals
+ * and numeric ones bare. Unresolvable references are reported and left in place rather than guessed.
+ *
+ * Returns undefined when the template references no parameter at all.
+ *
+ * @internal
+ */
+export declare function renderParameterDefaults(maql: string, ldmObjects: LdmObjects): IRenderedMaql | undefined;
+
+/**
+ * Resolves every parameter the given MAQL templates and metrics depend on to its default value,
+ * following `{metric/id}` references into metric expressions. Each parameter is reported once, in
+ * order of first appearance.
+ *
+ * @internal
+ */
+export declare function resolveParameterValues(maqls: string[], metricIds: string[], ldmObjects: LdmObjects): IResolvedParameter[];
+
+/**
+ * @internal
+ */
+export declare const semanticTokensLegend: SemanticTokensLegend;
+
+/**
+ * @internal
+ */
+export declare enum TokenTypes {
+    Type = 0,
+    Keyword = 1,
+    Function = 2,
+    Operator = 3,
+    Number = 4,
+    Variable = 5,
+    String = 6,
+    Comment = 7,
+    Label = 8,
+    Fact = 9,
+    Metric = 10,
+    Dataset = 11
+}
+
+/**
+ * @internal
+ */
+export declare const TokenTypesList: string[];
+
+/**
+ * @internal
+ */
+export declare type TypeModifiers = keyof IMetadataObjectStruct<IMetadataObject>;
+
+export { }

package/esm/tests/metadata.test.helpers.d.ts

@@ -0,0 +1,8 @@
+import { type IAttributeElement } from "@gooddata/sdk-model";
+import { type LabelElementsFunc, LdmObjects } from "../metadata/model.js";
+export declare const ldmObjects: LdmObjects;
+export declare const slicedLdmObjects: LdmObjects;
+export declare const labelElementsFunction: LabelElementsFunc;
+export declare const mockLabelElements: Map<string, IAttributeElement[]>;
+export declare const docs: (resolveTag: string) => Promise<string | undefined>;
+//# sourceMappingURL=metadata.test.helpers.d.ts.map

package/esm/tests/metadata.test.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.test.helpers.d.ts","sourceRoot":"","sources":["../../src/tests/metadata.test.helpers.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,iBAAiB,EAAmB,MAAM,qBAAqB,CAAC;AAG9E,OAAO,EAGH,KAAK,iBAAiB,EACtB,UAAU,EACb,MAAM,sBAAsB,CAAC;AAE9B,eAAO,MAAM,UAAU,EAAE,UA2QxB,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,UAmJ9B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,iBAkCnC,CAAC;AAEF,eAAO,MAAM,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,EAAE,CAoB7D,CAAC;AAUH,eAAO,MAAM,IAAI,eAAgB,MAAM,KAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAInE,CAAC"}