@gooddata/sdk-ui-catalog 11.46.0-alpha.2 → 11.46.0-alpha.4

package/esm/metric/MetricMutationContext.d.ts

@@ -0,0 +1,16 @@
+import { type PropsWithChildren } from "react";
+import { type IMetricMutationPort } from "./metricMutationPort.js";
+type ProviderProps = PropsWithChildren<{
+    port?: IMetricMutationPort;
+}>;
+/**
+ * Must be placed inside `BackendProvider` and `WorkspaceProvider`.
+ * @internal
+ */
+export declare function MetricMutationProvider({ children, port }: ProviderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * @internal
+ */
+export declare function useMetricMutation(): IMetricMutationPort;
+export {};
+//# sourceMappingURL=MetricMutationContext.d.ts.map

package/esm/metric/MetricMutationContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricMutationContext.d.ts","sourceRoot":"","sources":["../../src/metric/MetricMutationContext.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,iBAAiB,EAAsC,MAAM,OAAO,CAAC;AAInF,OAAO,EAAE,KAAK,mBAAmB,EAA+B,MAAM,yBAAyB,CAAC;AAIhG,KAAK,aAAa,GAAG,iBAAiB,CAAC;IACnC,IAAI,CAAC,EAAE,mBAAmB,CAAC;CAC9B,CAAC,CAAC;AAEH;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,EAAE,aAAa,2CAKvE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,mBAAmB,CAMvD"}

package/esm/metric/MetricMutationContext.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { createContext, useContext, useMemo } from "react";
+import { useBackendStrict, useWorkspaceStrict } from "@gooddata/sdk-ui";
+import { createMetricMutationAdapter } from "./metricMutationPort.js";
+const MetricMutationContext = createContext(null);
+/**
+ * Must be placed inside `BackendProvider` and `WorkspaceProvider`.
+ * @internal
+ */
+export function MetricMutationProvider({ children, port }) {
+    if (port) {
+        return _jsx(MetricMutationContext.Provider, { value: port, children: children });
+    }
+    return _jsx(DefaultMetricMutationProvider, { children: children });
+}
+/**
+ * @internal
+ */
+export function useMetricMutation() {
+    const mutation = useContext(MetricMutationContext);
+    if (!mutation) {
+        throw new Error("useMetricMutation must be used within MetricMutationProvider");
+    }
+    return mutation;
+}
+function DefaultMetricMutationProvider({ children }) {
+    const backend = useBackendStrict();
+    const workspace = useWorkspaceStrict();
+    const mutation = useMemo(() => createMetricMutationAdapter(backend, workspace), [backend, workspace]);
+    return _jsx(MetricMutationContext.Provider, { value: mutation, children: children });
+}

package/esm/metric/MetricYamlEditor.d.ts

@@ -0,0 +1,8 @@
+type Props = {
+    initialValue: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+};
+export declare function MetricYamlEditor({ initialValue, onChange, disabled }: Props): import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=MetricYamlEditor.d.ts.map

package/esm/metric/MetricYamlEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricYamlEditor.d.ts","sourceRoot":"","sources":["../../src/metric/MetricYamlEditor.tsx"],"names":[],"mappings":"AAcA,KAAK,KAAK,GAAG;IACT,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,wBAAgB,gBAAgB,CAAC,EAAE,YAAY,EAAE,QAAQ,EAAE,QAAgB,EAAE,EAAE,KAAK,2CA2BnF"}

package/esm/metric/MetricYamlEditor.js

@@ -0,0 +1,20 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+// (C) 2026 GoodData Corporation
+import { useCallback, useMemo, useState } from "react";
+import { yaml } from "@codemirror/lang-yaml";
+import { lintGutter } from "@codemirror/lint";
+import { lineNumbers } from "@codemirror/view";
+import { useIntl } from "react-intl";
+import { SyntaxHighlightingInput } from "@gooddata/sdk-ui-kit";
+import { metricSchemaCompletions } from "./metricCompletions.js";
+import { createMetricYamlLinter } from "./metricYamlLinter.js";
+export function MetricYamlEditor({ initialValue, onChange, disabled = false }) {
+    const intl = useIntl();
+    const [value, setValue] = useState(initialValue);
+    const extensions = useMemo(() => [yaml(), lineNumbers(), createMetricYamlLinter(intl), lintGutter()], [intl]);
+    const handleChange = useCallback((nextValue) => {
+        setValue(nextValue);
+        onChange?.(nextValue);
+    }, [onChange]);
+    return (_jsx(SyntaxHighlightingInput, { className: "gd-ascode-dialog-editor-input", value: value, onChange: handleChange, extensions: extensions, onCompletion: metricSchemaCompletions, disabled: disabled }));
+}

package/esm/metric/gate.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Catalog inline metric editor feature gate.
+ */
+export declare function useIsCatalogMetricEditorEnabled(): boolean;
+/**
+ * Whether the current user can create and edit metrics inline in the catalog.
+ */
+export declare function useCanManageMetric(): boolean;
+//# sourceMappingURL=gate.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gate.d.ts","sourceRoot":"","sources":["../../src/metric/gate.ts"],"names":[],"mappings":"AAIA;;GAEG;AACH,wBAAgB,+BAA+B,IAAI,OAAO,CAEzD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,OAAO,CAI5C"}

package/esm/metric/gate.js

@@ -0,0 +1,16 @@
+// (C) 2026 GoodData Corporation
+import { useFeatureFlag, useWorkspacePermission } from "../permission/PermissionsContext.js";
+/**
+ * Catalog inline metric editor feature gate.
+ */
+export function useIsCatalogMetricEditorEnabled() {
+    return useFeatureFlag("enableAnalyticalCatalogMetricEditor");
+}
+/**
+ * Whether the current user can create and edit metrics inline in the catalog.
+ */
+export function useCanManageMetric() {
+    const isMetricEditorEnabled = useIsCatalogMetricEditorEnabled();
+    const canManageProject = useWorkspacePermission("canManageProject");
+    return isMetricEditorEnabled && canManageProject;
+}

package/esm/metric/metricCompletions.d.ts

@@ -0,0 +1,7 @@
+import type { CompletionContext, CompletionResult } from "@codemirror/autocomplete";
+/**
+ * CodeMirror completion source that suggests allowed YAML property names
+ * based on the metric zod schema and cursor position in the Lezer tree.
+ */
+export declare function metricSchemaCompletions(context: CompletionContext): CompletionResult | null;
+//# sourceMappingURL=metricCompletions.d.ts.map

package/esm/metric/metricCompletions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricCompletions.d.ts","sourceRoot":"","sources":["../../src/metric/metricCompletions.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAcpF;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,IAAI,CA2B3F"}

package/esm/metric/metricCompletions.js

@@ -0,0 +1,59 @@
+// (C) 2026 GoodData Corporation
+import { syntaxTree } from "@codemirror/language";
+import { METRIC_SCHEMA_KEYS } from "./metricSchema.js";
+/** Pre-built completion options from the schema key map. */
+const completionOptions = Object.fromEntries(Object.entries(METRIC_SCHEMA_KEYS).map(([parent, keys]) => [
+    parent,
+    keys.map((label) => ({ label, type: "property" })),
+]));
+/**
+ * CodeMirror completion source that suggests allowed YAML property names
+ * based on the metric zod schema and cursor position in the Lezer tree.
+ */
+export function metricSchemaCompletions(context) {
+    const line = context.state.doc.lineAt(context.pos);
+    const before = line.text.slice(0, context.pos - line.from);
+    // Only trigger when typing a key name at the start of a line
+    const match = before.match(/^(\s*)(\w*)$/);
+    if (!match) {
+        return null;
+    }
+    // The metric schema is flat: property keys exist only at the top-level mapping, at zero
+    // indentation. An indented cursor is inside a value such as the `tags` sequence, where the
+    // top-level key suggestions must not be offered.
+    if (match[1].length > 0) {
+        return null;
+    }
+    const word = match[2];
+    const from = context.pos - word.length;
+    const parentKey = getParentKey(context.state, context.pos);
+    const options = completionOptions[parentKey];
+    if (!options) {
+        return null;
+    }
+    return { from, options };
+}
+/**
+ * Walk up the Lezer YAML tree from cursor to find which key's BlockMapping
+ * we're inside. Returns "" for the top-level mapping.
+ */
+function getParentKey(state, pos) {
+    const tree = syntaxTree(state);
+    let node = tree.resolveInner(pos, -1).parent;
+    // Find the BlockMapping we're inside
+    while (node) {
+        if (node.name === "BlockMapping") {
+            // If this BlockMapping is the value of a Pair, return the Pair's key
+            const pair = node.parent;
+            if (pair?.name === "Pair") {
+                const keyNode = pair.getChild("Key");
+                if (keyNode) {
+                    return state.sliceDoc(keyNode.from, keyNode.to).trim();
+                }
+            }
+            return "";
+        }
+        node = node.parent;
+    }
+    return "";
+}

package/esm/metric/metricConverter.d.ts

@@ -0,0 +1,49 @@
+import type { v1 } from "@gooddata/sdk-code-schemas";
+import type { IMeasureMetadataObject, IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { MetricSchema } from "./metricSchema.js";
+/**
+ * Canonical AAC metric object with an optional `id`.
+ *
+ * The `id` is dropped when a metric is created or duplicated so the server derives one; a loaded
+ * metric always carries it. Field names otherwise mirror `@gooddata/sdk-code-schemas` `v1.Metric`.
+ */
+export type MetricYaml = Omit<v1.Metric, "id"> & {
+    id?: string;
+};
+/**
+ * Maps a measure definition (or a loaded measure, which is a superset) to the canonical AAC metric
+ * object for YAML serialization.
+ *
+ * Optional meta fields are omitted when empty so the rendered YAML stays terse, matching the
+ * analytics-as-code tooling output; a hidden metric is expressed as `show_in_ai_results: false`.
+ * 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; a loaded measure always carries it.
+ */
+export declare function definitionToMetricYaml(definition: IMeasureMetadataObjectDefinition): MetricYaml;
+/**
+ * Maps a validated AAC metric object to a backend measure definition.
+ *
+ * `show_in_ai_results` takes precedence over the deprecated `is_hidden` when both are present.
+ */
+export declare function metricYamlToDefinition(metric: MetricSchema): IMeasureMetadataObjectDefinition;
+/**
+ * Overlays the fields the as-code YAML owns onto a base measure, keeping the base's identity and the
+ * fields the YAML cannot express (`metricType`, `isHiddenFromKda`, ...).
+ *
+ * Used wherever YAML edits are committed onto an existing measure: the update flow overlays onto the
+ * loaded metric, and duplicating from the edit dialog seeds the copy from the metric being edited.
+ * Duplicating from the detail panel instead needs YAML-authoritative identity — see
+ * {@link mergeCopiedMetricDefinition}.
+ */
+export declare function overlayMetricYamlFields(base: IMeasureMetadataObject, yamlDefinition: IMeasureMetadataObjectDefinition): IMeasureMetadataObject;
+/**
+ * Builds the definition to persist when duplicating a metric, layering the author's YAML edits over
+ * the copied source.
+ *
+ * The source carries fields the YAML cannot express (`metricType`, `isHiddenFromKda`), 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 copied source's id is
+ * intentionally dropped from the base first.
+ */
+export declare function mergeCopiedMetricDefinition(copiedMetric: IMeasureMetadataObjectDefinition, yamlDefinition: IMeasureMetadataObjectDefinition): IMeasureMetadataObjectDefinition;
+//# sourceMappingURL=metricConverter.d.ts.map

package/esm/metric/metricConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricConverter.d.ts","sourceRoot":"","sources":["../../src/metric/metricConverter.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,4BAA4B,CAAC;AACrD,OAAO,KAAK,EAAE,sBAAsB,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAEpG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,IAAI,CAAC,EAAE,CAAC,MAAM,EAAE,IAAI,CAAC,GAAG;IAAE,EAAE,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gCAAgC,GAAG,UAAU,CAW/F;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,YAAY,GAAG,gCAAgC,CAY7F;AAsCD;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACnC,IAAI,EAAE,sBAAsB,EAC5B,cAAc,EAAE,gCAAgC,GACjD,sBAAsB,CAKxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CACvC,YAAY,EAAE,gCAAgC,EAC9C,cAAc,EAAE,gCAAgC,GACjD,gCAAgC,CAOlC"}

package/esm/metric/metricConverter.js

@@ -0,0 +1,101 @@
+// (C) 2026 GoodData Corporation
+/**
+ * Maps a measure definition (or a loaded measure, which is a superset) to the canonical AAC metric
+ * object for YAML serialization.
+ *
+ * Optional meta fields are omitted when empty so the rendered YAML stays terse, matching the
+ * analytics-as-code tooling output; a hidden metric is expressed as `show_in_ai_results: false`.
+ * 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; a loaded measure always carries it.
+ */
+export function definitionToMetricYaml(definition) {
+    return {
+        type: "metric",
+        ...(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.format ? { format: definition.format } : {}),
+        ...(definition.isHidden === true ? { show_in_ai_results: false } : {}),
+    };
+}
+/**
+ * Maps a validated AAC metric object to a backend measure definition.
+ *
+ * `show_in_ai_results` takes precedence over the deprecated `is_hidden` when both are present.
+ */
+export function metricYamlToDefinition(metric) {
+    const isHidden = resolveIsHidden(metric);
+    return {
+        type: "measure",
+        ...(metric.id === undefined ? {} : { id: metric.id }),
+        title: metric.title ?? "",
+        description: metric.description ?? "",
+        tags: metric.tags ?? [],
+        expression: metric.maql,
+        format: metric.format ?? "",
+        ...(isHidden === undefined ? {} : { isHidden }),
+    };
+}
+function resolveIsHidden(metric) {
+    if (metric.show_in_ai_results !== undefined) {
+        return metric.show_in_ai_results === false;
+    }
+    if (metric.is_hidden !== undefined) {
+        return metric.is_hidden;
+    }
+    return undefined;
+}
+/**
+ * The fields the as-code metric YAML owns, extracted from a parsed definition and normalized for
+ * persistence. Every other field on a measure — `metricType`, `isHiddenFromKda`, and a loaded
+ * measure's identity (`ref`, `uri`) — lies outside the YAML projection and is preserved by layering
+ * these fields over a base object rather than replacing it.
+ *
+ * `isHidden` is always returned (normalized to `false` when absent), never omitted: it must
+ * overwrite the base so that clearing `show_in_ai_results` unhides a previously hidden metric. Were
+ * it omitted when undefined, the base's stale `isHidden` would leak through the overlay.
+ */
+function pickMetricYamlFields(definition) {
+    return {
+        title: definition.title ?? "",
+        description: definition.description ?? "",
+        tags: definition.tags ?? [],
+        expression: definition.expression,
+        format: definition.format ?? "",
+        isHidden: definition.isHidden ?? false,
+    };
+}
+/**
+ * Overlays the fields the as-code YAML owns onto a base measure, keeping the base's identity and the
+ * fields the YAML cannot express (`metricType`, `isHiddenFromKda`, ...).
+ *
+ * Used wherever YAML edits are committed onto an existing measure: the update flow overlays onto the
+ * loaded metric, and duplicating from the edit dialog seeds the copy from the metric being edited.
+ * Duplicating from the detail panel instead needs YAML-authoritative identity — see
+ * {@link mergeCopiedMetricDefinition}.
+ */
+export function overlayMetricYamlFields(base, yamlDefinition) {
+    return {
+        ...base,
+        ...pickMetricYamlFields(yamlDefinition),
+    };
+}
+/**
+ * Builds the definition to persist when duplicating a metric, layering the author's YAML edits over
+ * the copied source.
+ *
+ * The source carries fields the YAML cannot express (`metricType`, `isHiddenFromKda`), 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 copied source's id is
+ * intentionally dropped from the base first.
+ */
+export function mergeCopiedMetricDefinition(copiedMetric, yamlDefinition) {
+    const { id: _copiedId, ...carriedOver } = copiedMetric;
+    return {
+        ...carriedOver,
+        ...pickMetricYamlFields(yamlDefinition),
+        ...(yamlDefinition.id === undefined ? {} : { id: yamlDefinition.id }),
+    };
+}

package/esm/metric/metricCopy.d.ts

@@ -0,0 +1,4 @@
+import type { IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+export declare function createCopiedMetric(metric: IMeasureMetadataObjectDefinition): IMeasureMetadataObjectDefinition;
+export declare function isDuplicateIdError(error: unknown): boolean;
+//# sourceMappingURL=metricCopy.d.ts.map

package/esm/metric/metricCopy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricCopy.d.ts","sourceRoot":"","sources":["../../src/metric/metricCopy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAK5E,wBAAgB,kBAAkB,CAC9B,MAAM,EAAE,gCAAgC,GACzC,gCAAgC,CAkBlC;AAwCD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,OAAO,GAAG,OAAO,CAE1D"}

package/esm/metric/metricCopy.js

@@ -0,0 +1,60 @@
+// (C) 2026 GoodData Corporation
+import { isUnexpectedResponseError } from "@gooddata/sdk-backend-spi";
+const canonicalUuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const trailingCopySuffixRegex = /^(.*) \((\d+)\)$/;
+export function createCopiedMetric(metric) {
+    const title = getCopiedTitle(metric.title);
+    const id = shouldOmitCopiedId(metric.id) ? undefined : getCopiedId(title);
+    // Whitelist only definition-owned fields; the source may be a loaded measure carrying
+    // server-managed fields (uri, ref, timestamps, ...) that must not leak into the definition.
+    // metricType and isHiddenFromKda are author-owned semantics, so they carry over to the copy.
+    return {
+        type: "measure",
+        ...(id === undefined ? {} : { id }),
+        ...(title === undefined ? {} : { title }),
+        description: metric.description,
+        tags: metric.tags,
+        expression: metric.expression,
+        format: metric.format,
+        ...(metric.metricType === undefined ? {} : { metricType: metric.metricType }),
+        ...(metric.isHidden === undefined ? {} : { isHidden: metric.isHidden }),
+        ...(metric.isHiddenFromKda === undefined ? {} : { isHiddenFromKda: metric.isHiddenFromKda }),
+    };
+}
+function getCopiedTitle(title) {
+    if (title === undefined) {
+        return undefined;
+    }
+    if (title === "") {
+        return "";
+    }
+    const match = title.match(trailingCopySuffixRegex);
+    if (match) {
+        const [, prefix, suffix] = match;
+        return `${prefix} (${Number(suffix) + 1})`;
+    }
+    return `${title} (2)`;
+}
+// A UUID id was server-generated, so the copy omits its id and lets the server generate a fresh one.
+// A human-authored id (e.g. "revenue.total") is instead re-derived from the copied title to stay
+// readable; a resulting collision is handled by the create 409 retry-without-id.
+function shouldOmitCopiedId(id) {
+    return id === undefined || isCanonicalUuid(id);
+}
+function getCopiedId(title) {
+    if (!title) {
+        return undefined;
+    }
+    const normalizedTitle = title
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(/\W/g, "_")
+        .toLowerCase();
+    return normalizedTitle || undefined;
+}
+function isCanonicalUuid(value) {
+    return canonicalUuidRegex.test(value);
+}
+export function isDuplicateIdError(error) {
+    return isUnexpectedResponseError(error) && error.httpStatus === 409;
+}

package/esm/metric/metricMutationPort.d.ts

@@ -0,0 +1,18 @@
+import type { IAnalyticalBackend, IMeasureReferencing } from "@gooddata/sdk-backend-spi";
+import { type IMeasureMetadataObject, type IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+import type { ICatalogItemMeasure, ICatalogItemRef } from "../catalogItem/types.js";
+/**
+ * @internal
+ */
+export interface IMetricMutationPort {
+    create(definition: IMeasureMetadataObjectDefinition): Promise<ICatalogItemMeasure>;
+    update(existing: IMeasureMetadataObject, definition: IMeasureMetadataObjectDefinition): Promise<ICatalogItemMeasure>;
+    delete(ref: ICatalogItemRef): Promise<void>;
+    load(ref: ICatalogItemRef): Promise<IMeasureMetadataObject>;
+    getReferencingObjects(ref: ICatalogItemRef): Promise<IMeasureReferencing>;
+}
+/**
+ * @internal
+ */
+export declare function createMetricMutationAdapter(backend: IAnalyticalBackend, workspace: string): IMetricMutationPort;
+//# sourceMappingURL=metricMutationPort.d.ts.map

package/esm/metric/metricMutationPort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricMutationPort.d.ts","sourceRoot":"","sources":["../../src/metric/metricMutationPort.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AACzF,OAAO,EACH,KAAK,sBAAsB,EAC3B,KAAK,gCAAgC,EAExC,MAAM,qBAAqB,CAAC;AAU7B,OAAO,KAAK,EAAE,mBAAmB,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAIpF;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAChC,MAAM,CAAC,UAAU,EAAE,gCAAgC,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;IACnF,MAAM,CACF,QAAQ,EAAE,sBAAsB,EAChC,UAAU,EAAE,gCAAgC,GAC7C,OAAO,CAAC,mBAAmB,CAAC,CAAC;IAChC,MAAM,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAC5C,IAAI,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAC5D,qBAAqB,CAAC,GAAG,EAAE,eAAe,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAAC;CAC7E;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CACvC,OAAO,EAAE,kBAAkB,EAC3B,SAAS,EAAE,MAAM,GAClB,mBAAmB,CA4BrB"}

package/esm/metric/metricMutationPort.js

@@ -0,0 +1,39 @@
+// (C) 2026 GoodData Corporation
+import { idRef, } from "@gooddata/sdk-model";
+import { convertMeasureToCatalogItem } from "../catalogItem/converter.js";
+import { createMeasureCatalogItem, deleteMeasureCatalogItem, getMeasureCatalogItem, getMeasureReferencingObjectsCatalogItem, updateMeasureCatalogItem, } from "../catalogItem/query.js";
+import { overlayMetricYamlFields } from "./metricConverter.js";
+/**
+ * @internal
+ */
+export function createMetricMutationAdapter(backend, workspace) {
+    return {
+        async create(definition) {
+            const savedMeasure = await createMeasureCatalogItem(backend, workspace, definition);
+            return convertMeasureToCatalogItem(savedMeasure);
+        },
+        async update(existing, definition) {
+            const savedMeasure = await updateMeasureCatalogItem(backend, workspace, mergeMeasureDefinition(existing, definition));
+            return convertMeasureToCatalogItem(savedMeasure);
+        },
+        async delete(ref) {
+            await deleteMeasureCatalogItem(backend, workspace, idRef(ref.identifier, "measure"));
+        },
+        async load(ref) {
+            return getMeasureCatalogItem(backend, workspace, idRef(ref.identifier, "measure"));
+        },
+        async getReferencingObjects(ref) {
+            return getMeasureReferencingObjectsCatalogItem(backend, workspace, idRef(ref.identifier, "measure"));
+        },
+    };
+}
+/**
+ * Overlays the fields the as-code YAML owns onto the loaded metric.
+ *
+ * The measures update endpoint is a full replace, so fields absent from the YAML
+ * (`metricType`, `isHiddenFromKda`, identity, ...) must be carried over from the loaded metric to
+ * avoid wiping them; `overlayMetricYamlFields` preserves them via the base spread.
+ */
+function mergeMeasureDefinition(existing, definition) {
+    return overlayMetricYamlFields(existing, definition);
+}

package/esm/metric/metricSchema.d.ts

@@ -0,0 +1,29 @@
+import * as z from "zod/mini";
+/**
+ * Zod schema for the analytics-as-code (AAC) metric YAML shape.
+ *
+ * Field names and structure mirror the canonical AAC metric definition
+ * (`@gooddata/sdk-code-schemas` `v1.Metric`) so YAML authored here is interchangeable
+ * with metrics 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 metricSchema: z.ZodMiniObject<{
+    type: z.ZodMiniDefault<z.ZodMiniLiteral<"metric">>;
+    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>;
+    format: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    show_in_ai_results: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    is_hidden: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$strict>;
+export type MetricSchemaInput = z.input<typeof metricSchema>;
+export type MetricSchema = z.infer<typeof metricSchema>;
+/**
+ * Allowed YAML property names keyed by parent mapping, used to power editor autocompletion.
+ * The metric 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 METRIC_SCHEMA_KEYS: Record<string, string[]>;
+//# sourceMappingURL=metricSchema.d.ts.map

package/esm/metric/metricSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricSchema.d.ts","sourceRoot":"","sources":["../../src/metric/metricSchema.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,CAAC,MAAM,UAAU,CAAC;AAE9B;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;kBAWvB,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAC7D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAEvD,CAAC"}

package/esm/metric/metricSchema.js

@@ -0,0 +1,30 @@
+// (C) 2026 GoodData Corporation
+import * as z from "zod/mini";
+/**
+ * Zod schema for the analytics-as-code (AAC) metric YAML shape.
+ *
+ * Field names and structure mirror the canonical AAC metric definition
+ * (`@gooddata/sdk-code-schemas` `v1.Metric`) so YAML authored here is interchangeable
+ * with metrics 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 metricSchema = z.strictObject({
+    type: z._default(z.literal("metric"), "metric"),
+    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(),
+    format: z.optional(z.string()),
+    show_in_ai_results: z.optional(z.boolean()),
+    // Deprecated predecessor of `show_in_ai_results`; accepted so AAC exports still parse.
+    is_hidden: z.optional(z.boolean()),
+});
+/**
+ * Allowed YAML property names keyed by parent mapping, used to power editor autocompletion.
+ * The metric 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 METRIC_SCHEMA_KEYS = {
+    "": Object.keys(metricSchema.shape),
+};

package/esm/metric/metricSerialization.d.ts

@@ -0,0 +1,10 @@
+import type { MetricYaml } from "./metricConverter.js";
+/**
+ * Serializes a canonical AAC metric object to YAML.
+ *
+ * A blank line is placed before `title` and `maql` to visually group identity, metadata,
+ * and definition, matching the analytics-as-code tooling layout. The `id` line is omitted when
+ * the metric has none so the server derives one on create.
+ */
+export declare function serializeMetricToYaml(metric: MetricYaml): string;
+//# sourceMappingURL=metricSerialization.d.ts.map

package/esm/metric/metricSerialization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricSerialization.d.ts","sourceRoot":"","sources":["../../src/metric/metricSerialization.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAEvD;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM,CAsBhE"}

package/esm/metric/metricSerialization.js

@@ -0,0 +1,33 @@
+// (C) 2026 GoodData Corporation
+import { Document, Pair, Scalar } from "yaml";
+/**
+ * Serializes a canonical AAC metric object to YAML.
+ *
+ * A blank line is placed before `title` and `maql` to visually group identity, metadata,
+ * and definition, matching the analytics-as-code tooling layout. The `id` line is omitted when
+ * the metric has none so the server derives one on create.
+ */
+export function serializeMetricToYaml(metric) {
+    const doc = new Document(metric.id === undefined ? { type: "metric" } : { type: "metric", id: metric.id });
+    doc.add(spacedPair("title", metric.title ?? ""));
+    if (metric.description) {
+        doc.add(doc.createPair("description", metric.description));
+    }
+    if (metric.tags && metric.tags.length > 0) {
+        doc.add(doc.createPair("tags", metric.tags));
+    }
+    doc.add(spacedPair("maql", metric.maql ?? ""));
+    if (metric.format) {
+        doc.add(doc.createPair("format", metric.format));
+    }
+    if (metric.show_in_ai_results === false) {
+        doc.add(doc.createPair("show_in_ai_results", false));
+    }
+    return doc.toString({ lineWidth: 0 }).trimEnd();
+}
+/** Builds a map entry preceded by a blank line. */
+function spacedPair(key, value) {
+    const keyScalar = new Scalar(key);
+    keyScalar.spaceBefore = true;
+    return new Pair(keyScalar, value);
+}

package/esm/metric/metricValidation.d.ts

@@ -0,0 +1,15 @@
+import type { IMeasureMetadataObjectDefinition } from "@gooddata/sdk-model";
+export type MetricValidationResult = {
+    isValid: true;
+    measure: IMeasureMetadataObjectDefinition;
+} | {
+    isValid: false;
+    errorCode: MetricValidationErrorCode;
+};
+export type MetricValidationErrorCode = "empty" | "syntax" | "invalidStructure" | "idImmutable" | "missingMaql" | "invalidTags";
+type ValidateMetricYamlOptions = {
+    fixedIdentifier?: string;
+};
+export declare function validateMetricYaml(value: string, options?: ValidateMetricYamlOptions): MetricValidationResult;
+export {};
+//# sourceMappingURL=metricValidation.d.ts.map

package/esm/metric/metricValidation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metricValidation.d.ts","sourceRoot":"","sources":["../../src/metric/metricValidation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,qBAAqB,CAAC;AAK5E,MAAM,MAAM,sBAAsB,GAC5B;IACI,OAAO,EAAE,IAAI,CAAC;IACd,OAAO,EAAE,gCAAgC,CAAC;CAC7C,GACD;IACI,OAAO,EAAE,KAAK,CAAC;IACf,SAAS,EAAE,yBAAyB,CAAC;CACxC,CAAC;AAER,MAAM,MAAM,yBAAyB,GAC/B,OAAO,GACP,QAAQ,GACR,kBAAkB,GAClB,aAAa,GACb,aAAa,GACb,aAAa,CAAC;AAEpB,KAAK,yBAAyB,GAAG;IAC7B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAgB,kBAAkB,CAC9B,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,yBAA8B,GACxC,sBAAsB,CAyBxB"}