@gooddata/sdk-code-convertors 11.30.0-alpha.2 → 11.30.0-alpha.4

package/esm/from/declarativeVisualisationToYaml.js

@@ -24,18 +24,23 @@ import { table } from "../configs/table.js";
 import { treemapChart } from "../configs/treemapChart.js";
 import { waterfallChart } from "../configs/waterfallChart.js";
 import { BucketsType } from "../types.js";
-import { CoreErrorCode, newError } from "../utils/errors.js";
+import { CoreErrorCode, newError, updateErrorContext } from "../utils/errors.js";
 import { matchConditionToYaml, parseDateValues } from "../utils/filterUtils.js";
 import { parseGranularity } from "../utils/granularityUtils.js";
 import { remapLocationAttribute } from "../utils/locationUtils.js";
 import { VISUALISATION_COMMENT } from "../utils/texts.js";
 import { cleanUpItems, createFilterItemKeyName, entryWithSpace, fillOptionalMetaFields, getIdentifier, } from "../utils/yamlUtils.js";
 /** @public */
-export function declarativeVisualisationToYaml(entities, visualisation) {
+export function declarativeVisualisationToYaml(entities, visualisation, context) {
+    const errorContext = updateErrorContext(context, {
+        type: "visualisation",
+        path: ["visualisation", visualisation.id],
+        data: {},
+    });
     // Build visualisation object
     const insight = { insight: visualisation.content };
     if (!isInsight(insight)) {
-        throw newError(CoreErrorCode.VisualizationNotSupported, [JSON.stringify(insight)]);
+        throw newError(CoreErrorCode.VisualizationNotSupported, [JSON.stringify(insight)], errorContext);
     }
     // Load type
     const type = declarativeVisTypeToYaml(insight.insight);
@@ -57,9 +62,13 @@ export function declarativeVisualisationToYaml(entities, visualisation) {
     if (visualisation.isHidden === true) {
         doc.add(doc.createPair("show_in_ai_results", false));
     }
-    const report = declarativeReportToYaml(entities, insight.insight);
+    const report = declarativeReportToYaml(entities, insight.insight, updateErrorContext(errorContext, {
+        path: ["insight"],
+    }));
     doc.add(entryWithSpace("query", report.report));
-    declarativeVisToYaml(doc, insight.insight, report, entities);
+    declarativeVisToYaml(doc, insight.insight, report, entities, updateErrorContext(errorContext, {
+        path: ["insight"],
+    }));
     return {
         content: doc.toString({
             lineWidth: 0,
@@ -67,25 +76,39 @@ export function declarativeVisualisationToYaml(entities, visualisation) {
         json: doc.toJSON(),
     };
 }
-function declarativeReportToYaml(entities, def) {
+function declarativeReportToYaml(entities, def, errorContext) {
     const report = new YAMLMap();
-    const { fieldsMap, postProcessors, groups: derivedBuckets, } = declarativeBucketsToYaml(entities, def.buckets);
-    appendLayerFieldsToReport(fieldsMap, postProcessors, entities, def.layers);
+    const { fieldsMap, postProcessors, groups: derivedBuckets, } = declarativeBucketsToYaml(entities, def.buckets, updateErrorContext(errorContext, {
+        path: ["buckets"],
+    }));
+    appendLayerFieldsToReport(fieldsMap, postProcessors, entities, def.layers, updateErrorContext(errorContext, {
+        path: ["layers"],
+    }));
     if (fieldsMap.items.length > 0) {
         report.add(new Pair("fields", fieldsMap));
     }
-    const { filtersArray, filtersMap } = declarativeFiltersToYaml(entities, def.filters ?? []);
-    declarativeFiltersConfigToYaml(def, filtersMap);
+    const { filtersArray, filtersMap } = declarativeFiltersToYaml(entities, def.filters ?? [], updateErrorContext(errorContext, {
+        path: ["filters"],
+    }));
+    declarativeFiltersConfigToYaml(def, filtersMap, updateErrorContext(errorContext, {
+        path: ["filters"],
+    }));
     if (filtersArray.items.length > 0) {
         report.add(entryWithSpace("filter_by", filtersArray));
     }
-    const { sortsArray } = declarativeSortsToYaml(def.sorts ?? []);
+    const { sortsArray } = declarativeSortsToYaml(def.sorts ?? [], updateErrorContext(errorContext, {
+        path: ["sorts"],
+    }));
     if (sortsArray.length > 0) {
         report.add(entryWithSpace("sort_by", sortsArray));
     }
-    postProcessors.filters?.forEach(({ filters, item }) => {
-        const { filtersArray, filtersMap } = declarativeFiltersToYaml(entities, filters);
-        declarativeFiltersConfigToYaml(def, filtersMap);
+    postProcessors.filters?.forEach(({ filters, item }, i) => {
+        const { filtersArray, filtersMap } = declarativeFiltersToYaml(entities, filters, updateErrorContext(errorContext, {
+            path: ["filters", i.toString()],
+        }));
+        declarativeFiltersConfigToYaml(def, filtersMap, updateErrorContext(errorContext, {
+            path: ["filters", i.toString()],
+        }));
         if (filtersArray.items.length > 0) {
             item.add(new Pair("filter_by", filtersArray));
         }
@@ -95,15 +118,17 @@ function declarativeReportToYaml(entities, def) {
         derivedBuckets,
     };
 }
-function appendLayerFieldsToReport(fieldsMap, postProcessors, entities, layers) {
+function appendLayerFieldsToReport(fieldsMap, postProcessors, entities, layers, errorContext) {
     if (!layers || layers.length === 0) {
         return;
     }
     const knownKeys = new Set(fieldsMap.items
         .map((pair) => getPairKeyValue(pair))
         .filter((key) => typeof key === "string" && key.length > 0));
-    layers.forEach((layer) => {
-        const { fieldsMap: layerFieldsMap, postProcessors: layerPostProcessors } = declarativeBucketsToYaml(entities, layer.buckets ?? []);
+    layers.forEach((layer, li) => {
+        const { fieldsMap: layerFieldsMap, postProcessors: layerPostProcessors } = declarativeBucketsToYaml(entities, layer.buckets ?? [], updateErrorContext(errorContext, {
+            path: [li.toString(), "buckets"],
+        }));
         const valueMapping = new Map();
         layerFieldsMap.items.forEach((pair) => {
             const keyValue = getPairKeyValue(pair);
@@ -148,14 +173,16 @@ function getPairKeyValue(pair) {
     }
     return undefined;
 }
-export function declarativeFiltersConfigToYaml(insight, filtersMap) {
+export function declarativeFiltersConfigToYaml(insight, filtersMap, errorContext) {
     Object.keys(insight.attributeFilterConfigs ?? {}).forEach((key) => {
         const filter = filtersMap[key];
         if (filter) {
             const localIdentifier = filterLocalIdentifier(filter.filter);
             if (localIdentifier) {
                 if (insight.attributeFilterConfigs[localIdentifier].displayAsLabel) {
-                    filter.yaml.add(new Pair("display_as", getIdentifier(insight.attributeFilterConfigs[localIdentifier].displayAsLabel)));
+                    filter.yaml.add(new Pair("display_as", getIdentifier(insight.attributeFilterConfigs[localIdentifier].displayAsLabel, undefined, updateErrorContext(errorContext, {
+                        path: ["attributeFilterConfigs", key, "displayAsLabel"],
+                    }))));
                 }
             }
         }
@@ -211,79 +238,85 @@ export function declarativeVisTypeToYaml(def) {
             return null;
     }
 }
-function declarativeVisToYaml(doc, def, report, entities) {
+function declarativeVisToYaml(doc, def, report, entities, errorContext) {
+    const context = updateErrorContext(errorContext, {
+        data: {
+            ...(errorContext?.data ?? {}),
+            type: def.visualizationUrl,
+        },
+    });
     switch (def.visualizationUrl) {
         case "local:table":
-            declarativeVisTableToYaml(doc, def, report);
+            declarativeVisTableToYaml(doc, def, report, context);
             break;
         case "local:bar":
-            declarativeVisBarToYaml(doc, def, report);
+            declarativeVisBarToYaml(doc, def, report, context);
             break;
         case "local:column":
-            declarativeVisColumnToYaml(doc, def, report);
+            declarativeVisColumnToYaml(doc, def, report, context);
             break;
         case "local:line":
-            declarativeVisLineToYaml(doc, def, report);
+            declarativeVisLineToYaml(doc, def, report, context);
             break;
         case "local:area":
-            declarativeVisAreaToYaml(doc, def, report);
+            declarativeVisAreaToYaml(doc, def, report, context);
             break;
         case "local:scatter":
-            declarativeVisScatterToYaml(doc, def, report);
+            declarativeVisScatterToYaml(doc, def, report, context);
             break;
         case "local:bubble":
-            declarativeVisBubbleToYaml(doc, def, report);
+            declarativeVisBubbleToYaml(doc, def, report, context);
             break;
         case "local:pie":
-            declarativeVisPieToYaml(doc, def, report);
+            declarativeVisPieToYaml(doc, def, report, context);
             break;
         case "local:donut":
-            declarativeVisDonutToYaml(doc, def, report);
+            declarativeVisDonutToYaml(doc, def, report, context);
             break;
         case "local:treemap":
-            declarativeVisTreemapToYaml(doc, def, report);
+            declarativeVisTreemapToYaml(doc, def, report, context);
             break;
         case "local:pyramid":
-            declarativeVisPyramidToYaml(doc, def, report);
+            declarativeVisPyramidToYaml(doc, def, report, context);
             break;
         case "local:funnel":
-            declarativeVisFunnelToYaml(doc, def, report);
+            declarativeVisFunnelToYaml(doc, def, report, context);
             break;
         case "local:heatmap":
-            declarativeVisHeatmapToYaml(doc, def, report);
+            declarativeVisHeatmapToYaml(doc, def, report, context);
             break;
         case "local:bullet":
-            declarativeVisBulletToYaml(doc, def, report);
+            declarativeVisBulletToYaml(doc, def, report, context);
             break;
         case "local:waterfall":
-            declarativeVisWaterfallToYaml(doc, def, report);
+            declarativeVisWaterfallToYaml(doc, def, report, context);
             break;
         case "local:dependencywheel":
-            declarativeVisDependencyWheelToYaml(doc, def, report);
+            declarativeVisDependencyWheelToYaml(doc, def, report, context);
             break;
         case "local:sankey":
-            declarativeVisSankeyToYaml(doc, def, report);
+            declarativeVisSankeyToYaml(doc, def, report, context);
             break;
         case "local:headline":
-            declarativeVisHeadlineToYaml(doc, def, report);
+            declarativeVisHeadlineToYaml(doc, def, report, context);
             break;
         case "local:combo2":
-            declarativeVisComboToYaml(doc, def, report);
+            declarativeVisComboToYaml(doc, def, report, context);
             break;
         case "local:pushpin":
-            declarativeVisGeoToYaml(doc, def, report, entities);
+            declarativeVisGeoToYaml(doc, def, report, entities, context);
             break;
         case "local:choropleth":
-            declarativeVisGeoAreaToYaml(doc, def, report, entities);
+            declarativeVisGeoAreaToYaml(doc, def, report, entities, context);
             break;
         case "local:repeater":
-            declarativeVisRepeaterToYaml(doc, def, report);
+            declarativeVisRepeaterToYaml(doc, def, report, context);
             break;
         default:
             break;
     }
 }
-export function declarativeBucketsToYaml(entities, buckets) {
+export function declarativeBucketsToYaml(entities, buckets, errorContext) {
     const fullFieldsMap = new YAMLMap();
     const groups = [];
     const postProcessors = {
@@ -294,22 +327,29 @@ export function declarativeBucketsToYaml(entities, buckets) {
         group.items.push(createBucketGroupItem(local, format, axis));
     };
     //create buckets
-    buckets.forEach((bucket) => {
+    buckets.forEach((bucket, bi) => {
         if (isBucket(bucket)) {
             const group = { items: [], type: bucket.localIdentifier };
             const attributesMap = {};
             const isLocation = bucket.localIdentifier === BucketsType.Location;
             //items
-            bucket.items.forEach((item) => {
+            bucket.items.forEach((item, ii) => {
+                const bucketItemErrorContext = updateErrorContext(errorContext, {
+                    path: [bi.toString(), "items", ii.toString()],
+                });
                 if (isAttribute(item) && isLocation) {
                     const remapped = remapLocationAttribute(entities, item);
-                    const def = declarativeAttributeToYaml(remapped.attribute);
+                    const def = declarativeAttributeToYaml(remapped.attribute, updateErrorContext(bucketItemErrorContext, {
+                        path: ["attribute"],
+                    }));
                     addField(item.attribute.localIdentifier, def, group);
                     attributesMap[item.attribute.localIdentifier] = def;
                     return;
                 }
                 if (isAttribute(item)) {
-                    const def = declarativeAttributeToYaml(item.attribute);
+                    const def = declarativeAttributeToYaml(item.attribute, updateErrorContext(bucketItemErrorContext, {
+                        path: ["attribute"],
+                    }));
                     addField(item.attribute.localIdentifier, def, group);
                     attributesMap[item.attribute.localIdentifier] = def;
                     return;
@@ -321,7 +361,9 @@ export function declarativeBucketsToYaml(entities, buckets) {
                     return;
                 }
                 if (isMeasure(item) && isMeasureDefinition(item.measure.definition)) {
-                    const def = declarativeNormalMetricToYaml(item.measure, item.measure.definition, postProcessors);
+                    const def = declarativeNormalMetricToYaml(item.measure, item.measure.definition, postProcessors, updateErrorContext(bucketItemErrorContext, {
+                        path: ["measure"],
+                    }));
                     addField(item.measure.localIdentifier, def, group, { format: item.measure.format });
                     attributesMap[item.measure.localIdentifier] = def;
                     return;
@@ -333,22 +375,29 @@ export function declarativeBucketsToYaml(entities, buckets) {
                     return;
                 }
                 if (isMeasure(item) && isPoPMeasureDefinition(item.measure.definition)) {
-                    const def = declarativePoPMetricToYaml(item.measure, item.measure.definition);
+                    const def = declarativePoPMetricToYaml(item.measure, item.measure.definition, updateErrorContext(bucketItemErrorContext, {
+                        path: ["measure"],
+                    }));
                     addField(item.measure.localIdentifier, def, group, { format: item.measure.format });
                     attributesMap[item.measure.localIdentifier] = def;
                     return;
                 }
                 if (isMeasure(item) && isPreviousPeriodMeasureDefinition(item.measure.definition)) {
-                    const def = declarativePreviousPeriodMetricToYaml(item.measure, item.measure.definition);
+                    const def = declarativePreviousPeriodMetricToYaml(item.measure, item.measure.definition, updateErrorContext(bucketItemErrorContext, {
+                        path: ["measure"],
+                    }));
                     addField(item.measure.localIdentifier, def, group, { format: item.measure.format });
                     attributesMap[item.measure.localIdentifier] = def;
                     return;
                 }
-                throw newError(CoreErrorCode.BucketItemTypeNotSupported, [JSON.stringify(item)]);
+                throw newError(CoreErrorCode.BucketItemTypeNotSupported, [JSON.stringify(item)], bucketItemErrorContext);
             });
             //totals
-            bucket.totals?.forEach((total) => {
-                const { totalMap, attribute } = declarativeTotalToYaml(total);
+            bucket.totals?.forEach((total, ti) => {
+                const totalItemErrorContext = updateErrorContext(errorContext, {
+                    path: [bi.toString(), "totals", ti.toString()],
+                });
+                const { totalMap, attribute } = declarativeTotalToYaml(total, totalItemErrorContext);
                 const item = group.items.find((item) => item?.field === attribute);
                 if (item) {
                     item.totals = [...(item.totals ?? []), totalMap];
@@ -377,12 +426,14 @@ export function declarativeBucketsToYaml(entities, buckets) {
         postProcessors,
     };
 }
-export function declarativeAttributeToYaml(def) {
+export function declarativeAttributeToYaml(def, errorContext) {
     const map = new YAMLMap();
     if (def.alias) {
         map.add(new Pair("title", def.alias));
     }
-    const id = getIdentifier(def.displayForm);
+    const id = getIdentifier(def.displayForm, undefined, updateErrorContext(errorContext, {
+        path: ["displayForm"],
+    }));
     map.add(new Pair("using", id));
     if (def.showAllValues) {
         map.add(new Pair("show_all_values", true));
@@ -396,7 +447,7 @@ export function declarativeInlineMetricToYaml(def, inlineDef) {
     map.add(new Pair("maql", id.maql));
     return map;
 }
-export function declarativeNormalMetricToYaml(def, metricDefinition, postProcessors) {
+export function declarativeNormalMetricToYaml(def, metricDefinition, postProcessors, errorContext) {
     const map = new YAMLMap();
     fillDefaultMetricProperties(map, def);
     const md = metricDefinition.measureDefinition;
@@ -409,7 +460,9 @@ export function declarativeNormalMetricToYaml(def, metricDefinition, postProcess
     if (md.filters && md.filters.length > 0) {
         postProcessors.filters.push({ item: map, filters: md.filters });
     }
-    const id = getIdentifier(md.item);
+    const id = getIdentifier(md.item, undefined, updateErrorContext(errorContext, {
+        path: ["item"],
+    }));
     map.add(new Pair("using", id));
     return map;
 }
@@ -421,26 +474,32 @@ export function declarativeArithmeticMetricToYaml(def, arithmeticDefinition) {
     map.add(new Pair("using", ad.measureIdentifiers));
     return map;
 }
-export function declarativePoPMetricToYaml(def, popDefinition) {
+export function declarativePoPMetricToYaml(def, popDefinition, errorContext) {
     const map = new YAMLMap();
     fillDefaultMetricProperties(map, def);
     const pop = popDefinition.popMeasureDefinition;
-    const id = getIdentifier(pop.popAttribute, true);
+    const id = getIdentifier(pop.popAttribute, true, updateErrorContext(errorContext, {
+        path: ["popAttribute"],
+    }));
     const [date] = id.split(".");
     map.add(new Pair("type", "PREVIOUS_YEAR"));
     map.add(new Pair("date_filter", date));
     map.add(new Pair("using", pop.measureIdentifier));
     return map;
 }
-export function declarativePreviousPeriodMetricToYaml(def, previousDefinition) {
+export function declarativePreviousPeriodMetricToYaml(def, previousDefinition, errorContext) {
     const map = new YAMLMap();
     fillDefaultMetricProperties(map, def);
     const previous = previousDefinition.previousPeriodMeasure;
     if (previous.dateDataSets.length > 1) {
-        throw newError(CoreErrorCode.MultipleDateDataSets, [JSON.stringify(previous)]);
+        throw newError(CoreErrorCode.MultipleDateDataSets, [JSON.stringify(previous)], updateErrorContext(errorContext, {
+            path: ["previousPeriodMeasure", "dateDataSets"],
+        }));
     }
     const prev = previous.dateDataSets[0];
-    const id = getIdentifier(prev.dataSet, true);
+    const id = getIdentifier(prev.dataSet, true, updateErrorContext(errorContext, {
+        path: ["dateSet"],
+    }));
     const [date] = id.split(".");
     map.add(new Pair("type", "PREVIOUS_PERIOD"));
     if (prev.periodsAgo > 1) {
@@ -533,35 +592,37 @@ function groupFiltersByDateFilter(filters) {
     };
     dateFilters.forEach((dateFilter) => {
         const { filterRef: datasetId } = getFilterRefDetails(dateFilter);
+        const fi = filters.indexOf(dateFilter);
         if (datasetId === undefined) {
-            result.rest.push(dateFilter);
+            result.rest.push([dateFilter, fi]);
             return;
         }
         if (result.grouped[datasetId]) {
-            result.rest.push(dateFilter);
+            result.rest.push([dateFilter, fi]);
         }
         else {
-            result.grouped[datasetId] = { dateFilter, attributeFilters: [] };
+            result.grouped[datasetId] = { dateFilter: [dateFilter, fi], attributeFilters: [] };
         }
     });
     nonDateFilters.forEach((filter) => {
         const { filterRef: filterId } = getFilterRefDetails(filter);
+        const fi = filters.indexOf(filter);
         if (filterId === undefined) {
-            result.rest.push(filter);
+            result.rest.push([filter, fi]);
             return;
         }
         const datasetId = filterId.split(".")[0];
         const group = result.grouped[datasetId];
         if (group) {
-            group.attributeFilters.push(filter);
+            group.attributeFilters.push([filter, fi]);
         }
         else {
-            result.rest.push(filter);
+            result.rest.push([filter, fi]);
         }
     });
     return result;
 }
-export function declarativeFiltersToYaml(entities, filters) {
+export function declarativeFiltersToYaml(entities, filters, errorContext) {
     const filtersArray = [];
     const filtersMap = {};
     const usedKeys = new Set();
@@ -576,8 +637,10 @@ export function declarativeFiltersToYaml(entities, filters) {
         return key;
     };
     const filtersGroupedByDateFilter = groupFiltersByDateFilter(filters);
-    filtersGroupedByDateFilter.rest.forEach((filter) => {
-        const result = declarativeFilterToYaml(entities, filter, getUniqueKey);
+    filtersGroupedByDateFilter.rest.forEach(([filter, fi]) => {
+        const result = declarativeFilterToYaml(entities, filter, getUniqueKey, undefined, updateErrorContext(errorContext, {
+            path: [fi.toString()],
+        }));
         if (!result) {
             return;
         }
@@ -589,7 +652,9 @@ export function declarativeFiltersToYaml(entities, filters) {
         };
     });
     Object.values(filtersGroupedByDateFilter.grouped).forEach(({ dateFilter, attributeFilters }) => {
-        const result = declarativeFilterToYaml(entities, dateFilter, getUniqueKey, attributeFilters);
+        const result = declarativeFilterToYaml(entities, dateFilter[0], getUniqueKey, attributeFilters.map(([f]) => f), updateErrorContext(errorContext, {
+            path: [dateFilter[1].toString()],
+        }));
         if (!result) {
             return;
         }
@@ -608,73 +673,91 @@ export function declarativeFiltersToYaml(entities, filters) {
         }, new YAMLMap()),
     };
 }
-function declarativeFilterToYaml(entities, filter, getUniqueKey, connectedAttributeFilters) {
+function declarativeFilterToYaml(entities, filter, getUniqueKey, connectedAttributeFilters, errorContext) {
     if (!isFilter(filter)) {
         return null;
     }
-    const key = getUniqueKey(createFilterItemKeyName(filter));
+    const key = getUniqueKey(createFilterItemKeyName(filter, "date", updateErrorContext(errorContext, {
+        path: ["date"],
+    })));
     if (isAbsoluteDateFilter(filter)) {
         return {
             key,
-            yaml: declarativeAbsoluteDateFilterToYaml(filter.absoluteDateFilter, connectedAttributeFilters, entities, getUniqueKey),
+            yaml: declarativeAbsoluteDateFilterToYaml(filter.absoluteDateFilter, connectedAttributeFilters, entities, getUniqueKey, updateErrorContext(errorContext, {
+                path: ["absoluteDateFilter"],
+            })),
             filter,
         };
     }
     if (isRelativeDateFilter(filter)) {
         return {
             key,
-            yaml: declarativeRelativeDateFilterToYaml(filter.relativeDateFilter, connectedAttributeFilters, entities, getUniqueKey),
+            yaml: declarativeRelativeDateFilterToYaml(filter.relativeDateFilter, connectedAttributeFilters, entities, getUniqueKey, updateErrorContext(errorContext, {
+                path: ["relativeDateFilter"],
+            })),
             filter,
         };
     }
     if (isPositiveAttributeFilter(filter)) {
         return {
             key,
-            yaml: declarativePositiveAttributeFilterToYaml(entities, filter.positiveAttributeFilter),
+            yaml: declarativePositiveAttributeFilterToYaml(entities, filter.positiveAttributeFilter, updateErrorContext(errorContext, {
+                path: ["positiveAttributeFilter"],
+            })),
             filter,
         };
     }
     if (isNegativeAttributeFilter(filter)) {
         return {
             key,
-            yaml: declarativeNegativeAttributeFilterToYaml(entities, filter.negativeAttributeFilter),
+            yaml: declarativeNegativeAttributeFilterToYaml(entities, filter.negativeAttributeFilter, updateErrorContext(errorContext, {
+                path: ["negativeAttributeFilter"],
+            })),
             filter,
         };
     }
     if (isArbitraryAttributeFilter(filter)) {
         return {
             key,
-            yaml: declarativeArbitraryAttributeFilterToYaml(filter.arbitraryAttributeFilter),
+            yaml: declarativeArbitraryAttributeFilterToYaml(filter.arbitraryAttributeFilter, updateErrorContext(errorContext, {
+                path: ["arbitraryAttributeFilter"],
+            })),
             filter,
         };
     }
     if (isMatchAttributeFilter(filter)) {
         return {
             key,
-            yaml: declarativeMatchAttributeFilterToYaml(filter.matchAttributeFilter),
+            yaml: declarativeMatchAttributeFilterToYaml(filter.matchAttributeFilter, updateErrorContext(errorContext, {
+                path: ["matchAttributeFilter"],
+            })),
             filter,
         };
     }
     if (isMeasureValueFilter(filter)) {
         return {
             key,
-            yaml: declarativeMeasureValueFilterToYaml(filter.measureValueFilter),
+            yaml: declarativeMeasureValueFilterToYaml(filter.measureValueFilter, updateErrorContext(errorContext, {
+                path: ["measureValueFilter"],
+            })),
             filter,
         };
     }
     if (isRankingFilter(filter)) {
         return {
             key,
-            yaml: declarativeRankingFilterToYaml(filter.rankingFilter),
+            yaml: declarativeRankingFilterToYaml(filter.rankingFilter, updateErrorContext(errorContext, {
+                path: ["rankingFilter"],
+            })),
             filter,
         };
     }
-    throw newError(CoreErrorCode.FilterItemTypeNotSupported, [JSON.stringify(filter)]);
+    throw newError(CoreErrorCode.FilterItemTypeNotSupported, [JSON.stringify(filter)], errorContext);
 }
 /**
  * Modifies `map`, adding `empty_filters` and `with` keys, populated from connectedAttributeFilters.
  */
-function processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey) {
+function processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey, errorContext) {
     // empty values filter
     const emptyValuesFilter = connectedAttributeFilters.find((filter) => detectEmptyValuesFilterType(filter));
     if (emptyValuesFilter) {
@@ -688,23 +771,25 @@ function processConnectedAttributeFilters(map, connectedAttributeFilters, entiti
     const withMap = new YAMLMap();
     map.add(new Pair("with", withMap));
     additionalAttributeFilters?.forEach((filter) => {
-        const converted = declarativeFilterToYaml(entities, filter, getUniqueKey);
+        const converted = declarativeFilterToYaml(entities, filter, getUniqueKey, undefined, errorContext);
         if (!converted) {
             return;
         }
         withMap.add(new Pair(converted.key, converted.yaml));
     });
 }
-export function declarativeAbsoluteDateFilterToYaml(absoluteDateFilter, connectedAttributeFilters = [], entities, getUniqueKey) {
+export function declarativeAbsoluteDateFilterToYaml(absoluteDateFilter, connectedAttributeFilters = [], entities, getUniqueKey, errorContext) {
     const map = new YAMLMap();
     // base date filter attributes
     map.add(new Pair("type", "date_filter"));
     map.add(new Pair("from", absoluteDateFilter.from));
     map.add(new Pair("to", absoluteDateFilter.to));
-    const id = getIdentifier(absoluteDateFilter.dataSet, true);
+    const id = getIdentifier(absoluteDateFilter.dataSet, true, updateErrorContext(errorContext, {
+        path: ["dateSet"],
+    }));
     map.add(new Pair("using", id));
     // connected attribute filters
-    processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey);
+    processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey, errorContext);
     return map;
 }
 function isRelativeDateFilterAllTime(relativeDateFilter) {
@@ -716,7 +801,7 @@ function isRelativeDateFilterAllTime(relativeDateFilter) {
     // But unfortunately AD emits granularity as GDC.time.year for an all time date filter, so we need this check as well
     return granularity === "GDC.time.year" && from === undefined && to === undefined;
 }
-export function declarativeRelativeDateFilterToYaml(relativeDateFilter, connectedAttributeFilters = [], entities, getUniqueKey) {
+export function declarativeRelativeDateFilterToYaml(relativeDateFilter, connectedAttributeFilters = [], entities, getUniqueKey, errorContext) {
     const map = new YAMLMap();
     map.add(new Pair("type", "date_filter"));
     if (isRelativeDateFilterAllTime(relativeDateFilter)) {
@@ -733,15 +818,19 @@ export function declarativeRelativeDateFilterToYaml(relativeDateFilter, connecte
             map.add(new Pair("to", relativeDateFilter.to));
         }
     }
-    const id = getIdentifier(relativeDateFilter.dataSet, true);
+    const id = getIdentifier(relativeDateFilter.dataSet, true, updateErrorContext(errorContext, {
+        path: ["dataSet"],
+    }));
     map.add(new Pair("using", id));
-    processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey);
+    processConnectedAttributeFilters(map, connectedAttributeFilters, entities, getUniqueKey, errorContext);
     return map;
 }
-export function declarativePositiveAttributeFilterToYaml(entities, attributeFilter) {
+export function declarativePositiveAttributeFilterToYaml(entities, attributeFilter, errorContext) {
     const map = new YAMLMap();
     map.add(new Pair("type", "attribute_filter"));
-    const id = getIdentifier(attributeFilter.displayForm);
+    const id = getIdentifier(attributeFilter.displayForm, undefined, updateErrorContext(errorContext, {
+        path: ["displayForm"],
+    }));
     map.add(new Pair("using", id));
     if (isAttributeElementsByValue(attributeFilter.in)) {
         const ind = attributeFilter.in;
@@ -751,10 +840,12 @@ export function declarativePositiveAttributeFilterToYaml(entities, attributeFilt
     }
     return map;
 }
-export function declarativeNegativeAttributeFilterToYaml(entities, attributeFilter) {
+export function declarativeNegativeAttributeFilterToYaml(entities, attributeFilter, errorContext) {
     const map = new YAMLMap();
     map.add(new Pair("type", "attribute_filter"));
-    const id = getIdentifier(attributeFilter.displayForm);
+    const id = getIdentifier(attributeFilter.displayForm, undefined, updateErrorContext(errorContext, {
+        path: ["displayForm"],
+    }));
     map.add(new Pair("using", id));
     if (isAttributeElementsByValue(attributeFilter.notIn)) {
         const ind = attributeFilter.notIn;
@@ -766,18 +857,22 @@ export function declarativeNegativeAttributeFilterToYaml(entities, attributeFilt
     }
     return map;
 }
-export function declarativeArbitraryAttributeFilterToYaml(attributeFilter) {
+export function declarativeArbitraryAttributeFilterToYaml(attributeFilter, errorContext) {
     const map = new YAMLMap();
     map.add(new Pair("type", "text_filter"));
-    map.add(new Pair("using", getIdentifier(attributeFilter.label)));
+    map.add(new Pair("using", getIdentifier(attributeFilter.label, undefined, updateErrorContext(errorContext, {
+        path: ["label"],
+    }))));
     map.add(new Pair("condition", attributeFilter.negativeSelection ? "isNot" : "is"));
     map.add(new Pair("values", attributeFilter.values));
     return map;
 }
-export function declarativeMatchAttributeFilterToYaml(attributeFilter) {
+export function declarativeMatchAttributeFilterToYaml(attributeFilter, errorContext) {
     const map = new YAMLMap();
     map.add(new Pair("type", "text_filter"));
-    map.add(new Pair("using", getIdentifier(attributeFilter.label)));
+    map.add(new Pair("using", getIdentifier(attributeFilter.label, undefined, updateErrorContext(errorContext, {
+        path: ["label"],
+    }))));
     map.add(new Pair("condition", matchConditionToYaml(attributeFilter.operator, attributeFilter.negativeSelection)));
     map.add(new Pair("value", attributeFilter.literal));
     if (attributeFilter.caseSensitive !== undefined) {
@@ -821,14 +916,16 @@ function addConditionToYamlMap(conditionMap, condition) {
     }
     return hasTreatNullValues;
 }
-export function declarativeMeasureValueFilterToYaml(measureValueFilter) {
+export function declarativeMeasureValueFilterToYaml(measureValueFilter, errorContext) {
     const map = new YAMLMap();
     map.add(new Pair("type", "metric_value_filter"));
     if (isLocalIdRef(measureValueFilter.measure)) {
         map.add(new Pair("using", measureValueFilter.measure.localIdentifier));
     }
     else {
-        map.add(new Pair("using", getIdentifier(measureValueFilter.measure)));
+        map.add(new Pair("using", getIdentifier(measureValueFilter.measure, undefined, updateErrorContext(errorContext, {
+            path: ["measure"],
+        }))));
     }
     // Handle multiple conditions (new SDK model feature)
     if (measureValueFilter.conditions && measureValueFilter.conditions.length > 1) {
@@ -870,14 +967,16 @@ export function declarativeMeasureValueFilterToYaml(measureValueFilter) {
     }
     return map;
 }
-export function declarativeRankingFilterToYaml(rankingFilter) {
+export function declarativeRankingFilterToYaml(rankingFilter, errorContext) {
     const map = new YAMLMap();
     map.add(new Pair("type", "ranking_filter"));
     if (isLocalIdRef(rankingFilter.measure)) {
         map.add(new Pair("using", rankingFilter.measure.localIdentifier));
     }
     else {
-        map.add(new Pair("using", getIdentifier(rankingFilter.measure)));
+        map.add(new Pair("using", getIdentifier(rankingFilter.measure, undefined, updateErrorContext(errorContext, {
+            path: ["measure"],
+        }))));
     }
     if (rankingFilter.operator === "TOP") {
         map.add(new Pair("top", rankingFilter.value));
@@ -897,7 +996,7 @@ export function declarativeRankingFilterToYaml(rankingFilter) {
     }
     return map;
 }
-export function declarativeSortsToYaml(sorts) {
+export function declarativeSortsToYaml(sorts, _errorContext) {
     const sortsArray = [];
     sorts.forEach((sort) => {
         if (isAttributeSort(sort)) {
@@ -953,7 +1052,7 @@ export function declarativeMeasureSortToYaml(sort) {
     return map;
 }
 //visualisations
-function declarativeVisTableToYaml(doc, def, report) {
+function declarativeVisTableToYaml(doc, def, report, _context) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -972,7 +1071,7 @@ function declarativeVisTableToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisBarToYaml(doc, def, report) {
+function declarativeVisBarToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -991,7 +1090,7 @@ function declarativeVisBarToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisColumnToYaml(doc, def, report) {
+function declarativeVisColumnToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1010,7 +1109,7 @@ function declarativeVisColumnToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisLineToYaml(doc, def, report) {
+function declarativeVisLineToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1029,7 +1128,7 @@ function declarativeVisLineToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisAreaToYaml(doc, def, report) {
+function declarativeVisAreaToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1048,7 +1147,7 @@ function declarativeVisAreaToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisScatterToYaml(doc, def, report) {
+function declarativeVisScatterToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics1 = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     const metrics2 = report.derivedBuckets.find((item) => item.type === BucketsType.SecondaryMeasures);
@@ -1075,7 +1174,7 @@ function declarativeVisScatterToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisBubbleToYaml(doc, def, report) {
+function declarativeVisBubbleToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics1 = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     const metrics2 = report.derivedBuckets.find((item) => item.type === BucketsType.SecondaryMeasures);
@@ -1102,7 +1201,7 @@ function declarativeVisBubbleToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisPieToYaml(doc, def, report) {
+function declarativeVisPieToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1117,7 +1216,7 @@ function declarativeVisPieToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisDonutToYaml(doc, def, report) {
+function declarativeVisDonutToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1132,7 +1231,7 @@ function declarativeVisDonutToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisTreemapToYaml(doc, def, report) {
+function declarativeVisTreemapToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1151,7 +1250,7 @@ function declarativeVisTreemapToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisPyramidToYaml(doc, def, report) {
+function declarativeVisPyramidToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1166,7 +1265,7 @@ function declarativeVisPyramidToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisFunnelToYaml(doc, def, report) {
+function declarativeVisFunnelToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1181,7 +1280,7 @@ function declarativeVisFunnelToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisHeatmapToYaml(doc, def, report) {
+function declarativeVisHeatmapToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1200,7 +1299,7 @@ function declarativeVisHeatmapToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisBulletToYaml(doc, def, report) {
+function declarativeVisBulletToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics1 = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     const metrics2 = report.derivedBuckets.find((item) => item.type === BucketsType.SecondaryMeasures);
@@ -1225,7 +1324,7 @@ function declarativeVisBulletToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisWaterfallToYaml(doc, def, report) {
+function declarativeVisWaterfallToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1240,7 +1339,7 @@ function declarativeVisWaterfallToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisDependencyWheelToYaml(doc, def, report) {
+function declarativeVisDependencyWheelToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1263,7 +1362,7 @@ function declarativeVisDependencyWheelToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisSankeyToYaml(doc, def, report) {
+function declarativeVisSankeyToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     if (metrics && metrics.items.length > 0) {
@@ -1286,7 +1385,7 @@ function declarativeVisSankeyToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisHeadlineToYaml(doc, def, report) {
+function declarativeVisHeadlineToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics1 = report.derivedBuckets.find((item) => item.type === BucketsType.Measures);
     const metrics2 = report.derivedBuckets.find((item) => item.type === BucketsType.SecondaryMeasures);
@@ -1302,7 +1401,7 @@ function declarativeVisHeadlineToYaml(doc, def, report) {
         doc.add(config);
     }
 }
-function declarativeVisComboToYaml(doc, def, report) {
+function declarativeVisComboToYaml(doc, def, report, _errorContext) {
     //buckets
     const metrics1 = addAxisTypeToGroup(report.derivedBuckets.find((item) => item.type === BucketsType.Measures), "primary");
     const metrics2 = addAxisTypeToGroup(report.derivedBuckets.find((item) => item.type === BucketsType.SecondaryMeasures), "secondary");
@@ -1362,35 +1461,35 @@ function addGeoAreaBucketsToYaml(target, groups) {
         target.add(entryWithSpace("segment_by", groupToYaml(segment)));
     }
 }
-function declarativeVisGeoToYaml(doc, def, report, entities) {
+function declarativeVisGeoToYaml(doc, def, report, entities, errorContext) {
     //buckets
     addPushpinBucketsToYaml(doc, report.derivedBuckets);
     const config = geoChart.load(def.properties);
     if (config) {
         doc.add(config);
     }
-    appendLayers(doc, def, entities);
+    appendLayers(doc, def, entities, errorContext);
 }
-function declarativeVisGeoAreaToYaml(doc, def, report, entities) {
+function declarativeVisGeoAreaToYaml(doc, def, report, entities, errorContext) {
     //buckets
     addGeoAreaBucketsToYaml(doc, report.derivedBuckets);
     const config = geoAreaChart.load(def.properties);
     if (config) {
         doc.add(config);
     }
-    appendLayers(doc, def, entities);
+    appendLayers(doc, def, entities, errorContext);
 }
-function appendLayers(doc, def, entities) {
+function appendLayers(doc, def, entities, errorContext) {
     const layersDefinition = def.layers ?? [];
     if (layersDefinition.length === 0) {
         return;
     }
-    const layers = declarativeLayersToYaml(entities, layersDefinition);
+    const layers = declarativeLayersToYaml(entities, layersDefinition, updateErrorContext(errorContext, { path: ["layers"] }));
     if (layers.items.length > 0) {
         doc.add(entryWithSpace("layers", layers));
     }
 }
-function declarativeVisRepeaterToYaml(doc, def, report) {
+function declarativeVisRepeaterToYaml(doc, def, report, _errorContext) {
     const columns = report.derivedBuckets.find((item) => item.type === BucketsType.Columns);
     const columnsMapped = addChartTypeToGroup(columns, def.properties);
     if (columnsMapped && columnsMapped.items.length > 0) {
@@ -1410,7 +1509,7 @@ function declarativeVisRepeaterToYaml(doc, def, report) {
     }
 }
 //TOTALS
-export function declarativeTotalToYaml(total) {
+export function declarativeTotalToYaml(total, _errorContext) {
     const map = new YAMLMap();
     if (total.alias) {
         map.add(new Pair("title", total.alias));
@@ -1486,11 +1585,11 @@ function addChartTypeToGroup(group, config) {
         }),
     };
 }
-function declarativeLayersToYaml(entities, layersDefinition) {
+function declarativeLayersToYaml(entities, layersDefinition, errorContext) {
     const layers = new YAMLSeq();
-    layersDefinition.forEach((layer) => {
-        const { groups } = declarativeBucketsToYaml(entities, layer.buckets ?? []);
-        const layerKind = resolveLayerExportKind(layer.type);
+    layersDefinition.forEach((layer, li) => {
+        const { groups } = declarativeBucketsToYaml(entities, layer.buckets ?? [], updateErrorContext(errorContext, { path: [li.toString(), "buckets"] }));
+        const layerKind = resolveLayerExportKind(layer.type, updateErrorContext(errorContext, { path: [li.toString(), "type"] }));
         const layerMap = new YAMLMap();
         layerMap.add(new Pair("id", layer.id));
         if (layer.name) {
@@ -1499,22 +1598,22 @@ function declarativeLayersToYaml(entities, layersDefinition) {
         if (layer.type) {
             layerMap.add(new Pair("type", layer.type));
         }
-        appendLayerBucketsForKind(layerMap, groups, layerKind);
+        appendLayerBucketsForKind(layerMap, groups, layerKind, updateErrorContext(errorContext, { path: [li.toString()] }));
         addLayerConfig(layerMap, layerKind, layer.properties);
         layers.add(layerMap);
     });
     return layers;
 }
-function resolveLayerExportKind(rawLayerType) {
+function resolveLayerExportKind(rawLayerType, errorContext) {
     if (rawLayerType === "pushpin") {
         return "pushpin";
     }
     if (rawLayerType === "area") {
         return "area";
     }
-    throw newError(CoreErrorCode.LayerTypeNotSupported, [rawLayerType ?? "<missing>"]);
+    throw newError(CoreErrorCode.LayerTypeNotSupported, [rawLayerType ?? "<missing>"], errorContext);
 }
-function appendLayerBucketsForKind(layerMap, groups, kind) {
+function appendLayerBucketsForKind(layerMap, groups, kind, errorContext) {
     if (kind === "pushpin") {
         addPushpinBucketsToYaml(layerMap, groups);
         return;
@@ -1523,7 +1622,7 @@ function appendLayerBucketsForKind(layerMap, groups, kind) {
         addGeoAreaBucketsToYaml(layerMap, groups);
         return;
     }
-    throw newError(CoreErrorCode.LayerTypeNotSupported, [kind]);
+    throw newError(CoreErrorCode.LayerTypeNotSupported, [kind], errorContext);
 }
 function addLayerConfig(layerMap, layerKind, properties) {
     if (!properties) {