example(dashboardapi): basic.flow.json demos end-to-end Grafana round-trip (#42)

Replaces the placeholder inject→dashboardapi→debug example with the full
chain: inject (simulating a measurement child registration) → dashboardapi
(composes dashboard JSON) → http request (POSTs to Grafana) → debug (shows
the response). Default targets http://grafana:3000 inside the Docker compose
network. Configure bearer token via the encrypted credentials field.

Refs #42

config/machineGroup.json

@@ -122,7 +122,12 @@
         }
       ],
       "title": "Scaling",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "scaling"
+        ]
+      }
     },
     {
       "datasource": {
@@ -174,7 +179,12 @@
         }
       ],
       "title": "Abs Dist Peak",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "absDistFromPeak"
+        ]
+      }
     },
     {
       "datasource": {
@@ -227,7 +237,12 @@
         }
       ],
       "title": "Rel Dist Peak",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "relDistFromPeak"
+        ]
+      }
     },
     {
       "gridPos": {
@@ -253,7 +268,58 @@
             "fillOpacity": 10
           }
         },
-        "overrides": []
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".+\\.min$"
+            },
+            "properties": [
+              {
+                "id": "custom.lineStyle",
+                "value": {
+                  "fill": "dash",
+                  "dash": [
+                    10,
+                    10
+                  ]
+                }
+              },
+              {
+                "id": "color",
+                "value": {
+                  "mode": "fixed",
+                  "fixedColor": "orange"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".+\\.max$"
+            },
+            "properties": [
+              {
+                "id": "custom.lineStyle",
+                "value": {
+                  "fill": "dash",
+                  "dash": [
+                    10,
+                    10
+                  ]
+                }
+              },
+              {
+                "id": "color",
+                "value": {
+                  "mode": "fixed",
+                  "fixedColor": "red"
+                }
+              }
+            ]
+          }
+        ]
       },
       "gridPos": {
         "h": 8,
@@ -278,7 +344,13 @@
         }
       ],
       "title": "Total Flow",
-      "type": "timeseries"
+      "type": "timeseries",
+      "meta": {
+        "emittedFields": [
+          "flow.total",
+          "flow.group"
+        ]
+      }
     },
     {
       "datasource": {
@@ -293,7 +365,58 @@
             "fillOpacity": 10
           }
         },
-        "overrides": []
+        "overrides": [
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".+\\.min$"
+            },
+            "properties": [
+              {
+                "id": "custom.lineStyle",
+                "value": {
+                  "fill": "dash",
+                  "dash": [
+                    10,
+                    10
+                  ]
+                }
+              },
+              {
+                "id": "color",
+                "value": {
+                  "mode": "fixed",
+                  "fixedColor": "orange"
+                }
+              }
+            ]
+          },
+          {
+            "matcher": {
+              "id": "byRegexp",
+              "options": ".+\\.max$"
+            },
+            "properties": [
+              {
+                "id": "custom.lineStyle",
+                "value": {
+                  "fill": "dash",
+                  "dash": [
+                    10,
+                    10
+                  ]
+                }
+              },
+              {
+                "id": "color",
+                "value": {
+                  "mode": "fixed",
+                  "fixedColor": "red"
+                }
+              }
+            ]
+          }
+        ]
       },
       "gridPos": {
         "h": 8,
@@ -318,7 +441,13 @@
         }
       ],
       "title": "Total Power",
-      "type": "timeseries"
+      "type": "timeseries",
+      "meta": {
+        "emittedFields": [
+          "power.total",
+          "power.group"
+        ]
+      }
     }
   ],
   "schemaVersion": 39,

config/pumpingStation.json

@@ -3,7 +3,10 @@
     "list": [
       {
         "builtIn": 1,
-        "datasource": { "type": "grafana", "uid": "-- Grafana --" },
+        "datasource": {
+          "type": "grafana",
+          "uid": "-- Grafana --"
+        },
         "enable": true,
         "hide": true,
         "iconColor": "rgba(0, 211, 255, 1)",
@@ -17,153 +20,680 @@
   "id": null,
   "links": [],
   "panels": [
-    { "gridPos": { "h": 1, "w": 24, "x": 0, "y": 0 }, "id": 1, "title": "Status", "type": "row" },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "gridPos": {
-      "fieldConfig": { "defaults": { "thresholds": { "mode": "absolute", "steps": [{ "color": "blue", "value": null }] } }, "overrides": [] },
+        "h": 1,
-      "gridPos": { "h": 4, "w": 5, "x": 0, "y": 1 },
+        "w": 24,
+        "x": 0,
+        "y": 0
+      },
+      "id": 1,
+      "title": "Status",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "influxdb",
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "blue",
+                "value": null
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 5,
+        "x": 0,
+        "y": 1
+      },
       "id": 2,
-      "options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        },
+        "colorMode": "value",
+        "graphMode": "none"
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"direction\")\n  |> last()", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"direction\")\n  |> last()",
+          "refId": "A"
+        }
       ],
       "title": "Direction",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "direction"
