@gooddata/sdk-ui-catalog 11.54.0-alpha.6 → 11.54.0

package/esm/computedAttribute/computedAttributeCompletions.js

@@ -0,0 +1,21 @@
+// (C) 2026 GoodData Corporation
+import { COMPUTED_ATTRIBUTE_SCHEMA_KEYS } from "./computedAttributeSchema.js";
+const rootOptions = (COMPUTED_ATTRIBUTE_SCHEMA_KEYS[""] ?? []).map((label) => ({
+    label,
+    type: "property",
+}));
+/**
+ * Completion source for the computed attribute YAML schema. The schema is a flat mapping, so
+ * completion only offers the top-level property names, and only at column zero — an indented line
+ * sits inside a sequence value (e.g. under `tags:`), where those keys must not be offered.
+ */
+export function computedAttributeCompletions(context) {
+    const line = context.state.doc.lineAt(context.pos);
+    const before = line.text.slice(0, context.pos - line.from);
+    // Trigger only for a key typed at column zero; any leading whitespace means the cursor is nested.
+    const match = before.match(/^([\w-]*)$/);
+    if (!match) {
+        return null;
+    }
+    return { from: context.pos - match[1].length, options: rootOptions, validFor: /^[\w-]*$/ };
+}

package/esm/computedAttribute/computedAttributeConverter.d.ts

