Possibility to communicate warnings together with data result from backend.

[anders-kiaer]

A common use case for this is e.g. that you want to calculate statistics over a given set of realizations, and then when the backend does the calculation, it discovers that for the data type in question + set of realizations, some of them are missing the necessary data.

In some cases, it would be preferred to calculate statistics over the realizations that do have data, and at the same time communicate to the user which realizations where forced to be removed from the calculation.

[rubenthoms]

There are several parts of this task that require some research and evaluation

Transportation of warnings from backend to frontend via HTTP

• HTTP header - there doesn't seem to be a standard header for this purpose (https://datatracker.ietf.org/doc/html/rfc9111#name-warning) so we'd need to use a custom one
• Body - how to make this generic? Regarding structured data we could use a JSON wrapper with the warnings around our actual data. However, how about binary data? Are we gonna stick to Base64 and can therefore keep JSON for all responses or do we actually want to send raw binary? To solve the latter we might be able to use multipart/form-data responses: How can I return from a FastAPI service a multipart/form-data response consisting in one binary file and additional data fields, or consisting in multiple binary files ? fastapi/fastapi#8785

Creating responses in FastAPI

We somehow need to add the warning to either the header or the response. Do we change the way we return data from our endpoints to a function taking the actual response data + potential warnings/errors and creates a unified response? What are alternatives?

Consuming the responses frontend

How can we intercept the warnings/errors coming from backend in a HTTP response in an automated manner? We need access to:

• The response body and potentially the header (depending on the means of transportation)
• The module instance id
  We want the HTTP response as an input and the actual response data and warning as two separate outputs. The former gets send to the module that made the request, the second one is passed automatically to the module instance.
  Where do we (need to) intercept?
• Axios - difficult as all functions are auto-generated
• Tanstack Query - has no access to the header information and is very close to the actual module implementation level
• An optional wrapper around the @api calls in useQuery calls that do the separation for us - would require the module instance id