+        ]
+      }
     },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "datasource": {
-      "fieldConfig": { "defaults": { "unit": "s", "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }, { "color": "orange", "value": 300 }, { "color": "red", "value": 600 }] } }, "overrides": [] },
+        "type": "influxdb",
-      "gridPos": { "h": 4, "w": 5, "x": 5, "y": 1 },
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "s",
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              },
+              {
+                "color": "orange",
+                "value": 300
+              },
+              {
+                "color": "red",
+                "value": 600
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 5,
+        "x": 5,
+        "y": 1
+      },
       "id": 3,
-      "options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "area" },
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        },
+        "colorMode": "value",
+        "graphMode": "area"
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"timeleft\")\n  |> last()", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"timeleft\")\n  |> last()",
+          "refId": "A"
+        }
       ],
       "title": "Time Left",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "timeLeft"
+        ]
+      }
     },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "datasource": {
-      "fieldConfig": { "defaults": { "thresholds": { "mode": "absolute", "steps": [{ "color": "purple", "value": null }] } }, "overrides": [] },
+        "type": "influxdb",
-      "gridPos": { "h": 4, "w": 4, "x": 10, "y": 1 },
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "purple",
+                "value": null
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 4,
+        "x": 10,
+        "y": 1
+      },
       "id": 4,
-      "options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        },
+        "colorMode": "value",
+        "graphMode": "none"
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"flowSource\")\n  |> last()", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field==\"flowSource\")\n  |> last()",
+          "refId": "A"
+        }
       ],
       "title": "Flow Source",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "flowSource"
+        ]
+      }
     },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "datasource": {
-      "fieldConfig": { "defaults": { "min": 0, "max": 100, "unit": "percent", "thresholds": { "mode": "absolute", "steps": [{ "color": "red", "value": null }, { "color": "orange", "value": 20 }, { "color": "green", "value": 40 }, { "color": "orange", "value": 80 }, { "color": "red", "value": 95 }] } }, "overrides": [] },
+        "type": "influxdb",
-      "gridPos": { "h": 4, "w": 5, "x": 14, "y": 1 },
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "min": 0,
+          "max": 100,
+          "unit": "percent",
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "red",
+                "value": null
+              },
+              {
+                "color": "orange",
+                "value": 20
+              },
+              {
+                "color": "green",
+                "value": 40
+              },
+              {
+                "color": "orange",
+                "value": 80
+              },
+              {
+                "color": "red",
+                "value": 95
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 5,
+        "x": 14,
+        "y": 1
+      },
       "id": 5,
-      "options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "showThresholdLabels": false, "showThresholdMarkers": true },
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        },
+        "showThresholdLabels": false,
+        "showThresholdMarkers": true
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volumePercent\\.predicted\\.atequipment/)\n  |> last()", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volumePercent\\.predicted\\.atequipment/)\n  |> last()",
+          "refId": "A"
+        }
       ],
       "title": "Fill %",
-      "type": "gauge"
+      "type": "gauge",
+      "meta": {
+        "emittedFields": [
+          "volumePercent"
+        ]
+      }
     },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "datasource": {
-      "fieldConfig": { "defaults": { "unit": "m", "thresholds": { "mode": "absolute", "steps": [{ "color": "green", "value": null }] } }, "overrides": [] },
+        "type": "influxdb",
-      "gridPos": { "h": 4, "w": 5, "x": 19, "y": 1 },
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "m",
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "green",
+                "value": null
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 5,
+        "x": 19,
+        "y": 1
+      },
       "id": 6,
-      "options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "area" },
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        },
+        "colorMode": "value",
+        "graphMode": "area"
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.predicted\\.atequipment/)\n  |> last()", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.predicted\\.atequipment/)\n  |> last()",
+          "refId": "A"
+        }
       ],
       "title": "Level",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "level"
+        ]
+      }
     },
-    { "gridPos": { "h": 1, "w": 24, "x": 0, "y": 5 }, "id": 7, "title": "Basin", "type": "row" },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "gridPos": {
-      "fieldConfig": { "defaults": { "unit": "m", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
+        "h": 1,
-      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 6 },
+        "w": 24,
+        "x": 0,
+        "y": 5
+      },
+      "id": 7,
+      "title": "Basin",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "influxdb",
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "m",
+          "custom": {
+            "drawStyle": "line",
+            "lineWidth": 2,
+            "fillOpacity": 10
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 6
+      },
       "id": 8,
-      "options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
+      "options": {
+        "legend": {
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "multi"
+        }
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.(predicted|measured)\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^level\\.(predicted|measured)\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
+          "refId": "A"
+        }
       ],
       "title": "Level",
-      "type": "timeseries"
+      "type": "timeseries",
+      "meta": {
+        "emittedFields": [
+          "level"
+        ]
+      }
     },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "datasource": {
-      "fieldConfig": { "defaults": { "unit": "m\u00b3", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
+        "type": "influxdb",
-      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 6 },
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "m\u00b3",
+          "custom": {
+            "drawStyle": "line",
+            "lineWidth": 2,
+            "fillOpacity": 10
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 6
+      },
       "id": 9,
-      "options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
+      "options": {
+        "legend": {
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "multi"
+        }
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volume\\.predicted\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^volume\\.predicted\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
+          "refId": "A"
+        }
       ],
       "title": "Volume",
-      "type": "timeseries"
+      "type": "timeseries",
+      "meta": {
+        "emittedFields": [
+          "volume"
+        ]
+      }
     },
