Dashboard Tools Runner

The Dashboard Tools Runner enables two specialized node templates used for filtering and visualizing data within a session context:

1. `json-filter` (Transform Node)

This node uses a JMESPath expression to extract a specific subset of JSON from its input.
Typical usage: Isolate data related to the current session, user, or any scoped variable before passing it to downstream nodes.

2. `dashboard` (Aggregation Node)

This node aggregates the filtered input and publishes a dashboard dimension to the backend.

It requires the following configuration properties:

dataSourceName — a unique key identifying the data source
layoutConfiguration — an array describing the layout and components of the dashboard
dashboardName — a human-readable name for the resulting dashboard

Integration in a Session Template

Here’s how you can incorporate these nodes into your session template:

Insert a json-filter node immediately after your data ingestion or transformation node.
Set the expression field using session-scoped variables. Example: records[?userId=='$SESSION.userId']
Connect a dashboard node to consume the filtered output.
Provide the dataSourceName, define the layoutConfiguration, and specify the dashboardName.

This pipeline ensures the dashboard reflects only the data relevant to the active session.

Input Payload Requirements

To assign proper access controls, the JSON passed to the dashboard node must include a dashboardUsers field — an array of GUIDs representing users who should have access:


{
  "map": {
    /* widget-specific or component-specific data */
  },
  "dashboardUsers": ["<user-guid-1>", "<user-guid-2>"]
}

map: Arbitrary data keyed by component or widget name. This structure must be compatible with your dashboard panel definitions.
dashboardUsers: An array of user GUIDs granted visibility to the resulting dashboard dimension.

Note: If dashboardUsers is omitted, the dashboard will only be visible to the runner’s internal service account.

Example: Filtering with JMESPath

Below is a basic example showing how the json-filter node processes input:

Input JSON:


[
  { "userId": "u1", "score": 10 },
  { "userId": "u2", "score": 15 },
  { "userId": "u1", "score": 20 }
]

JMESPath Expression:


[?userId=='u1']

Filtered Output:


[
  { "userId": "u1", "score": 10 },
  { "userId": "u1", "score": 20 }
]

Configuration Tips

Use $SESSION.* variables in JMESPath expressions for dynamic filtering.
Keep layout definitions minimal — specify only what is necessary (row/column span, widget types, etc.).
Give dashboards meaningful names to help users distinguish between multiple visualizations.

Runtime Behavior

At runtime, the Dashboard Tools Runner performs the following:

Evaluates the JMESPath expression against the raw payload in the json-filter node.
Passes the filtered data to the dashboard node, which:
1. Submits the full output payload
2. Parses dashboardUsers to define access controls
3. Publishes a new dashboard dimension using the provided name and layout

Both nodes are idempotent — re-running them will append new outputs without overwriting previously published data.

Dashboard Tools Runner

1. json-filter (Transform Node)

2. dashboard (Aggregation Node)