HTTP Response¶

Description¶

HTTP Response is a destination node that defines the payload, status code, body source, or file returned to an inbound HTTP caller after the pipeline finishes. It does not call an external system. Instead, it writes a response contract into the run state so the inbound HTTP runtime can return the configured response.

Use HTTP Response at the end of request-driven pipeline branches that begin with an inbound HTTP request and need to return a controlled response to the caller.

Field reference¶

Field	Description
Response type	Determines the response shape. Supported values are `status_json`, `json`, `xml`, `text`, `file`, and `none`. Defaults to `status_json`.
Success status code	HTTP status code returned when the pipeline succeeds. Defaults to `200`. Values are clamped to the HTTP status range `100` through `599`.
Response source	Determines where the response body or file should come from. Supported values are `job_status`, `template`, `upstream_stream`, `upstream_artifact`, `last_artifact`, and `node_output`. Defaults to `job_status`.
Content type override	Optional MIME type override. When blank, SchemAlign uses the source metadata or a default for the response type.
Template / body	Static JSON, XML, or text response body used when Response source is `template`. JSON responses may use a JSON object or array string.
Producer node ID	Optional upstream node id to read from. Leave blank to use the connected upstream node. Use this when multiple upstream nodes are available or when a specific producer should be selected.
Filename	Optional artifact filename to return or use when selecting a file-like upstream payload.
Attachment filename	Optional download filename for file responses. When blank, SchemAlign derives a filename from the selected artifact.

When to use HTTP Response¶

Use this node when the pipeline should:

return a success/status payload after an inbound HTTP workflow completes
return static JSON, XML, or text
return transformed upstream output as JSON, XML, or text
return a published artifact as a file download
intentionally return no body while still controlling the success status code

HTTP Response is a destination node. It normally appears at the end of a request-driven pipeline branch.

Common pipeline patterns¶

Pattern	Use case
`Inbound HTTP Request -> HTTP Response`	Accept a request and return a simple status, static body, or selected request content.
`Inbound HTTP Request -> SQL Transform -> HTTP Response`	Process request data and return transformed results.
`Inbound HTTP Request -> File Put -> HTTP Response`	Process a request, deliver a file, and return a status response.
`SQL Transform -> HTTP Response`	Return query output from a request-driven pipeline.

Response types¶

Response type	Behavior
`status_json`	Returns a default JSON status payload that includes run and pipeline identifiers.
`json`	Returns JSON parsed from the selected source. Template text is parsed as JSON when possible.
`xml`	Returns text using an XML-oriented response type.
`text`	Returns plain text from the selected source.
`file`	Returns a published artifact as a file response.
`none`	Returns no response body.

Response sources¶

Response source	Behavior
`job_status`	Uses the default status payload. In file mode, this falls back to the last available artifact.
`template`	Uses the static value entered in Template / body.
`upstream_stream`	Reads stream text or bytes from the selected connected upstream node.
`upstream_artifact`	Prefers a published artifact from the selected upstream node.
`last_artifact`	Uses the most recent artifact recorded in the run state.
`node_output`	Returns the node output map available in the execution context.

File response behavior¶

When Response type is file, HTTP Response requires a published artifact from the configured source. If Attachment filename is blank, SchemAlign derives a download filename from artifact metadata or the artifact path. If Content type override is blank, SchemAlign uses artifact MIME metadata or application/octet-stream.

File mode does not create a new artifact. It selects an existing published artifact and records that selection in the response contract.

Template behavior¶

When Response source is template, SchemAlign reads Template / body directly from the node configuration.

Response type	Template behavior
`json`	Attempts to parse the template as JSON. Blank or invalid JSON falls back to a safe parsed value.
`xml`	Returns the template text as the XML response body.
`text`	Returns the template text as the response body.

Avoid placing secrets in response templates. The configured body may be returned to the external caller.

Output behavior¶

HTTP Response stores the final response contract in run state under the HTTP response output. The contract includes response type, status code, source, content type, parsed body, body text, selected artifact metadata, and attachment filename.

The inbound HTTP runtime reads this contract after the pipeline completes and renders the actual caller response.

Validation and common errors¶

Message or condition	What it means	How to fix it
Unsupported response type falls back to `status_json`	The configured response type is not recognized.	Use `status_json`, `json`, `xml`, `text`, `file`, or `none`.
Unsupported response source falls back to `job_status`	The configured response source is not recognized.	Use one of the supported response source values.
Status code outside `100` through `599`	The configured status code is outside the HTTP status range.	Enter a valid HTTP status code.
`HTTP Response file mode requires a published upstream or last artifact`	File response mode could not find a published artifact.	Connect a producer that publishes an artifact, select the correct producer, or use a non-file response type.
`No last artifact is available for HTTP Response`	The node is configured to use the last artifact, but the run has not produced one.	Use a specific upstream producer or add a node that publishes an artifact before HTTP Response.
Response body is empty	The selected source did not provide body text or parsed content.	Check the selected response source and upstream output.

Security notes¶

HTTP Response does not call an external service; it defines what the inbound HTTP caller receives.
Treat Template / body content as externally visible when used in request-driven workflows.
Do not include secrets, credentials, tokens, or internal-only details in response templates or node outputs returned to callers.
Use Content type override intentionally so callers can interpret the response correctly.
File responses should only expose artifacts that the pipeline is intended to return.