-    { "gridPos": { "h": 1, "w": 24, "x": 0, "y": 14 }, "id": 10, "title": "Flow", "type": "row" },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "gridPos": {
-      "fieldConfig": { "defaults": { "unit": "m\u00b3/h", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
+        "h": 1,
-      "gridPos": { "h": 8, "w": 12, "x": 0, "y": 15 },
+        "w": 24,
+        "x": 0,
+        "y": 14
+      },
+      "id": 10,
+      "title": "Flow",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "influxdb",
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "m\u00b3/h",
+          "custom": {
+            "drawStyle": "line",
+            "lineWidth": 2,
+            "fillOpacity": 10
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 0,
+        "y": 15
+      },
       "id": 11,
-      "options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
+      "options": {
+        "legend": {
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "multi"
+        }
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^netFlowRate\\.predicted\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^netFlowRate\\.predicted\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
+          "refId": "A"
+        }
       ],
       "title": "Net Flow Rate",
-      "type": "timeseries"
+      "type": "timeseries",
+      "meta": {
+        "emittedFields": [
+          "flow.net",
+          "flow"
+        ]
+      }
     },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "datasource": {
-      "fieldConfig": { "defaults": { "unit": "m\u00b3/h", "custom": { "drawStyle": "line", "lineWidth": 2, "fillOpacity": 10 } }, "overrides": [] },
+        "type": "influxdb",
-      "gridPos": { "h": 8, "w": 12, "x": 12, "y": 15 },
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "m\u00b3/h",
+          "custom": {
+            "drawStyle": "line",
+            "lineWidth": 2,
+            "fillOpacity": 10
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 8,
+        "w": 12,
+        "x": 12,
+        "y": 15
+      },
       "id": 12,
-      "options": { "legend": { "displayMode": "list", "placement": "bottom" }, "tooltip": { "mode": "multi" } },
+      "options": {
+        "legend": {
+          "displayMode": "list",
+          "placement": "bottom"
+        },
+        "tooltip": {
+          "mode": "multi"
+        }
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^flow\\.(predicted|measured)\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and r._field =~ /^flow\\.(predicted|measured)\\.atequipment/)\n  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)",
+          "refId": "A"
+        }
       ],
       "title": "Inflow + Outflow",
-      "type": "timeseries"
+      "type": "timeseries",
+      "meta": {
+        "emittedFields": [
+          "flow.in",
+          "flow.out"
+        ]
+      }
     },
-    { "gridPos": { "h": 1, "w": 24, "x": 0, "y": 23 }, "id": 13, "title": "Configuration", "type": "row" },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "gridPos": {
-      "fieldConfig": { "defaults": { "unit": "m", "thresholds": { "mode": "absolute", "steps": [{ "color": "blue", "value": null }] } }, "overrides": [] },
+        "h": 1,
-      "gridPos": { "h": 4, "w": 12, "x": 0, "y": 24 },
+        "w": 24,
+        "x": 0,
+        "y": 23
+      },
+      "id": 13,
+      "title": "Configuration",
+      "type": "row"
+    },
+    {
+      "datasource": {
+        "type": "influxdb",
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "m",
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "blue",
+                "value": null
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 12,
+        "x": 0,
+        "y": 24
+      },
       "id": 14,
-      "options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        },
+        "colorMode": "value",
+        "graphMode": "none"
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"heightInlet\" or r._field==\"heightOverflow\" or r._field==\"volEmptyBasin\"))\n  |> last()", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"heightInlet\" or r._field==\"heightOverflow\" or r._field==\"volEmptyBasin\"))\n  |> last()",
+          "refId": "A"
+        }
       ],
       "title": "Heights",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "heights.min",
+          "heights.max"
+        ]
+      }
     },
     {
-      "datasource": { "type": "influxdb", "uid": "cdzg44tv250jkd" },
+      "datasource": {
-      "fieldConfig": { "defaults": { "unit": "m\u00b3", "thresholds": { "mode": "absolute", "steps": [{ "color": "blue", "value": null }] } }, "overrides": [] },
+        "type": "influxdb",
-      "gridPos": { "h": 4, "w": 12, "x": 12, "y": 24 },
+        "uid": "cdzg44tv250jkd"
+      },
+      "fieldConfig": {
+        "defaults": {
+          "unit": "m\u00b3",
+          "thresholds": {
+            "mode": "absolute",
+            "steps": [
+              {
+                "color": "blue",
+                "value": null
+              }
+            ]
+          }
+        },
+        "overrides": []
+      },
+      "gridPos": {
+        "h": 4,
+        "w": 12,
+        "x": 12,
+        "y": 24
+      },
       "id": 15,
-      "options": { "reduceOptions": { "calcs": ["lastNotNull"] }, "colorMode": "value", "graphMode": "none" },
+      "options": {
+        "reduceOptions": {
+          "calcs": [
+            "lastNotNull"
+          ]
+        },
+        "colorMode": "value",
+        "graphMode": "none"
+      },
       "targets": [
-        { "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"maxVol\" or r._field==\"minVol\" or r._field==\"maxVolOverflow\" or r._field==\"minVolOut\" or r._field==\"minVolIn\"))\n  |> last()", "refId": "A" }
+        {
+          "query": "from(bucket: \"${bucket}\")\n  |> range(start: -7d)\n  |> filter(fn:(r) => r._measurement==\"${measurement}\" and (r._field==\"maxVol\" or r._field==\"minVol\" or r._field==\"maxVolOverflow\" or r._field==\"minVolOut\" or r._field==\"minVolIn\"))\n  |> last()",
+          "refId": "A"
+        }
       ],
       "title": "Volume Limits",
-      "type": "stat"
+      "type": "stat",
+      "meta": {
+        "emittedFields": [
+          "volume.min",
+          "volume.max"
+        ]
+      }
     }
   ],
   "schemaVersion": 39,