@@ -0,0 +1,38 @@
+import type { v1 } from "@gooddata/sdk-code-schemas";
+import type { IComputedAttributeMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { ComputedAttributeSchema } from "./computedAttributeSchema.js";
+/**
+ * Canonical AAC computed attribute object with an optional `id`.
+ *
+ * The `id` is dropped when a computed attribute is created or duplicated so the server derives one;
+ * a loaded computed attribute always carries it. Field names otherwise mirror
+ * `@gooddata/sdk-code-schemas` `v1.ComputedAttribute`.
+ */
+export type ComputedAttributeYaml = Omit<v1.ComputedAttribute, "id"> & {
+    id?: string;
+};
+/**
+ * Maps a computed attribute definition (or a loaded computed attribute, which is a superset) to the
+ * canonical AAC object for YAML serialization.
+ *
+ * Optional meta fields are omitted when empty so the rendered YAML stays terse, matching the
+ * analytics-as-code tooling output. The `id` is omitted when the definition has none (e.g. seeding
+ * the create dialog from a duplicate) so the server derives a fresh one.
+ */
+export declare function definitionToComputedAttributeYaml(definition: IComputedAttributeMetadataObjectDefinition): ComputedAttributeYaml;
+/**
+ * Maps a validated AAC computed attribute object to a backend computed attribute definition.
+ */
+export declare function computedAttributeYamlToDefinition(computedAttribute: ComputedAttributeSchema): IComputedAttributeMetadataObjectDefinition;
+/**
+ * The computed attribute's `reconcile`: layers the author's parsed YAML edits over the base
+ * definition — the loaded object on an edit, the copy source on a duplicate.
+ *
+ * The base carries fields the YAML cannot express (`format`, `metricType`, `dataType`, ...), which
+ * survive because only the YAML-owned fields are overlaid on top. Identity stays YAML-authoritative:
+ * the parsed `id` wins, and its absence lets the server derive a fresh one, so the base's id is
+ * intentionally dropped first. (On an edit this is moot — validation pins the parsed id to the loaded
+ * object's — but on a duplicate it is what frees the copy from the source's identity.)
+ */
+export declare function reconcileComputedAttributeDefinition(base: IComputedAttributeMetadataObjectDefinition, edited: IComputedAttributeMetadataObjectDefinition): IComputedAttributeMetadataObjectDefinition;
+//# sourceMappingURL=computedAttributeConverter.d.ts.map

package/esm/computedAttribute/computedAttributeConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeConverter.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeConverter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,qBAAqB,CAAC;AAEtF,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,8BAA8B,CAAC;AAE5E;;;;;;GAMG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CAAC,EAAE,CAAC,iBAAiB,EAAE,IAAI,CAAC,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEvF;;;;;;;GAOG;AACH,wBAAgB,iCAAiC,CAC7C,UAAU,EAAE,0CAA0C,GACvD,qBAAqB,CAUvB;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAC7C,iBAAiB,EAAE,uBAAuB,GAC3C,0CAA0C,CAU5C;AA2BD;;;;;;;;;GASG;AACH,wBAAgB,oCAAoC,CAChD,IAAI,EAAE,0CAA0C,EAChD,MAAM,EAAE,0CAA0C,GACnD,0CAA0C,CAO5C"}

package/esm/computedAttribute/computedAttributeConverter.js

@@ -0,0 +1,71 @@
+// (C) 2026 GoodData Corporation
+/**
+ * Maps a computed attribute definition (or a loaded computed attribute, which is a superset) to the
+ * canonical AAC object for YAML serialization.
+ *
+ * Optional meta fields are omitted when empty so the rendered YAML stays terse, matching the
+ * analytics-as-code tooling output. The `id` is omitted when the definition has none (e.g. seeding
+ * the create dialog from a duplicate) so the server derives a fresh one.
+ */
+export function definitionToComputedAttributeYaml(definition) {
+    return {
+        type: "computed_attribute",
+        ...(definition.id === undefined ? {} : { id: definition.id }),
+        title: definition.title,
+        ...(definition.description ? { description: definition.description } : {}),
+        ...(definition.tags && definition.tags.length > 0 ? { tags: definition.tags } : {}),
+        maql: definition.expression,
+        ...(definition.locale ? { locale: definition.locale } : {}),
+    };
+}
+/**
+ * Maps a validated AAC computed attribute object to a backend computed attribute definition.
+ */
+export function computedAttributeYamlToDefinition(computedAttribute) {
+    return {
+        type: "computedAttribute",
+        ...(computedAttribute.id === undefined ? {} : { id: computedAttribute.id }),
+        title: computedAttribute.title ?? "",
+        description: computedAttribute.description ?? "",
+        tags: computedAttribute.tags ?? [],
+        expression: computedAttribute.maql,
+        ...(computedAttribute.locale === undefined ? {} : { locale: computedAttribute.locale }),
+    };
+}
+/**
+ * The fields the as-code computed attribute YAML owns, extracted from a parsed definition and
+ * normalized for persistence. Every other field — `format`, `metricType`, `dataType`, `isNullable`,
+ * `nullValue`, and a loaded object's identity (`ref`, `uri`) — lies outside the YAML projection and
+ * is preserved by layering these fields over a base object rather than replacing it.
+ *
+ * `locale` is always returned (normalized to `undefined` when absent), never omitted: it must
+ * overwrite the base so that clearing the `locale` line drops a previously set collation. Were it
+ * omitted when undefined, the base's stale `locale` would leak through the overlay.
+ */
+function pickComputedAttributeYamlFields(definition) {
+    return {
+        title: definition.title ?? "",
+        description: definition.description ?? "",
+        tags: definition.tags ?? [],
+        expression: definition.expression,
+        locale: definition.locale,
+    };
+}
+/**
+ * The computed attribute's `reconcile`: layers the author's parsed YAML edits over the base
+ * definition — the loaded object on an edit, the copy source on a duplicate.
+ *
+ * The base carries fields the YAML cannot express (`format`, `metricType`, `dataType`, ...), which
+ * survive because only the YAML-owned fields are overlaid on top. Identity stays YAML-authoritative:
+ * the parsed `id` wins, and its absence lets the server derive a fresh one, so the base's id is
+ * intentionally dropped first. (On an edit this is moot — validation pins the parsed id to the loaded
+ * object's — but on a duplicate it is what frees the copy from the source's identity.)
+ */
+export function reconcileComputedAttributeDefinition(base, edited) {
+    const { id: _baseId, ...carriedOver } = base;
+    return {
+        ...carriedOver,
+        ...pickComputedAttributeYamlFields(edited),
+        ...(edited.id === undefined ? {} : { id: edited.id }),
+    };
+}

package/esm/computedAttribute/computedAttributeCopy.d.ts

@@ -0,0 +1,3 @@
+import type { IComputedAttributeMetadataObjectDefinition } from "@gooddata/sdk-model";
+export declare function createCopiedComputedAttribute(computedAttribute: IComputedAttributeMetadataObjectDefinition): IComputedAttributeMetadataObjectDefinition;
+//# sourceMappingURL=computedAttributeCopy.d.ts.map

package/esm/computedAttribute/computedAttributeCopy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeCopy.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeCopy.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,qBAAqB,CAAC;AAItF,wBAAgB,6BAA6B,CACzC,iBAAiB,EAAE,0CAA0C,GAC9D,0CAA0C,CAiB5C"}

package/esm/computedAttribute/computedAttributeCopy.js

@@ -0,0 +1,20 @@
+// (C) 2026 GoodData Corporation
+import { deriveCopyIdentity } from "../asCode/copy.js";
+export function createCopiedComputedAttribute(computedAttribute) {
+    // Whitelist only definition-owned fields; the source may be a loaded computed attribute carrying
+    // server-managed fields (uri, ref, timestamps, ...) that must not leak into the definition.
+    // The value-shaping fields are author-owned semantics, so they carry over.
+    return {
+        type: "computedAttribute",
+        ...deriveCopyIdentity(computedAttribute),
+        description: computedAttribute.description,
+        tags: computedAttribute.tags,
+        expression: computedAttribute.expression,
+        ...(computedAttribute.format === undefined ? {} : { format: computedAttribute.format }),
+        ...(computedAttribute.metricType === undefined ? {} : { metricType: computedAttribute.metricType }),
+        ...(computedAttribute.dataType === undefined ? {} : { dataType: computedAttribute.dataType }),
+        ...(computedAttribute.isNullable === undefined ? {} : { isNullable: computedAttribute.isNullable }),
+        ...(computedAttribute.nullValue === undefined ? {} : { nullValue: computedAttribute.nullValue }),
+        ...(computedAttribute.locale === undefined ? {} : { locale: computedAttribute.locale }),
+    };
+}

package/esm/computedAttribute/computedAttributeDescriptor.d.ts

@@ -0,0 +1,7 @@
+import type { IComputedAttributeMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { ICatalogItemComputedAttribute } from "../catalogItem/types.js";
+/**
+ * @internal
+ */
+export declare const computedAttributeDescriptor: import("../asCode/descriptor.js").IAsCodeDescriptor<IComputedAttributeMetadataObjectDefinition, ICatalogItemComputedAttribute>;
+//# sourceMappingURL=computedAttributeDescriptor.d.ts.map

package/esm/computedAttribute/computedAttributeDescriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeDescriptor.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeDescriptor.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,qBAAqB,CAAC;AAQtF,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAkF7E;;GAEG;AACH,eAAO,MAAM,2BAA2B,gIAmCtC,CAAC"}

package/esm/computedAttribute/computedAttributeDescriptor.js

@@ -0,0 +1,101 @@
+// (C) 2026 GoodData Corporation
+import { useMemo } from "react";
+import { defineMessages, useIntl } from "react-intl";
+import { defineAsCodeDescriptor, fixedIdentifierOf, } from "../asCode/descriptor.js";
+import { ObjectTypes } from "../objectType/constants.js";
+import { computedAttributeCompletions } from "./computedAttributeCompletions.js";
+import { computedAttributeYamlToDefinition, definitionToComputedAttributeYaml, reconcileComputedAttributeDefinition, } from "./computedAttributeConverter.js";
+import { createCopiedComputedAttribute } from "./computedAttributeCopy.js";
+import { createComputedAttributeMutationAdapter, listComputedAttributeReferences, loadComputedAttribute, } from "./computedAttributeMutationPort.js";
+import { serializeComputedAttributeToYaml } from "./computedAttributeSerialization.js";
+import { validateComputedAttributeYaml } from "./computedAttributeValidation.js";
+import { COMPUTED_ATTRIBUTE_FEATURE_FLAG } from "./gate.js";
+const COMPUTED_ATTRIBUTE_DOCS_URL = "https://www.gooddata.ai/docs/cloud/api-and-sdk/vs-code-extension/structures/#computed-attribute";
+const messages = defineMessages({
+    createTitle: { id: "analyticsCatalog.computedAttribute.dialog.create.title" },
+    editTitle: { id: "analyticsCatalog.computedAttribute.dialog.edit.title" },
+    duplicate: { id: "analyticsCatalog.computedAttribute.dialog.edit.duplicate" },
+    createDefaultTitle: { id: "analyticsCatalog.computedAttribute.create.defaultTitle" },
+    createSuccess: { id: "analyticsCatalog.computedAttribute.create.success" },
+    updateSuccess: { id: "analyticsCatalog.computedAttribute.update.success" },
+    sectionHeader: { id: "analyticsCatalog.computedAttribute.dialog.sectionHeader" },
+    sectionHeaderTooltip: { id: "analyticsCatalog.computedAttribute.dialog.sectionHeader.tooltip" },
+    help: { id: "analyticsCatalog.computedAttribute.dialog.help" },
+    submitError: { id: "analyticsCatalog.computedAttribute.dialog.submit.error" },
+    deleteTitle: { id: "analyticsCatalog.computedAttribute.dialog.delete.title" },
+    deleteBody: { id: "analyticsCatalog.computedAttribute.dialog.delete.body" },
+    deleteSubmit: { id: "analyticsCatalog.computedAttribute.dialog.delete.submit" },
+    deleteSuccess: { id: "analyticsCatalog.computedAttribute.delete.success" },
+    deleteError: { id: "analyticsCatalog.computedAttribute.delete.error" },
+});
+const capabilityMessages = defineMessages({
+    loadError: { id: "analyticsCatalog.computedAttribute.load.error" },
+    deleteUsageWarning: { id: "analyticsCatalog.computedAttribute.dialog.delete.usageWarning" },
+    deleteBlocked: { id: "analyticsCatalog.computedAttribute.dialog.delete.blocked" },
+});
+const errorMessages = defineMessages({
+    empty: { id: "analyticsCatalog.computedAttribute.validation.empty" },
+    syntax: { id: "analyticsCatalog.computedAttribute.validation.syntax" },
+    invalidStructure: { id: "analyticsCatalog.computedAttribute.validation.invalidStructure" },
+    idImmutable: { id: "analyticsCatalog.computedAttribute.dialog.edit.idImmutable" },
+    missingMaql: { id: "analyticsCatalog.computedAttribute.validation.missingMaql" },
+    invalidTags: { id: "analyticsCatalog.computedAttribute.validation.invalidTags" },
+});
+function useComputedAttributeEditing() {
+    const intl = useIntl();
+    return useMemo(() => ({
+        completionSource: computedAttributeCompletions,
+        syntaxErrorMessage: intl.formatMessage(errorMessages.syntax),
+        // The editor works in the YAML shape, a lossy projection of the computed attribute
+        // definition — lossy in what a document carries, which `reconcile` restores, never in
+        // whether one exists.
+        serialize: (definition) => ({
+            yaml: serializeComputedAttributeToYaml(definitionToComputedAttributeYaml(definition)),
+            hasCodeForm: true,
+        }),
+        validate: (value, context) => {
+            const result = validateComputedAttributeYaml(value, {
+                fixedIdentifier: fixedIdentifierOf(context),
+            });
+            return result.isValid
+                ? { isValid: true, definition: result.computedAttribute }
+                : { isValid: false, error: intl.formatMessage(errorMessages[result.errorCode]) };
+        },
+        reconcile: reconcileComputedAttributeDefinition,
+    }), [intl]);
+}
+/**
+ * @internal
+ */
+export const computedAttributeDescriptor = defineAsCodeDescriptor({
+    objectType: ObjectTypes.COMPUTED_ATTRIBUTE,
+    docsUrl: COMPUTED_ATTRIBUTE_DOCS_URL,
+    featureFlag: COMPUTED_ATTRIBUTE_FEATURE_FLAG,
+    messages,
+    useEditing: useComputedAttributeEditing,
+    createMutationPort: createComputedAttributeMutationAdapter,
+    // The template offers the fields and leaves the MAQL line empty: the expression is the whole
+    // point of the object, so a placeholder one would only be text to delete.
+    emptyDefinition: (defaultTitle) => computedAttributeYamlToDefinition({
+        type: "computed_attribute",
+        title: defaultTitle,
+        maql: "",
+    }),
+    // The catalog item carries no MAQL, so the full object is fetched for editing.
+    seed: { load: loadComputedAttribute, loadError: capabilityMessages.loadError },
+    // Refuses the deletion while a visualization still groups by it, and names those
+    // visualizations. The backend currently allows the delete (it would break the insight
+    // silently), so the catalog is the guard.
+    referenceCounted: {
+        load: listComputedAttributeReferences,
+        usageWarning: capabilityMessages.deleteUsageWarning,
+        listReferences: true,
+        blockedBody: capabilityMessages.deleteBlocked,
+    },
+    // A copied computed attribute derives a human-readable id that can collide on create; identity lets the dialog retry without it.
+    identity: {
+        read: (definition) => definition.id,
+        strip: ({ id: _id, ...definition }) => definition,
+    },
+    toCopy: createCopiedComputedAttribute,
+});

package/esm/computedAttribute/computedAttributeMutationPort.d.ts

@@ -0,0 +1,17 @@
+import type { IAnalyticalBackend } from "@gooddata/sdk-backend-spi";
+import { type IComputedAttributeMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { IAsCodeMutationPort } from "../asCode/descriptor.js";
+import type { ICatalogItemComputedAttribute } from "../catalogItem/types.js";
+/**
+ * @internal
+ */
+export type IComputedAttributeMutationPort = IAsCodeMutationPort<IComputedAttributeMetadataObjectDefinition, ICatalogItemComputedAttribute>;
+/** Fetches the full computed attribute for editing (the catalog item carries no MAQL). @internal */
+export declare function loadComputedAttribute(backend: IAnalyticalBackend, workspace: string, item: ICatalogItemComputedAttribute): Promise<IComputedAttributeMetadataObjectDefinition>;
+/** Titles of the insights and metrics referencing a computed attribute. @internal */
+export declare function listComputedAttributeReferences(backend: IAnalyticalBackend, workspace: string, item: ICatalogItemComputedAttribute): Promise<string[]>;
+/**
+ * @internal
+ */
+export declare function createComputedAttributeMutationAdapter(backend: IAnalyticalBackend, workspace: string): IComputedAttributeMutationPort;
+//# sourceMappingURL=computedAttributeMutationPort.d.ts.map

package/esm/computedAttribute/computedAttributeMutationPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeMutationPort.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeMutationPort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAEH,KAAK,0CAA0C,EAIlD,MAAM,qBAAqB,CAAC;AAE7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAGnE,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,yBAAyB,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,mBAAmB,CAC5D,0CAA0C,EAC1C,6BAA6B,CAChC,CAAC;AAYF,oGAAoG;AACpG,wBAAgB,qBAAqB,CACjC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,6BAA6B,GACpC,OAAO,CAAC,0CAA0C,CAAC,CAKrD;AAED,qFAAqF;AACrF,wBAAsB,+BAA+B,CACjD,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,6BAA6B,GACpC,OAAO,CAAC,MAAM,EAAE,CAAC,CASnB;AAED;;GAEG;AACH,wBAAgB,sCAAsC,CAClD,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAClB,8BAA8B,CAyBhC"}

package/esm/computedAttribute/computedAttributeMutationPort.js

@@ -0,0 +1,53 @@
+// (C) 2026 GoodData Corporation
+import { idRef, insightTitle, isComputedAttributeMetadataObject, } from "@gooddata/sdk-model";
+import { convertComputedAttributeToCatalogItem } from "../catalogItem/converter.js";
+// `id` is definition-expressible yet server-owned: the update targets by it, so a hand-edited id must not retarget it.
+function pickComputedAttributeIdentity(computedAttribute) {
+    const { id, ref, uri, created, updated, createdBy, updatedBy, certification, displayForms } = computedAttribute;
+    return { id, ref, uri, created, updated, createdBy, updatedBy, certification, displayForms };
+}
+/** Fetches the full computed attribute for editing (the catalog item carries no MAQL). @internal */
+export function loadComputedAttribute(backend, workspace, item) {
+    return backend
+        .workspace(workspace)
+        .computedAttributes()
+        .getComputedAttribute(idRef(item.identifier, "computedAttribute"));
+}
+/** Titles of the insights and metrics referencing a computed attribute. @internal */
+export async function listComputedAttributeReferences(backend, workspace, item) {
+    const referencing = await backend
+        .workspace(workspace)
+        .computedAttributes()
+        .getComputedAttributeReferencingObjects(idRef(item.identifier, "computedAttribute"));
+    return [
+        ...(referencing.insights ?? []).map((insight) => insightTitle(insight)),
+        ...(referencing.measures ?? []).map((measure) => measure.title),
+    ];
+}
+/**
+ * @internal
+ */
+export function createComputedAttributeMutationAdapter(backend, workspace) {
+    const computedAttributes = () => backend.workspace(workspace).computedAttributes();
+    return {
+        async create(definition) {
+            const saved = await computedAttributes().createComputedAttribute(definition);
+            return convertComputedAttributeToCatalogItem(saved);
+        },
+        async update(base, definition) {
+            if (!isComputedAttributeMetadataObject(base)) {
+                throw new Error("Computed attribute update requires the loaded object as base, not a bare definition.");
+            }
+            // Definition is authoritative (already reconciled); base fills only non-definition fields, and the server-identity pick wins.
+            const saved = await computedAttributes().updateComputedAttribute({
+                ...base,
+                ...definition,
+                ...pickComputedAttributeIdentity(base),
+            });
+            return convertComputedAttributeToCatalogItem(saved);
+        },
+        async delete(ref) {
+            await computedAttributes().deleteComputedAttribute(idRef(ref.identifier, "computedAttribute"));
+        },
+    };
+}

package/esm/computedAttribute/computedAttributeMutationPort.test.utils.d.ts

@@ -0,0 +1,4 @@
+import type { IComputedAttributeMutationPort } from "./computedAttributeMutationPort.js";
+/** @internal */
+export declare function createTestComputedAttributeMutationPort(overrides?: Partial<IComputedAttributeMutationPort>): IComputedAttributeMutationPort;
+//# sourceMappingURL=computedAttributeMutationPort.test.utils.d.ts.map

package/esm/computedAttribute/computedAttributeMutationPort.test.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeMutationPort.test.utils.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeMutationPort.test.utils.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,oCAAoC,CAAC;AAgBzF,gBAAgB;AAChB,wBAAgB,uCAAuC,CACnD,SAAS,GAAE,OAAO,CAAC,8BAA8B,CAAM,GACxD,8BAA8B,CAOhC"}

package/esm/computedAttribute/computedAttributeMutationPort.test.utils.js

@@ -0,0 +1,24 @@
+// (C) 2026 GoodData Corporation
+import { vi } from "vitest";
+const defaultSavedItem = {
+    identifier: "test-computed-attribute",
+    type: "computedAttribute",
+    title: "Test Computed Attribute",
+    description: "",
+    tags: [],
+    createdBy: "test",
+    updatedBy: "test",
+    createdAt: null,
+    updatedAt: null,
+    isLocked: false,
+    isEditable: true,
+};
+/** @internal */
+export function createTestComputedAttributeMutationPort(overrides = {}) {
+    return {
+        create: vi.fn().mockResolvedValue(defaultSavedItem),
+        update: vi.fn().mockResolvedValue(defaultSavedItem),
+        delete: vi.fn().mockResolvedValue(undefined),
+        ...overrides,
+    };
+}

package/esm/computedAttribute/computedAttributeSchema.d.ts

@@ -0,0 +1,27 @@
+import * as z from "zod/mini";
+/**
+ * Zod schema for the analytics-as-code (AAC) computed attribute YAML shape.
+ *
+ * Field names and structure mirror the canonical AAC computed attribute definition
+ * (`@gooddata/sdk-code-schemas` `v1.ComputedAttribute`) so YAML authored here is interchangeable
+ * with computed attributes produced by the analytics-as-code tooling. `id` is optional because the
+ * server derives one from the title when it is omitted on create.
+ */
+export declare const computedAttributeSchema: z.ZodMiniObject<{
+    type: z.ZodMiniDefault<z.ZodMiniLiteral<"computed_attribute">>;
+    id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tags: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    maql: z.ZodMiniString<string>;
+    locale: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$strict>;
+export type ComputedAttributeSchemaInput = z.input<typeof computedAttributeSchema>;
+export type ComputedAttributeSchema = z.infer<typeof computedAttributeSchema>;
+/**
+ * Allowed YAML property names keyed by parent mapping, used to power editor autocompletion.
+ * The computed attribute schema is flat, so the only entry is the top-level mapping (keyed by `""`),
+ * whose value is the object's property names read from zod's public `shape`.
+ */
+export declare const COMPUTED_ATTRIBUTE_SCHEMA_KEYS: Record<string, string[]>;
+//# sourceMappingURL=computedAttributeSchema.d.ts.map

package/esm/computedAttribute/computedAttributeSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeSchema.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeSchema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B;;;;;;;GAOG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;kBAQlC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACnF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAE9E;;;;GAIG;AACH,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAEnE,CAAC"}

package/esm/computedAttribute/computedAttributeSchema.js

@@ -0,0 +1,27 @@
+// (C) 2026 GoodData Corporation
+import * as z from "zod/mini";
+/**
+ * Zod schema for the analytics-as-code (AAC) computed attribute YAML shape.
+ *
+ * Field names and structure mirror the canonical AAC computed attribute definition
+ * (`@gooddata/sdk-code-schemas` `v1.ComputedAttribute`) so YAML authored here is interchangeable
+ * with computed attributes produced by the analytics-as-code tooling. `id` is optional because the
+ * server derives one from the title when it is omitted on create.
+ */
+export const computedAttributeSchema = z.strictObject({
+    type: z._default(z.literal("computed_attribute"), "computed_attribute"),
+    id: z.optional(z.string()),
+    title: z.optional(z.string()),
+    description: z.optional(z.string()),
+    tags: z.optional(z.array(z.string())),
+    maql: z.string(),
+    locale: z.optional(z.string()),
+});
+/**
+ * Allowed YAML property names keyed by parent mapping, used to power editor autocompletion.
+ * The computed attribute schema is flat, so the only entry is the top-level mapping (keyed by `""`),
+ * whose value is the object's property names read from zod's public `shape`.
+ */
+export const COMPUTED_ATTRIBUTE_SCHEMA_KEYS = {
+    "": Object.keys(computedAttributeSchema.shape),
+};

package/esm/computedAttribute/computedAttributeSerialization.d.ts

@@ -0,0 +1,15 @@
+import type { ComputedAttributeYaml } from "./computedAttributeConverter.js";
+/**
+ * Serializes a canonical AAC computed attribute object to YAML.
+ *
+ * The document is a flat, gap-free list of lines in the order the design prescribes: `id`, `type`,
+ * `title`, `description`, then `maql` last, so the expression the author came to write sits at the
+ * bottom with the room below it. The `id` line is omitted when the computed attribute has none so
+ * the server derives one on create.
+ *
+ * `description` is always rendered, empty as `""`, so the field an author is likely to fill is
+ * offered rather than hidden. An empty `maql` renders as a bare `maql:` (see `nullStr`), an
+ * invitation to type rather than a quoted blank to delete.
+ */
+export declare function serializeComputedAttributeToYaml(computedAttribute: ComputedAttributeYaml): string;
+//# sourceMappingURL=computedAttributeSerialization.d.ts.map

package/esm/computedAttribute/computedAttributeSerialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeSerialization.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeSerialization.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;;;;;;;;;GAWG;AACH,wBAAgB,gCAAgC,CAAC,iBAAiB,EAAE,qBAAqB,GAAG,MAAM,CAkBjG"}

package/esm/computedAttribute/computedAttributeSerialization.js

@@ -0,0 +1,29 @@
+// (C) 2026 GoodData Corporation
+import { Document } from "yaml";
+/**
+ * Serializes a canonical AAC computed attribute object to YAML.
+ *
+ * The document is a flat, gap-free list of lines in the order the design prescribes: `id`, `type`,
+ * `title`, `description`, then `maql` last, so the expression the author came to write sits at the
+ * bottom with the room below it. The `id` line is omitted when the computed attribute has none so
+ * the server derives one on create.
+ *
+ * `description` is always rendered, empty as `""`, so the field an author is likely to fill is
+ * offered rather than hidden. An empty `maql` renders as a bare `maql:` (see `nullStr`), an
+ * invitation to type rather than a quoted blank to delete.
+ */
+export function serializeComputedAttributeToYaml(computedAttribute) {
+    const doc = new Document(computedAttribute.id === undefined
+        ? { type: "computed_attribute" }
+        : { id: computedAttribute.id, type: "computed_attribute" });
+    doc.add(doc.createPair("title", computedAttribute.title ?? ""));
+    doc.add(doc.createPair("description", computedAttribute.description ?? ""));
+    if (computedAttribute.tags && computedAttribute.tags.length > 0) {
+        doc.add(doc.createPair("tags", computedAttribute.tags));
+    }
+    if (computedAttribute.locale) {
+        doc.add(doc.createPair("locale", computedAttribute.locale));
+    }
+    doc.add(doc.createPair("maql", computedAttribute.maql ? computedAttribute.maql : null));
+    return doc.toString({ lineWidth: 0, nullStr: "" }).trimEnd();
+}

package/esm/computedAttribute/computedAttributeValidation.d.ts

@@ -0,0 +1,15 @@
+import type { IComputedAttributeMetadataObjectDefinition } from "@gooddata/sdk-model";
+export type ComputedAttributeValidationResult = {
+    isValid: true;
+    computedAttribute: IComputedAttributeMetadataObjectDefinition;
+} | {
+    isValid: false;
+    errorCode: ComputedAttributeValidationErrorCode;
+};
+export type ComputedAttributeValidationErrorCode = "empty" | "syntax" | "invalidStructure" | "idImmutable" | "missingMaql" | "invalidTags";
+type ValidateComputedAttributeYamlOptions = {
+    fixedIdentifier?: string;
+};
+export declare function validateComputedAttributeYaml(value: string, options?: ValidateComputedAttributeYamlOptions): ComputedAttributeValidationResult;
+export {};
+//# sourceMappingURL=computedAttributeValidation.d.ts.map

package/esm/computedAttribute/computedAttributeValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computedAttributeValidation.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/computedAttributeValidation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,0CAA0C,EAAE,MAAM,qBAAqB,CAAC;AAOtF,MAAM,MAAM,iCAAiC,GACvC;IACI,OAAO,EAAE,IAAI,CAAC;IACd,iBAAiB,EAAE,0CAA0C,CAAC;CACjE,GACD;IACI,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,oCAAoC,CAAC;CACnD,CAAC;AAER,MAAM,MAAM,oCAAoC,GAC1C,OAAO,GACP,QAAQ,GACR,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,aAAa,CAAC;AAEpB,KAAK,oCAAoC,GAAG;IACxC,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,6BAA6B,CACzC,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,oCAAyC,GACnD,iCAAiC,CAgBnC"}

package/esm/computedAttribute/computedAttributeValidation.js

@@ -0,0 +1,37 @@
+// (C) 2026 GoodData Corporation
+import { validateYaml } from "../asCode/validateYaml.js";
+import { computedAttributeYamlToDefinition } from "./computedAttributeConverter.js";
+import { computedAttributeSchema } from "./computedAttributeSchema.js";
+export function validateComputedAttributeYaml(value, options = {}) {
+    const result = validateYaml(value, {
+        schema: computedAttributeSchema,
+        fixedIdentifier: options.fixedIdentifier,
+    });
+    if (result.ok) {
+        return { isValid: true, computedAttribute: computedAttributeYamlToDefinition(result.data) };
+    }
+    return {
+        isValid: false,
+        errorCode: result.kind === "schema"
+            ? classifyComputedAttributeError(result.error, result.parsed)
+            : result.kind,
+    };
+}
+function classifyComputedAttributeError(error, parsed) {
+    // A blank `maql:` line parses to null - the seeded template's state - and counts as unwritten,
+    // not as a value of the wrong type.
+    const maqlProvided = typeof parsed === "object" &&
+        parsed !== null &&
+        (parsed.maql ?? undefined) !== undefined;
+    for (const issue of error.issues) {
+        const path = issue.path.map(String).join(".");
+        if (path === "maql") {
+            // A present-but-wrong-typed maql is a structural error, not a missing field.
+            return maqlProvided ? "invalidStructure" : "missingMaql";
+        }
+        if (path === "tags" || path.startsWith("tags.")) {
+            return "invalidTags";
+        }
+    }
+    return "invalidStructure";
+}

package/esm/computedAttribute/gate.d.ts

@@ -0,0 +1,4 @@
+/** The flag gating catalog computed attributes, referenced by
+ *  `computedAttributeDescriptor.featureFlag` and `useCatalogEndpoints` `gatedBy`. */
+export declare const COMPUTED_ATTRIBUTE_FEATURE_FLAG = "enableComputedAttributes";
+//# sourceMappingURL=gate.d.ts.map

package/esm/computedAttribute/gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/computedAttribute/gate.ts"],"names":[],"mappings":"AAEA;qFACqF;AACrF,eAAO,MAAM,+BAA+B,6BAA6B,CAAC"}

package/esm/computedAttribute/gate.js

@@ -0,0 +1,4 @@
+// (C) 2026 GoodData Corporation
+/** The flag gating catalog computed attributes, referenced by
+ *  `computedAttributeDescriptor.featureFlag` and `useCatalogEndpoints` `gatedBy`. */
+export const COMPUTED_ATTRIBUTE_FEATURE_FLAG = "enableComputedAttributes";

package/esm/filter/FilterObjectType.js

@@ -3,17 +3,17 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { memo, useId } from "react";
 import { FormattedMessage } from "react-intl";
 import { useCatalogFeedCounter } from "../catalogItem/CatalogFeedContext.js";
+import { useEnabledObjectTypes } from "../catalogItem/useCatalogEndpoints.js";
 import { ObjectTypeSelectMemo } from "../objectType/ObjectTypeSelect.js";
-import { useIsParametersEnabled } from "../parameter/gate.js";
 import { useFilterActions, useFilterState } from "./FilterContext.js";
 import { FilterGroupLayout } from "./FilterGroupLayout.js";
 export function FilterObjectType() {
     const counter = useCatalogFeedCounter();
     const { types } = useFilterState();
     const { setTypes } = useFilterActions();
-    const isParametersEnabled = useIsParametersEnabled();
+    const enabledObjectTypes = useEnabledObjectTypes();
     const id = useId();
     const titleId = `filter-object-type-title/${id}`;
-    return (_jsx(FilterGroupLayout, { className: "gd-analytics-catalog__filter__group__object-type", title: _jsx(FormattedMessage, { id: "analyticsCatalog.objectType.title" }), titleId: titleId, children: _jsx(ObjectTypeSelectMemo, { counter: counter, selectedTypes: types, onSelect: setTypes, showParameter: isParametersEnabled, ariaLabelledBy: titleId }) }));
+    return (_jsx(FilterGroupLayout, { className: "gd-analytics-catalog__filter__group__object-type", title: _jsx(FormattedMessage, { id: "analyticsCatalog.objectType.title" }), titleId: titleId, children: _jsx(ObjectTypeSelectMemo, { counter: counter, selectedTypes: types, enabledObjectTypes: enabledObjectTypes, onSelect: setTypes, ariaLabelledBy: titleId }) }));
 }
 export const FilterObjectTypeMemo = memo(FilterObjectType);

package/esm/header/CreateObjectButton.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CreateObjectButton.d.ts","sourceRoot":"","sources":["../../src/header/CreateObjectButton.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AAatE,KAAK,KAAK,GAAG;IACT,cAAc,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,IAAI,CAAC;CACjE,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,EAAE,cAAc,EAAE,EAAE,KAAK,2CAsG3D"}
+{"version":3,"file":"CreateObjectButton.d.ts","sourceRoot":"","sources":["../../src/header/CreateObjectButton.tsx"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AActE,KAAK,KAAK,GAAG;IACT,cAAc,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,IAAI,CAAC;CACjE,CAAC;AAEF,wBAAgB,kBAAkB,CAAC,EAAE,cAAc,EAAE,EAAE,KAAK,2CAsG3D"}

package/esm/header/CreateObjectButton.js

@@ -13,6 +13,7 @@ const icons = {
     [ObjectTypes.VISUALIZATION]: "visualization",
     [ObjectTypes.METRIC]: "metric",
     [ObjectTypes.PARAMETER]: "parameter",
+    [ObjectTypes.COMPUTED_ATTRIBUTE]: "ldmAttribute",
 };
 export function CreateObjectButton({ onCreateObject }) {
     const intl = useIntl();

package/esm/index.d.ts

@@ -7,6 +7,6 @@ export type { ICatalogDetailProps } from "./catalogDetail/CatalogDetail.js";
 export type { EditHandlerEvent, OpenHandlerEvent } from "./catalogDetail/types.js";
 export type { ICatalogDetailContentProps } from "./catalogDetail/CatalogDetailContent.js";
 export type { ObjectType, CatalogCreateObjectType } from "./objectType/types.js";
-export type { ICatalogItem, ICatalogItemBase, ICatalogItemRef, ICatalogItemInsight, ICatalogItemMeasure, ICatalogItemParameter, ICatalogItemAttribute, ICatalogItemFact, ICatalogItemDataSet, ICatalogItemDashboard, VisualizationType, } from "./catalogItem/types.js";
-export { isCatalogItemAttribute, isCatalogItemDashboard, isCatalogItemDataSet, isCatalogItemFact, isCatalogItemInsight, isCatalogItemMeasure, isCatalogItemParameter, } from "./catalogItem/guards.js";
+export type { ICatalogItem, ICatalogItemBase, ICatalogItemRef, ICatalogItemInsight, ICatalogItemMeasure, ICatalogItemParameter, ICatalogItemComputedAttribute, ICatalogItemAttribute, ICatalogItemFact, ICatalogItemDataSet, ICatalogItemDashboard, VisualizationType, } from "./catalogItem/types.js";
+export { isCatalogItemAttribute, isCatalogItemComputedAttribute, isCatalogItemDashboard, isCatalogItemDataSet, isCatalogItemFact, isCatalogItemInsight, isCatalogItemMeasure, isCatalogItemParameter, } from "./catalogItem/guards.js";
 //# sourceMappingURL=index.d.ts.map