@meshmakers/octo-meshboard 3.4.810 → 3.4.880

package/fesm2022/meshmakers-octo-meshboard.mjs

@@ -3195,9 +3195,8 @@ class QueryExecutorService {
     /**
      * Best-effort per-series labels for resolution-aware fan-out (AB#4290): reads each source
      * entity's attribute matching `labelField` (canonical, case/underscore-insensitive so an archive
-     * column like `obis_code` maps to the CK attribute `obisCode`). Entities that fail to load or
-     * lack the attribute are simply omitted; the caller falls back to the rtId. Returns a
-     * `rtId → label` map.
+     * column name maps to its CK attribute). Entities that fail to load or lack the attribute are
+     * simply omitted; the caller falls back to the rtId. Returns a `rtId → label` map.
      */
     async fetchSeriesLabels(ckTypeId, rtIds, labelField) {
         const map = new Map();
@@ -3218,6 +3217,49 @@ class QueryExecutorService {
         }));
         return map;
     }
+    /** Cap on the source-entity population read for group-aggregation (AB#4714). A truncated read is
+     *  logged, never silent. */
+    static ENTITY_GROUP_FETCH_CAP = 5000;
+    /**
+     * Group-aggregation source resolution (AB#4714): fetches the source entities of `ckTypeId` in a
+     * single bulk read and buckets their rtIds by the value of `groupField` (canonical match — case
+     * and non-alphanumerics are ignored, so an archive column name maps to its CK attribute). Returns
+     * `groupValue → rtIds`. Optionally restricted to `restrictRtIds` (an entity-selector scope) —
+     * entities outside that set are dropped. Entities whose group attribute is missing/null are
+     * omitted (they cannot be attributed to a line). The population is bounded to
+     * {@link ENTITY_GROUP_FETCH_CAP}; a truncated read is logged (never silently capped).
+     */
+    async fetchEntityGroups(ckTypeId, groupField, restrictRtIds) {
+        const groups = new Map();
+        const canon = (s) => s.toLowerCase().replace(/[^a-z0-9]/g, '');
+        const wanted = canon(groupField);
+        const restrict = restrictRtIds && restrictRtIds.length > 0 ? new Set(restrictRtIds) : null;
+        const res = await firstValueFrom(this.entitiesGql.fetch({ variables: { ckTypeId, first: QueryExecutorService.ENTITY_GROUP_FETCH_CAP } }));
+        const connection = res.data?.runtime?.runtimeEntities;
+        const items = connection?.items ?? [];
+        const total = connection?.totalCount ?? items.length;
+        if (total > items.length) {
+            console.warn(`Group-aggregation: ${ckTypeId} has ${total} entities but only ${items.length} were read `
+                + `(cap ${QueryExecutorService.ENTITY_GROUP_FETCH_CAP}); some series may be incomplete.`);
+        }
+        for (const item of items) {
+            const rtId = item?.rtId != null ? String(item.rtId) : null;
+            if (!rtId || (restrict && !restrict.has(rtId)))
+                continue;
+            const attr = item?.attributes?.items?.find(a => !!a?.attributeName && canon(a.attributeName) === wanted);
+            if (attr?.value == null)
+                continue;
+            const groupValue = String(attr.value);
+            const bucket = groups.get(groupValue);
+            if (bucket) {
+                bucket.push(rtId);
+            }
+            else {
+                groups.set(groupValue, [rtId]);
+            }
+        }
+        return groups;
+    }
     buildStreamDataArg(args) {
         // Skip the entire `arg` field when the caller has nothing to override —
         // the persisted query then runs with its intrinsic from/to/limit and the
@@ -14811,10 +14853,12 @@ class LineChartWidgetComponent {
     }
     /**
      * Resolution-aware routing (AB#4290): resolve the best archive/rollup for the window + target
-     * point count, then downsample each source series against it. The transient downsampling groups
-     * by bin (merging source rtIds), so this fans out one call per source rtId to keep each register
-     * a separate line; each series' bins are reshaped onto the widget's configured value/series
-     * fields so the shared {@link processData} pipeline renders them unchanged.
+     * point count, then downsample the source series against it. Two fan-out shapes, both reshaped
+     * onto the widget's value/series fields so the shared {@link processData} pipeline renders them
+     * unchanged:
+     * - default: one call per source rtId → one line per register ({@link loadPerRtIdRows}).
+     * - `aggregateSeriesByGroup` (AB#4714): one call per `seriesGroupField` value with the whole
+     *   group's rtIds → one server-side-summed line per group ({@link loadGroupAggregatedRows}).
      */
     async loadResolutionAware(ds, from, to, sourceRtIds, fieldFilter) {
         const targetPoints = this.computeDownsampleLimit();
@@ -14834,7 +14878,6 @@ class LineChartWidgetComponent {
             requiredAggregation: aggregation,
             sourcePath,
             rtIds: sourceRtIds && sourceRtIds.length > 0 ? sourceRtIds : undefined,
-            obisFilter: ds.obisFilter || undefined,
             // Resolve calendar rollups in the board's zone so civil-day buckets match the
             // window (computed on the same zone by resolveCurrentTimeRange) — AB#4190.
             timeZone: this.stateService.resolveStreamDataTimeZone()
@@ -14856,31 +14899,52 @@ class LineChartWidgetComponent {
             qFrom = new Date(alignedFrom);
             qTo = new Date(alignedFrom + Math.max(1, resolution.points) * bucket);
         }
-        // One downsampling call per source rtId → each register stays its own series (the transient
-        // downsampling groups by bin, merging rtIds otherwise). With no source scope, a single merged
-        // series is produced (labeled by the series-group field name).
+        // Group-aggregation mode (AB#4714): one downsampling call PER GROUP, each with the whole
+        // group's rtIds, so the transient downsampling reduces over every member (per
+        // requiredAggregation) into one aggregate line. Default mode: one call per source rtId, keeping
+        // each source its own series. See loadGroupAggregatedRows / loadPerRtIdRows.
+        const downsample = (rtIds, label) => this.queryExecutor.downsampleByArchive({
+            archiveRtId: resolution.archiveRtId,
+            from: qFrom,
+            to: qTo,
+            limit: Math.max(1, resolution.points),
+            sourcePath,
+            aggregation: resolution.reducingFunction,
+            rtIds: rtIds && rtIds.length > 0 ? rtIds : undefined,
+            fieldFilter
+        }).then(seriesRows => seriesRows.map(r => this.reshapeResolutionRow(r, label)));
+        const rows = ds.aggregateSeriesByGroup && info.ckTypeId
+            ? await this.loadGroupAggregatedRows(info.ckTypeId, sourceRtIds, downsample)
+            : await this.loadPerRtIdRows(info.ckTypeId, sourceRtIds, downsample);
+        return { rows, signal: resolution, requestedPoints: targetPoints };
+    }
+    /**
+     * Group-aggregation fan-out (AB#4714): buckets the source entities by `seriesGroupField` and runs
+     * one downsampling call per group with the group's rtIds. The transient downsampling reduces over
+     * the group's members server-side, yielding one aggregate line per distinct group value. Falls
+     * back to a single merged series when no group can be resolved.
+     */
+    async loadGroupAggregatedRows(ckTypeId, sourceRtIds, downsample) {
+        const groups = await this.queryExecutor.fetchEntityGroups(ckTypeId, this.config.seriesGroupField, sourceRtIds);
+        if (groups.size === 0) {
+            // No group attribute resolved → a single merged line over the whole (optionally scoped) set.
+            return downsample(sourceRtIds, this.config.seriesGroupField);
+        }
+        const perGroup = await Promise.all(Array.from(groups.entries()).map(([groupValue, rtIds]) => downsample(rtIds, groupValue)));
+        return perGroup.flat();
+    }
+    /**
+     * Default resolution-aware fan-out (AB#4290): one downsampling call per source rtId so each
+     * register stays its own line, labeled from its `seriesGroupField` attribute. With no source
+     * scope a single merged series is produced (labeled by the series-group field name).
+     */
+    async loadPerRtIdRows(ckTypeId, sourceRtIds, downsample) {
         const seriesRtIds = sourceRtIds && sourceRtIds.length > 0 ? sourceRtIds : [undefined];
-        const labels = info.ckTypeId
-            ? await this.queryExecutor.fetchSeriesLabels(info.ckTypeId, sourceRtIds ?? [], this.config.seriesGroupField)
+        const labels = ckTypeId
+            ? await this.queryExecutor.fetchSeriesLabels(ckTypeId, sourceRtIds ?? [], this.config.seriesGroupField)
             : new Map();
-        const rows = [];
-        for (const rtId of seriesRtIds) {
-            const seriesRows = await this.queryExecutor.downsampleByArchive({
-                archiveRtId: resolution.archiveRtId,
-                from: qFrom,
-                to: qTo,
-                limit: Math.max(1, resolution.points),
-                sourcePath,
-                aggregation: resolution.reducingFunction,
-                rtIds: rtId ? [rtId] : undefined,
-                fieldFilter
-            });
-            const label = rtId ? (labels.get(rtId) ?? rtId) : this.config.seriesGroupField;
-            for (const r of seriesRows) {
-                rows.push(this.reshapeResolutionRow(r, label));
-            }
-        }
-        return { rows, signal: resolution, requestedPoints: targetPoints };
+        const perSeries = await Promise.all(seriesRtIds.map(rtId => downsample(rtId ? [rtId] : undefined, rtId ? (labels.get(rtId) ?? rtId) : this.config.seriesGroupField)));
+        return perSeries.flat();
     }
     /**
      * Reshapes one downsampling bin onto the widget's configured value + series-group fields so the
@@ -28154,6 +28218,10 @@ function buildDataSourceFromPersisted(data, config) {
         if (config['resolutionAware'] === true) {
             persisted.resolutionAware = true;
         }
+        // Group-aggregation (AB#4714) — only meaningful with resolutionAware.
+        if (config['aggregateSeriesByGroup'] === true) {
+            persisted.aggregateSeriesByGroup = true;
+        }
         const persistedAggregation = config['requiredAggregation'];
         if (persistedAggregation === 'AVG' || persistedAggregation === 'MIN' || persistedAggregation === 'MAX'
             || persistedAggregation === 'SUM' || persistedAggregation === 'COUNT') {
@@ -29238,6 +29306,9 @@ function registerDefaultWidgets(registry) {
             };
         },
         applyConfigResult: (widget, result) => {
+            // The config dialog does not surface aggregateSeriesByGroup; carry it over from the existing
+            // data source so a dialog edit never silently drops the seed-level flag.
+            const existing = widget.dataSource;
             const dataSource = {
                 type: 'persistentQuery',
                 queryRtId: result.queryRtId,
@@ -29246,7 +29317,8 @@ function registerDefaultWidgets(registry) {
                 ignoreTimeFilter: result.ignoreTimeFilter,
                 entitySelectorId: result.entitySelectorId,
                 resolutionAware: result.resolutionAware,
-                requiredAggregation: result.requiredAggregation
+                requiredAggregation: result.requiredAggregation,
+                aggregateSeriesByGroup: existing.aggregateSeriesByGroup
             };
             const filters = result.filters?.map(f => ({
                 attributePath: f.attributePath,
@@ -29314,6 +29386,9 @@ function registerDefaultWidgets(registry) {
                 ...(widget.dataSource.requiredAggregation && {
                     requiredAggregation: widget.dataSource.requiredAggregation
                 }),
+                ...(widget.dataSource.aggregateSeriesByGroup && {
+                    aggregateSeriesByGroup: true
+                }),
                 filters: widget.filters
             }
         }),