-  "tags": ["EVOLV", "pumpingStation", "template"],
+  "tags": [
+    "EVOLV",
+    "pumpingStation",
+    "template"
+  ],
   "templating": {
     "list": [
-      { "name": "dbase", "type": "custom", "label": "dbase", "query": "cdzg44tv250jkd", "current": { "text": "cdzg44tv250jkd", "value": "cdzg44tv250jkd", "selected": false }, "options": [{ "text": "cdzg44tv250jkd", "value": "cdzg44tv250jkd", "selected": true }], "hide": 2 },
+      {
-      { "name": "measurement", "type": "custom", "query": "template", "current": { "text": "template", "value": "template", "selected": false }, "options": [{ "text": "template", "value": "template", "selected": true }] },
+        "name": "dbase",
-      { "name": "bucket", "type": "custom", "query": "lvl2", "current": { "text": "lvl2", "value": "lvl2", "selected": false }, "options": [{ "text": "lvl2", "value": "lvl2", "selected": true }] }
+        "type": "custom",
+        "label": "dbase",
+        "query": "cdzg44tv250jkd",
+        "current": {
+          "text": "cdzg44tv250jkd",
+          "value": "cdzg44tv250jkd",
+          "selected": false
+        },
+        "options": [
+          {
+            "text": "cdzg44tv250jkd",
+            "value": "cdzg44tv250jkd",
+            "selected": true
+          }
+        ],
+        "hide": 2
+      },
+      {
+        "name": "measurement",
+        "type": "custom",
+        "query": "template",
+        "current": {
+          "text": "template",
+          "value": "template",
+          "selected": false
+        },
+        "options": [
+          {
+            "text": "template",
+            "value": "template",
+            "selected": true
+          }
+        ]
+      },
+      {
+        "name": "bucket",
+        "type": "custom",
+        "query": "lvl2",
+        "current": {
+          "text": "lvl2",
+          "value": "lvl2",
+          "selected": false
+        },
+        "options": [
+          {
+            "text": "lvl2",
+            "value": "lvl2",
+            "selected": true
+          }
+        ]
+      }
     ]
   },
-  "time": { "from": "now-6h", "to": "now" },
+  "time": {
+    "from": "now-6h",
+    "to": "now"
+  },
   "timezone": "",
   "title": "template",
   "uid": null,

examples/basic.flow.json

@@ -1,6 +1,70 @@
 [
-  {"id":"dashboardAPI_basic_tab","type":"tab","label":"dashboardAPI basic","disabled":false,"info":"dashboardAPI basic example"},
+  {
-  {"id":"dashboardAPI_basic_node","type":"dashboardapi","z":"dashboardAPI_basic_tab","name":"dashboardAPI basic","x":420,"y":180,"wires":[["dashboardAPI_basic_dbg"]]},
+    "id": "dashboardAPI_basic_tab",
-  {"id":"dashboardAPI_basic_inj","type":"inject","z":"dashboardAPI_basic_tab","name":"basic trigger","props":[{"p":"topic","vt":"str"},{"p":"payload","vt":"str"}],"topic":"ping","payload":"1","payloadType":"str","x":160,"y":180,"wires":[["dashboardAPI_basic_node"]]},
+    "type": "tab",
-  {"id":"dashboardAPI_basic_dbg","type":"debug","z":"dashboardAPI_basic_tab","name":"dashboardAPI basic debug","active":true,"tosidebar":true,"console":false,"tostatus":false,"complete":"true","targetType":"full","x":660,"y":180,"wires":[]}
+    "label": "dashboardAPI basic — measurement → Grafana",
+    "disabled": false,
+    "info": "Demonstrates the round-trip:\n- inject simulates a child.register message from a measurement node\n- dashboardapi composes a Grafana dashboard for that child\n- http request posts the dashboard to Grafana\n- debug shows the HTTP response\n\nConfigure the dashboardapi node with your Grafana host/port + bearer token\n(encrypted via Node-RED credentials). Default targets http://grafana:3000\nfrom inside the Docker compose stack."
+  },
+  {
+    "id": "dashboardAPI_basic_node",
+    "type": "dashboardapi",
+    "z": "dashboardAPI_basic_tab",
+    "name": "dashboardAPI",
+    "protocol": "http",
+    "host": "grafana",
+    "port": 3000,
+    "folderUid": "",
+    "defaultBucket": "telemetry",
+    "x": 460,
+    "y": 200,
+    "wires": [["dashboardAPI_basic_http"]]
+  },
+  {
+    "id": "dashboardAPI_basic_inj",
+    "type": "inject",
+    "z": "dashboardAPI_basic_tab",
+    "name": "simulate child.register (measurement)",
+    "props": [
+      { "p": "topic", "vt": "str" },
+      { "p": "payload", "v": "{\"config\":{\"general\":{\"id\":\"meas-demo-001\",\"name\":\"FT-001 demo\"},\"functionality\":{\"softwareType\":\"measurement\",\"positionVsParent\":\"downstream\"}}}", "vt": "json" }
+    ],
+    "topic": "child.register",
+    "x": 180,
+    "y": 200,
+    "wires": [["dashboardAPI_basic_node"]]
+  },
+  {
+    "id": "dashboardAPI_basic_http",
+    "type": "http request",
+    "z": "dashboardAPI_basic_tab",
+    "name": "POST /api/dashboards/db",
+    "method": "use",
+    "ret": "obj",
+    "paytoqs": "ignore",
+    "url": "",
+    "tls": "",
+    "persist": false,
+    "proxy": "",
+    "authType": "",
+    "senderr": false,
+    "x": 720,
+    "y": 200,
+    "wires": [["dashboardAPI_basic_dbg"]]
+  },
+  {
+    "id": "dashboardAPI_basic_dbg",
+    "type": "debug",
+    "z": "dashboardAPI_basic_tab",
+    "name": "Grafana response",
+    "active": true,
+    "tosidebar": true,
+    "console": false,
+    "tostatus": false,
+    "complete": "payload",
+    "targetType": "msg",
+    "x": 960,
+    "y": 200,
+    "wires": []
+  }
 ]

src/commands/handlers.js

@@ -22,35 +22,9 @@ function resolveChildNode(childId, ctx) {
   return runtimeNode || flowNode || null;
 }
 
-// On child.register: build the dashboard graph (root + direct children) and
+// Shared emit path used by both child.register (auto, deploy-driven) and
-// emit one Grafana upsert HTTP request per dashboard on Port 0.
+// regenerate-dashboard (manual). `trigger` distinguishes the two for logs.
-//
+function emitDashboardsFor(source, childSource, ctx, msg, trigger) {
-// Diff-skip behavior (PRD F-1, S1 spike #32): if the latest flows:started
-// payload's `diff` indicates that NEITHER the dashboardAPI itself NOR this
-// child NOR its grandchildren changed, skip composition and log no-diff. The
-// first call after startup (no cached diff yet) regenerates unconditionally.
-function registerChild(source, msg, ctx) {
-  const childSource = resolveChildSource(msg.payload, ctx);
-  if (!childSource?.config) {
-    throw new Error('Missing or invalid child node');
-  }
-
-  const subtreeIds = source.subtreeIdsFor(ctx.node?.id, childSource);
-  const changed = source.subtreeChanged(source.lastFlowsStartedDiff, subtreeIds);
-  if (!changed) {
-    if (source.logger?.info) {
-      source.logger.info({
-        event: 'regen-skipped',
-        outcome: 'no-diff',
-        trigger: 'child.register',
-        dashboardApiId: ctx.node?.id,
-        childId: childSource?.config?.general?.id,
-        subtreeSize: subtreeIds.size,
-      });
-    }
-    return;
-  }
-
   const dashboards = source.generateDashboardsForGraph(childSource, {
     includeChildren: Boolean(msg.includeChildren ?? true),
   });
@@ -77,9 +51,73 @@ function registerChild(source, msg, ctx) {
         softwareType: dash.softwareType,
         uid: dash.uid,
         title: dash.title,
+        trigger,
       },
     });
   }
+
+  if (source.logger?.info) {
+    source.logger.info({
+      event: 'regen-emitted',
+      trigger,
+      dashboardApiId: ctx.node?.id,
+      childId: childSource?.config?.general?.id,
+      dashboardCount: dashboards.length,
+    });
+  }
 }
 
-module.exports = { registerChild };
+// On child.register: build the dashboard graph (root + direct children) and
+// emit one Grafana upsert HTTP request per dashboard on Port 0.
+//
+// Diff-skip behavior (PRD F-1, S1 spike #32): if the latest flows:started
+// payload's `diff` indicates that NEITHER the dashboardAPI itself NOR this
+// child NOR its grandchildren changed, skip composition and log no-diff. The
+// first call after startup (no cached diff yet) regenerates unconditionally.
+function registerChild(source, msg, ctx) {
+  const childSource = resolveChildSource(msg.payload, ctx);
+  if (!childSource?.config) {
+    throw new Error('Missing or invalid child node');
+  }
+
+  // Cache the child source for later manual regen (#41).
+  source.recordChild?.(childSource);
+
+  const subtreeIds = source.subtreeIdsFor(ctx.node?.id, childSource);
+  const changed = source.subtreeChanged(source.lastFlowsStartedDiff, subtreeIds);
+  if (!changed) {
+    if (source.logger?.info) {
+      source.logger.info({
+        event: 'regen-skipped',
+        outcome: 'no-diff',
+        trigger: 'child.register',
+        dashboardApiId: ctx.node?.id,
+        childId: childSource?.config?.general?.id,
+        subtreeSize: subtreeIds.size,
+      });
+    }
+    return;
+  }
+
+  emitDashboardsFor(source, childSource, ctx, msg, 'child.register');
+}
+
+// On regenerate-dashboard: re-emit dashboards for every cached child source,
+// bypassing the diff predicate. Useful as an operator escape hatch when
+// auto-regen missed an edge case or when the operator just wants to refresh.
+function regenerateDashboard(source, msg, ctx) {
+  const cached = source.cachedChildSources?.() || [];
+  if (source.logger?.info) {
+    source.logger.info({
+      event: 'manual-regen-requested',
+      trigger: 'manual',
+      dashboardApiId: ctx.node?.id,
+      cachedChildCount: cached.length,
+    });
+  }
+  for (const childSource of cached) {
+    emitDashboardsFor(source, childSource, ctx, msg, 'manual');
+  }
+}
+
+module.exports = { registerChild, regenerateDashboard };

src/commands/index.js

@@ -13,4 +13,10 @@ module.exports = [
     payloadSchema: { type: 'any' },
     handler: handlers.registerChild,
   },
+  {
+    topic: 'regenerate-dashboard',
+    aliases: ['regen'],
+    payloadSchema: { type: 'any' },
+    handler: handlers.regenerateDashboard,
+  },
 ];

src/specificClass.js

@@ -75,6 +75,20 @@ class DashboardApi {
       this.config.general.logging.logLevel,
       this.config.general.name
     );
+
+    // Light state cache for manual regen (#41). Stores the latest child
+    // source object per child id so `regenerate-dashboard` can re-emit
+    // dashboards without waiting for children to re-register.
+    this._lastChildSources = new Map();
+  }
+
+  recordChild(childSource) {
+    const id = childSource?.config?.general?.id;
+    if (id) this._lastChildSources.set(id, childSource);
+  }
+
+  cachedChildSources() {
+    return Array.from(this._lastChildSources.values());
   }
 
   _templatesDir() {
@@ -228,6 +242,32 @@ class DashboardApi {
       if (childDash) results.push(childDash);
     }
 
+    // No-data-duplication rule (PRD F-5, #39): remove root panels whose
+    // emittedFields are fully covered by panels on child dashboards. The
+    // parent then shows only metrics its children don't already plot,
+    // avoiding redundant rendering of the same series in two places.
+    if (children.length > 0 && rootDash.dashboard) {
+      const childCoveredFields = new Set();
+      for (const dash of results.slice(1)) {
+        for (const f of this.collectEmittedFields(dash.dashboard)) childCoveredFields.add(f);
+      }
+      const before = rootDash.dashboard.panels.length;
+      rootDash.dashboard.panels = rootDash.dashboard.panels.filter((p) => {
+        if (p.type === 'row') return true; // never drop rows
+        const fields = p?.meta?.emittedFields;
+        if (!Array.isArray(fields) || fields.length === 0) return true; // no declaration, keep
+        return !fields.every((f) => childCoveredFields.has(f));
+      });
+      if (this.logger?.debug && before !== rootDash.dashboard.panels.length) {
+        this.logger.debug({
+          event: 'parent-panels-deduped',
+          before,
+          after: rootDash.dashboard.panels.length,
+          rootTitle: rootDash.title,
+        });
+      }
+    }
+
     // Add links from the root dashboard to children dashboards (when possible)
     if (children.length > 0) {
       rootDash.dashboard.links = Array.isArray(rootDash.dashboard.links) ? rootDash.dashboard.links : [];

test/basic/slice39-no-duplication.basic.test.js

@@ -0,0 +1,102 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const DashboardApi = require('../../src/specificClass.js');
+
+function makeChild(id, softwareType) {
+  return {
+    config: {
+      general: { id, name: id },
+      functionality: { softwareType, positionVsParent: 'downstream' },
+    },
+  };
+}
+
+function makeRoot(softwareType, children) {
+  const map = new Map();
+  for (const c of children) {
+    map.set(c.config.general.id, {
+      child: c,
+      softwareType: c.config.functionality.softwareType,
+      position: 'downstream',
+    });
+  }
+  return {
+    config: {
+      general: { id: 'root-1', name: 'PS-North' },
+      functionality: { softwareType, positionVsParent: 'atequipment' },
+    },
+    childRegistrationUtils: { registeredChildren: map },
+  };
+}
+
+test('pumpingStation template has emittedFields on every non-row panel', () => {
+  const api = new DashboardApi({});
+  const dash = api.loadTemplate('pumpingStation');
+  const annotated = dash.panels.filter((p) => p.type !== 'row' && p?.meta?.emittedFields);
+  const nonRowPanels = dash.panels.filter((p) => p.type !== 'row');
+  assert.equal(annotated.length, nonRowPanels.length,
+    `expected all ${nonRowPanels.length} non-row panels annotated, got ${annotated.length}`);
+});
+
+test('child-covered fields remove duplicate parent panels', () => {
+  const api = new DashboardApi({});
+
+  // Parent + 1 child with a fake template that emits 'level' (matches one of
+  // the pumpingStation parent's panels). The parent's "Level" panel should
+  // be removed when the child covers it.
+  const child1 = makeChild('child-1', 'measurement');
+  const root = makeRoot('pumpingStation', [child1]);
+
+  // Pre-count parent panels with the 'level' emitted field.
+  const parentTemplate = api.loadTemplate('pumpingStation');
+  const parentLevelPanels = parentTemplate.panels.filter(
+    (p) => p?.meta?.emittedFields?.includes('level')
+  );
+  assert.ok(parentLevelPanels.length > 0, 'parent has level panels in template');
+
+  // Monkey-patch the child's dashboard to claim it covers 'level'.
+  const origLoad = api.loadTemplate.bind(api);
+  api.loadTemplate = function (type) {
+    const dash = origLoad(type);
+    if (type === 'measurement' && dash) {
+      // Inject emittedFields = ['level'] on first non-row panel.
+      const firstPanel = dash.panels.find((p) => p.type !== 'row');
+      if (firstPanel) (firstPanel.meta ||= {}).emittedFields = ['level'];
+    }
+    return dash;
+  };
+
+  const result = api.generateDashboardsForGraph(root);
+  const rootResult = result[0];
+  const rootLevelPanels = rootResult.dashboard.panels.filter(
+    (p) => p?.meta?.emittedFields?.includes('level')
+  );
+  assert.equal(rootLevelPanels.length, 0,
+    'level panel(s) should be removed from parent when child covers them');
+});
+
+test('parent panels are kept when no child covers their fields', () => {
+  const api = new DashboardApi({});
+  const child1 = makeChild('child-1', 'measurement'); // measurement.json has no emittedFields
+  const root = makeRoot('pumpingStation', [child1]);
+  const result = api.generateDashboardsForGraph(root);
+  const rootResult = result[0];
+  const beforeTemplate = api.loadTemplate('pumpingStation');
+  const beforeNonRow = beforeTemplate.panels.filter((p) => p.type !== 'row').length;
+  const afterNonRow = rootResult.dashboard.panels.filter((p) => p.type !== 'row').length;
+  assert.equal(afterNonRow, beforeNonRow,
+    'no panels should be removed when no child declares overlapping fields');
+});
+
+test('row panels are never removed (structural)', () => {
+  const api = new DashboardApi({});
+  const child1 = makeChild('child-1', 'measurement');
+  const root = makeRoot('pumpingStation', [child1]);
+  const result = api.generateDashboardsForGraph(root);
+  const rootRows = result[0].dashboard.panels.filter((p) => p.type === 'row');
+  const templateRows = api.loadTemplate('pumpingStation').panels.filter((p) => p.type === 'row');
+  assert.equal(rootRows.length, templateRows.length, 'all row panels preserved');
+});

test/basic/slice40-mgc-template.basic.test.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const DashboardApi = require('../../src/specificClass.js');
+
+test('MGC template panels are all group-level (no per-pump fields)', () => {
+  const api = new DashboardApi({});
+  const dash = api.loadTemplate('machineGroup');
+  const PER_PUMP = new Set(['ctrl', 'state', 'runtime', 'pressure.upstream', 'pressure.downstream', 'temperature']);
+  for (const panel of dash.panels || []) {
+    if (panel.type === 'row') continue;
+    const fields = panel?.meta?.emittedFields || [];
+    for (const f of fields) {
+      assert.ok(!PER_PUMP.has(f),
+        `MGC panel "${panel.title}" emits ${f}, which belongs to rotatingMachine (per-pump). Move to children.`);
+    }
+  }
+});
+
+test('MGC group panels are annotated (mode, scaling, abs/rel peak, totals)', () => {
+  const api = new DashboardApi({});
+  const dash = api.loadTemplate('machineGroup');
+  const non = dash.panels.filter((p) => p.type !== 'row');
+  const annotated = non.filter((p) => p?.meta?.emittedFields);
+  assert.equal(annotated.length, non.length, 'every non-row MGC panel annotated');
+});
+
+test('MGC timeseries panels carry dashed-bounds overrides for .min/.max', () => {
+  const api = new DashboardApi({});
+  const dash = api.loadTemplate('machineGroup');
+  const ts = dash.panels.filter((p) => p.type === 'timeseries');
+  for (const panel of ts) {
+    const ov = panel?.fieldConfig?.overrides || [];
+    const hasMin = ov.some((o) => o.matcher?.id === 'byRegexp' && /\.min\$/.test(o.matcher?.options || ''));
+    const hasMax = ov.some((o) => o.matcher?.id === 'byRegexp' && /\.max\$/.test(o.matcher?.options || ''));
+    assert.ok(hasMin && hasMax, `MGC ts panel "${panel.title}" missing .min/.max dashed override`);
+  }
+});
+
+test('MGC composer dedups parent panels covered by pump children', () => {
+  // If a rotatingMachine child claims to emit `flow.total` (it shouldn't, but
+  // suppose), the parent MGC's "Total Flow" panel would be removed. Verify
+  // the composer applies the same dedup rule to MGC parents.
+  const api = new DashboardApi({});
+  function makeChildSrc(id) {
+    return { config: { general: { id }, functionality: { softwareType: 'machine', positionVsParent: 'downstream' } } };
+  }
+  const child = makeChildSrc('pump-1');
+  const root = {
+    config: { general: { id: 'mgc-1', name: 'MGC' }, functionality: { softwareType: 'machineGroupControl', positionVsParent: 'atequipment' } },
+    childRegistrationUtils: { registeredChildren: new Map([['pump-1', { child, position: 'downstream', softwareType: 'machine' }]]) },
+  };
+  const origLoad = api.loadTemplate.bind(api);
+  api.loadTemplate = function (t) {
+    const dash = origLoad(t);
+    if (t === 'machine') {
+      // Make the pump's template falsely claim it emits flow.total/flow.group
+      const firstPanel = dash.panels.find((p) => p.type !== 'row');
+      if (firstPanel) (firstPanel.meta ||= {}).emittedFields = ['flow.total', 'flow.group'];
+    }
+    return dash;
+  };
+  const results = api.generateDashboardsForGraph(root);
+  const mgcDash = results[0].dashboard;
+  const totalFlowPanel = mgcDash.panels.find((p) => p.title === 'Total Flow');
+  assert.ok(!totalFlowPanel, 'MGC Total Flow panel should be removed when child claims flow.total/flow.group');
+});

test/basic/slice41-manual-regen.basic.test.js

@@ -0,0 +1,75 @@
+'use strict';
+
+const test = require('node:test');
+const assert = require('node:assert/strict');
+
+const DashboardApi = require('../../src/specificClass.js');
+const handlers = require('../../src/commands/handlers.js');
+
+function makeCtx(sends, nodeId = 'dApi-1') {
+  return {
+    node: { id: nodeId },
+    RED: { nodes: { getNode: () => null } },
+    send: (m) => sends.push(m),
+    logger: null,
+  };
+}
+
+function makeChildPayload(id, softwareType = 'measurement') {
+  return {
+    config: {
+      general: { id, name: id },
+      functionality: { softwareType, positionVsParent: 'downstream' },
+    },
+  };
+}
+
+test('recordChild caches child source by id; subsequent ones replace by id', () => {
+  const api = new DashboardApi({});
+  api.recordChild(makeChildPayload('a'));
+  api.recordChild(makeChildPayload('b'));
+  api.recordChild(makeChildPayload('a')); // replace
+  assert.equal(api.cachedChildSources().length, 2);
+});
+
+test('regenerate-dashboard with no cached children is a no-op (no msgs emitted)', () => {
+  const api = new DashboardApi({});
+  const sends = [];
+  handlers.regenerateDashboard(api, { topic: 'regenerate-dashboard', payload: {} }, makeCtx(sends));
+  assert.equal(sends.length, 0);
+});
+
+test('regenerate-dashboard re-emits for each cached child, bypassing diff', () => {
+  const api = new DashboardApi({});
+  // Pre-populate cache as if two children had registered.
+  api.recordChild(makeChildPayload('m-1'));
+  api.recordChild(makeChildPayload('m-2'));
+
+  // Set a diff that says nothing changed — registerChild would skip, but
+  // regenerateDashboard should ignore the predicate.
+  api.lastFlowsStartedDiff = { added: [], changed: [], removed: [], rewired: [] };
+
+  const sends = [];
+  handlers.regenerateDashboard(api, { topic: 'regenerate-dashboard', payload: {} }, makeCtx(sends));
+  // Each child yields at least one dashboard message (the root for the child's view).
+  assert.ok(sends.length >= 2, `expected ≥2 emitted msgs, got ${sends.length}`);
+  // Every emitted msg carries trigger: 'manual' in meta.
+  for (const m of sends) assert.equal(m.meta?.trigger, 'manual');
+});
+
+test('child.register stamps trigger: child.register in emitted msg meta', () => {
+  const api = new DashboardApi({});
+  api.lastFlowsStartedDiff = null; // cold-start → always regen
+  const sends = [];
+  handlers.registerChild(api, { topic: 'child.register', payload: makeChildPayload('m-3') }, makeCtx(sends));
+  assert.ok(sends.length >= 1);
+  for (const m of sends) assert.equal(m.meta?.trigger, 'child.register');
+});
+
+test('command registry exposes regenerate-dashboard with regen alias', () => {
+  const registry = require('../../src/commands/index.js');
+  const entry = registry.find((e) => e.topic === 'regenerate-dashboard');
+  assert.ok(entry, 'topic registered');
+  assert.deepEqual(entry.aliases, ['regen']);
+  assert.equal(typeof entry.handler, 'function');
+});