@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/nodes/request/bindings/create-bound-request-fragment.js

@@ -0,0 +1,82 @@
+import { readFileSync } from 'node:fs';
+import { node } from '@n8n/workflow-sdk';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+import { createSerializedHttpRequestNode } from '../serialization/create-serialized-http-request-node.js';
+import { resolveCredentialBinding } from '../../../legacy/workflow/request/credential-binding.js';
+import { compileRequestValidator } from './compile-request-validator.js';
+import { resolveOutputBindingSources } from './resolve-output-binding-sources.js';
+import { createOutputReaderCode } from './create-output-reader-code.js';
+export function createBoundRequestFragment(input, config) {
+    const sources = resolveOutputBindingSources(input);
+    const runtime = readFileSync(new URL('../runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    const validator = compileRequestValidator(config);
+    const linked = input.itemMode === 'linked';
+    const materialize = `OpenApiFlowRequestRuntime.materializeHttpRequest(config,responses,OpenApiFlowRequestValidator${config.deferredInputs ? ',inputValues' : ''})`;
+    const inputReader = config.deferredInputs
+        ? `const inputItems=$(${javascriptJsonLiteral(config.deferredInputs.inputNodeName)}).all(0,0);if(inputItems.length!==1||inputItems[0].json.revision!==${config.deferredInputs.revision})throw new Error('Missing or stale validated workflow inputs: expected revision ${config.deferredInputs.revision}');const inputValues=inputItems[0].json.values;`
+        : '';
+    const code = `${runtime}\n${validator}\nconst config=${javascriptJsonLiteral(config)};\n${inputReader}\n${linked ? `return $input.all().map((_,inputIndex)=>{${createOutputReaderCode(sources, true)}\nreturn {json:${materialize},pairedItem:{item:inputIndex}};});` : `${createOutputReaderCode(sources)}\nreturn [{json:${materialize}}];`}`;
+    const materializer = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: `${config.arguments.callId}-materialize`,
+            name: `Materialize ${config.arguments.callId}`,
+            position: input.position,
+            parameters: { mode: 'runOnceForAllItems', jsCode: code },
+        },
+    });
+    const bodyPresent = Object.hasOwn(config.arguments.values, 'body') ||
+        config.arguments.bindings.some((binding) => binding.targetPointer === '/body' ||
+            binding.targetPointer.startsWith('/body/')) ||
+        config.deferredInputs?.slots.some((slot) => slot.targetPointer === '/body' ||
+            slot.targetPointer.startsWith('/body/')) === true;
+    const mediaTypes = config.operation.body
+        ? Object.keys(config.operation.body.mediaTypes)
+        : [];
+    const mediaType = config.arguments.requestMediaType ??
+        (mediaTypes.length === 1 ? mediaTypes[0] : undefined);
+    if (bodyPresent && mediaType === undefined)
+        throw new Error('requestMediaType must select the bound body media type');
+    if (bodyPresent &&
+        mediaType !== 'application/json' &&
+        mediaType !== 'application/x-www-form-urlencoded')
+        throw new Error(`${config.operation.operationRef}: requestBody media type ${mediaType} has no n8n mapping`);
+    const request = createSerializedHttpRequestNode({
+        bodySource: 'materialized',
+        operation: config.operation,
+        id: `${config.arguments.callId}-transport`,
+        name: 'Receive ' + config.arguments.callId,
+        position: [input.position[0] + 220, input.position[1]],
+        url: '={{ $json.url }}',
+        headers: [],
+        body: bodyPresent
+            ? {
+                contentType: mediaType === 'application/json' ? 'json' : 'form-urlencoded',
+                value: '={{ $json.body.value }}',
+            }
+            : undefined,
+        authentication: resolveCredentialBinding(input, input.credentialBindings),
+        shouldAssert: false,
+    });
+    // Headers may include bound values; HTTP Request supports a JSON expression.
+    request.config.parameters = {
+        ...request.config.parameters,
+        sendHeaders: true,
+        specifyHeaders: 'json',
+        jsonHeaders: '={{ $json.headersJson }}',
+    };
+    return {
+        nodeId: config.arguments.callId,
+        preservesInputItems: linked,
+        bindingSources: sources,
+        nodes: [materializer, request],
+        entry: materializer,
+        exit: request,
+        internalEdges: [
+            { from: materializer.id, output: 0, to: request.id, input: 0 },
+        ],
+        inputPorts: { main: 0 },
+        outputPorts: { main: 0 },
+    };
+}

package/dist/nodes/request/bindings/create-output-item-reader-code.d.ts

@@ -0,0 +1,2 @@
+/** A graph-proven singleton is read as exactly one item, never as an ancestry fallback. */
+export declare function createOutputItemReaderCode(linked: boolean): string;

package/dist/nodes/request/bindings/create-output-item-reader-code.js

@@ -0,0 +1,7 @@
+/** A graph-proven singleton is read as exactly one item, never as an ancestry fallback. */
+export function createOutputItemReaderCode(linked) {
+    const single = "const items=$(source.nodeName).all();if(items.length!==1)throw new Error('Response '+source.nodeId+' requires an unambiguous single JSON item; got '+items.length+' items');return items[0];";
+    return linked
+        ? `const item=source.singleton===true?(()=>{${single}})():$(source.nodeName).itemMatching(inputIndex);`
+        : `const item=(()=>{${single}})();`;
+}

package/dist/nodes/request/bindings/create-output-reader-code.d.ts

@@ -0,0 +1,3 @@
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+/** Read declared JSON roots without coercion or ambiguous item selection. */
+export declare function createOutputReaderCode(sources: N8nOutputBindingSource[], linked?: boolean, singletonNodeIds?: string[]): string;

package/dist/nodes/request/bindings/create-output-reader-code.js

@@ -0,0 +1,26 @@
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+import { compileNativeOutputValidators } from './compile-native-output-validators.js';
+import { compileSourceResponseValidators } from './compile-source-response-validators.js';
+import { createOutputItemReaderCode } from './create-output-item-reader-code.js';
+/** Read declared JSON roots without coercion or ambiguous item selection. */
+export function createOutputReaderCode(sources, linked = false, singletonNodeIds = []) {
+    const declarations = sources.map((source, index) => ({
+        nodeId: source.nodeId,
+        nodeName: source.nodeName,
+        kind: source.kind,
+        singleton: singletonNodeIds.includes(source.nodeId),
+        validator: source.kind === 'native-json' || source.operation ? index : null,
+    }));
+    const responseValidators = sources
+        .map((source, index) => source.kind === 'api-response' && source.operation
+        ? `OpenApiFlowResponseValidator${index}`
+        : 'null')
+        .join(',');
+    const nativeValidators = sources
+        .map((source, index) => source.kind === 'native-json'
+        ? `OpenApiFlowNativeOutputValidator${index}`
+        : 'null')
+        .join(',');
+    const reader = createOutputItemReaderCode(linked);
+    return `${compileNativeOutputValidators(sources)}\n${compileSourceResponseValidators(sources)}\nconst sources=${javascriptJsonLiteral(declarations)};\nconst validators=[${responseValidators}];\nconst nativeValidators=[${nativeValidators}];\nconst responses=Object.create(null);\nfor(const source of sources){${reader}if(!item||!item.json||typeof item.json!=='object')throw new Error('Missing JSON output '+source.nodeId);if(source.kind==='api-response'){if(source.validator!==null){const validate=validators[source.validator];if(!validate(OpenApiFlowRequestRuntime.apiResponseValidationValue(item.json)))throw new Error('Response '+source.nodeId+' does not match its OAS contract: '+JSON.stringify(validate.errors));}if(!Object.hasOwn(item.json,'body'))throw new Error('Missing response body '+source.nodeId);responses[source.nodeId]=item.json.body;}else{const validate=nativeValidators[source.validator];if(!validate(item.json))throw new Error('Native output does not match declared schema: '+JSON.stringify(validate.errors)+' (source '+source.nodeId+')');responses[source.nodeId]=item.json;}}`;
+}

package/dist/nodes/request/bindings/resolve-output-binding-sources.d.ts

@@ -0,0 +1,3 @@
+import type { CreateHttpRequestNodeInput } from '../../../types/node-fragment.js';
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+export declare function resolveOutputBindingSources(input: CreateHttpRequestNodeInput): N8nOutputBindingSource[];

package/dist/nodes/request/bindings/resolve-output-binding-sources.js

@@ -0,0 +1,36 @@
+import { validateNativeOutputContracts } from '@openapi-flow/core';
+export function resolveOutputBindingSources(input) {
+    validateNativeOutputContracts(input.nativeOutputSources ?? []);
+    const native = new Map((input.nativeOutputSources ?? []).map((item) => [item.nodeId, item]));
+    for (const item of native.values()) {
+        if (typeof item.nodeName !== 'string' || !item.nodeName.trim())
+            throw new Error(`nativeOutputSources[${item.nodeId}].nodeName must be a non-empty string`);
+        if (input.apiNodeNames && Object.hasOwn(input.apiNodeNames, item.nodeId))
+            throw new Error(`binding source ${item.nodeId} is declared as both API and native`);
+    }
+    return [
+        ...new Set(input.arguments.bindings.map((binding) => binding.sourceNodeId)),
+    ].map((nodeId) => {
+        const source = native.get(nodeId);
+        if (source)
+            return { ...source, kind: 'native-json' };
+        if (!input.apiNodeNames)
+            throw new Error(`arguments[${input.arguments.callId}] requires apiNodeNames for API response bindings`);
+        if (!Object.hasOwn(input.apiNodeNames, nodeId) ||
+            !input.apiNodeNames[nodeId].trim())
+            throw new Error(`apiNodeNames is missing ${nodeId}`);
+        if ((input.apiResponseContracts || input.itemMode === 'linked') &&
+            (!input.apiResponseContracts ||
+                !Object.hasOwn(input.apiResponseContracts, nodeId) ||
+                !input.apiResponseContracts[nodeId]))
+            throw new Error(`apiResponseContracts is missing ${nodeId}`);
+        return {
+            kind: 'api-response',
+            nodeId,
+            nodeName: input.apiNodeNames[nodeId],
+            ...(input.apiResponseContracts
+                ? { operation: input.apiResponseContracts[nodeId] }
+                : {}),
+        };
+    });
+}

package/dist/nodes/request/create-http-request-node.d.ts

@@ -0,0 +1,2 @@
+import type { CreateHttpRequestNodeInput, N8nNodeFragment } from '../../types/node-fragment.js';
+export declare function createHttpRequestNode(input: CreateHttpRequestNodeInput): N8nNodeFragment;

package/dist/nodes/request/create-http-request-node.js

@@ -0,0 +1,73 @@
+import { validateApiArguments, inspectApiArgumentRequirements, } from '@openapi-flow/core';
+import { resolveCredentialBinding } from '../../legacy/workflow/request/credential-binding.js';
+import { createBoundRequestFragment } from './bindings/create-bound-request-fragment.js';
+import { serializeHttpRequest } from './serialization/serialize-http-request.js';
+import { createSerializedHttpRequestNode } from './serialization/create-serialized-http-request-node.js';
+import { resolveHttpRequestNodeConfiguration } from './resolve-http-request-node-configuration.js';
+import { finalizeHttpRequestFragment } from './finalize-http-request-fragment.js';
+export function createHttpRequestNode(input) {
+    const { operation: contract, arguments: args } = input;
+    if (input.itemMode !== undefined && input.itemMode !== 'linked')
+        throw new Error('itemMode must be linked or omitted');
+    if (!args || typeof args.callId !== 'string' || !args.callId.trim())
+        throw new Error('arguments.callId must be non-empty');
+    if (!Array.isArray(args.unresolvedInputs))
+        throw new Error(`arguments[${args.callId}].unresolvedInputs must be an array`);
+    if (args.unresolvedInputs.length)
+        throw new Error(`arguments[${args.callId}] has unresolved inputs: ${args.unresolvedInputs.join(', ')}`);
+    const validation = validateApiArguments({
+        operation: contract,
+        values: args.values,
+        bindings: args.bindings,
+        requestMediaType: args.requestMediaType,
+    });
+    if (!validation.valid)
+        throw new Error(`arguments[${args.callId}] is missing ${validation.missingInputs.join(', ')}`);
+    const inspected = inspectApiArgumentRequirements({
+        operation: contract,
+        callId: args.callId,
+        values: args.values,
+        bindings: args.bindings,
+        requestMediaType: args.requestMediaType,
+        requestedInputs: args.requestedInputs,
+    });
+    if (inspected.status === 'needs-input')
+        throw new Error(`arguments[${args.callId}] is missing scenario-requested inputs: ${inspected.requirements.map((requirement) => requirement.targetPointer).join(', ')}`);
+    const prepared = resolveHttpRequestNodeConfiguration(input);
+    const resolvedInput = prepared.input;
+    const operation = prepared.config.operation;
+    let fragment;
+    if (args.bindings.length) {
+        fragment = createBoundRequestFragment(resolvedInput, prepared.config);
+    }
+    else {
+        const { url, body, headers } = serializeHttpRequest(operation, prepared.config.templateUrl, args.values, args.requestMediaType);
+        const request = createSerializedHttpRequestNode({
+            bodySource: 'literal',
+            operation,
+            id: `${args.callId}-transport`,
+            name: 'Receive ' + args.callId,
+            position: input.position,
+            url,
+            body,
+            headers,
+            authentication: resolveCredentialBinding(resolvedInput, resolvedInput.credentialBindings),
+            shouldAssert: false,
+        });
+        fragment = {
+            nodeId: args.callId,
+            preservesInputItems: true,
+            nodes: [request],
+            entry: request,
+            exit: request,
+            inputPorts: { main: 0 },
+            outputPorts: { main: 0 },
+        };
+    }
+    return finalizeHttpRequestFragment({
+        fragment,
+        method: contract.method,
+        documentId: contract.key.documentId,
+        deployment: resolvedInput,
+    });
+}

package/dist/nodes/request/deployment/create-request-deployment-notes.d.ts

@@ -0,0 +1,2 @@
+import type { ResolvedHttpRequestDeployment } from '../../../types/request-deployment.js';
+export declare function createRequestDeploymentNotes(documentId: string, deployment: ResolvedHttpRequestDeployment): string;

package/dist/nodes/request/deployment/create-request-deployment-notes.js

@@ -0,0 +1,3 @@
+export function createRequestDeploymentNotes(documentId, deployment) {
+    return `REPLACE_ME: OAS ${documentId} requires ${deployment.pendingFields.join(', ')} before execution. Supply deployment options and regenerate, or replace the placeholders in the exported JSON and select the real n8n credential. Bound request URLs are configured in their Materialize node. No credential secret is stored in this workflow.`;
+}

package/dist/nodes/request/deployment/resolve-http-request-deployment.d.ts

@@ -0,0 +1,2 @@
+import type { ResolveHttpRequestDeploymentInput, ResolvedHttpRequestDeployment } from '../../../types/request-deployment.js';
+export declare function resolveHttpRequestDeployment(input: ResolveHttpRequestDeploymentInput): ResolvedHttpRequestDeployment;

package/dist/nodes/request/deployment/resolve-http-request-deployment.js

@@ -0,0 +1,33 @@
+import { httpRequestDeploymentOptionsSchema } from '../../../schemas/request-deployment-schema.js';
+export function resolveHttpRequestDeployment(input) {
+    const options = httpRequestDeploymentOptionsSchema.parse({
+        baseUrl: input.baseUrl,
+        credentialBindings: input.credentialBindings,
+        securityRequirementIndex: input.securityRequirementIndex,
+    });
+    const pendingFields = [];
+    let baseUrl;
+    if (options.baseUrl === undefined) {
+        baseUrl = 'https://REPLACE_ME.invalid';
+        pendingFields.push('baseUrl');
+    }
+    else {
+        baseUrl = options.baseUrl;
+    }
+    const credentialBindings = options.credentialBindings === undefined ? {} : options.credentialBindings;
+    const schemeName = input.authentication?.schemeName;
+    if (schemeName !== undefined &&
+        !Object.hasOwn(credentialBindings, schemeName)) {
+        credentialBindings[schemeName] = {
+            id: `REPLACE_ME:${encodeURIComponent(input.documentId)}:${encodeURIComponent(schemeName)}`,
+            name: `REPLACE_ME (${input.documentId}: ${schemeName})`,
+        };
+        pendingFields.push(`credentialBindings.${schemeName}`);
+    }
+    return {
+        baseUrl,
+        credentialBindings,
+        pendingFields,
+        authentication: input.authentication,
+    };
+}

package/dist/nodes/request/finalize-http-request-fragment.d.ts

@@ -0,0 +1,3 @@
+import type { FinalizeHttpRequestFragmentInput } from '../../types/request-node-configuration.js';
+import type { N8nNodeFragment } from '../../types/node-fragment.js';
+export declare function finalizeHttpRequestFragment(input: FinalizeHttpRequestFragmentInput): N8nNodeFragment;

package/dist/nodes/request/finalize-http-request-fragment.js

@@ -0,0 +1,22 @@
+import { createHttpResponseDecoder } from './response/create-http-response-decoder.js';
+import { createRequestDeploymentNotes } from './deployment/create-request-deployment-notes.js';
+export function finalizeHttpRequestFragment(input) {
+    const fragment = createHttpResponseDecoder(input);
+    const { deployment } = input;
+    if (deployment.pendingFields.length ||
+        deployment.authentication?.credentialRequirements) {
+        const notes = [
+            ...(deployment.pendingFields.length
+                ? [createRequestDeploymentNotes(input.documentId, deployment)]
+                : []),
+            ...(deployment.authentication?.credentialRequirements
+                ? [deployment.authentication.credentialRequirements]
+                : []),
+        ].join('\n');
+        for (const node of fragment.nodes) {
+            node.config.notes = notes;
+            node.config.notesInFlow = true;
+        }
+    }
+    return fragment;
+}

package/dist/nodes/request/resolve-http-request-node-configuration.d.ts

@@ -0,0 +1,4 @@
+import type { CreateHttpRequestNodeInput } from '../../types/node-fragment.js';
+import type { ResolveHttpRequestNodeConfigurationResult } from '../../types/request-node-configuration.js';
+/** Shared configuration ownership, after the strict or template boundary checks. */
+export declare function resolveHttpRequestNodeConfiguration(input: CreateHttpRequestNodeInput): ResolveHttpRequestNodeConfigurationResult;

package/dist/nodes/request/resolve-http-request-node-configuration.js

@@ -0,0 +1,41 @@
+import { mapHttpOperationContract } from '@openapi-flow/core/internal';
+import { originFrom } from '../../legacy/workflow/request/base-url.js';
+import { absoluteOperationPath } from '../../legacy/workflow/request/request-url.js';
+import { resolveHttpRequestAuthentication } from './authentication/resolve-http-request-authentication.js';
+import { resolveHttpRequestDeployment } from './deployment/resolve-http-request-deployment.js';
+/** Shared configuration ownership, after the strict or template boundary checks. */
+export function resolveHttpRequestNodeConfiguration(input) {
+    const contract = input.operation;
+    const operation = mapHttpOperationContract(contract.path, contract.method, contract.key.operationRef, contract.pathItem, contract.operation);
+    const authentication = resolveHttpRequestAuthentication({
+        operation: contract,
+        securityRequirementIndex: input.securityRequirementIndex,
+    });
+    const deployment = resolveHttpRequestDeployment({
+        documentId: contract.key.documentId,
+        authentication,
+        baseUrl: input.baseUrl,
+        credentialBindings: input.credentialBindings,
+        securityRequirementIndex: input.securityRequirementIndex,
+    });
+    return {
+        input: { ...input, ...deployment },
+        config: {
+            contract,
+            operation,
+            arguments: {
+                callId: input.arguments.callId,
+                values: structuredClone(input.arguments.values),
+                bindings: structuredClone(input.arguments.bindings),
+                ...(input.arguments.requestedInputs === undefined
+                    ? {}
+                    : { requestedInputs: [...input.arguments.requestedInputs] }),
+                unresolvedInputs: [...input.arguments.unresolvedInputs],
+                ...(input.arguments.requestMediaType === undefined
+                    ? {}
+                    : { requestMediaType: input.arguments.requestMediaType }),
+            },
+            templateUrl: new URL(absoluteOperationPath(originFrom(deployment.baseUrl), operation.path)).href,
+        },
+    };
+}

package/dist/nodes/request/response/create-http-response-decoder.d.ts

@@ -0,0 +1,4 @@
+import type { N8nNodeFragment } from '../../../types/node-fragment.js';
+import type { CreateHttpResponseDecoderInput } from '../../../types/http-response-decoding.js';
+/** Keep transport metadata and item ancestry while exposing the decoded API exit. */
+export declare function createHttpResponseDecoder({ fragment, method, }: CreateHttpResponseDecoderInput): N8nNodeFragment;

package/dist/nodes/request/response/create-http-response-decoder.js

@@ -0,0 +1,57 @@
+import { readFileSync } from 'node:fs';
+import { node } from '@n8n/workflow-sdk';
+import { isObject } from '@openapi-flow/core/internal';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+import { httpResponseNodeName } from './http-response-node-name.js';
+/** Keep transport metadata and item ancestry while exposing the decoded API exit. */
+export function createHttpResponseDecoder({ fragment, method, }) {
+    const transport = fragment.exit;
+    const position = transport.config.position;
+    if (!position || position.length !== 2)
+        throw new Error(`API ${fragment.nodeId} response decoder requires transport position`);
+    const parameters = transport.config.parameters;
+    if (!parameters ||
+        !isObject(parameters.options) ||
+        !isObject(parameters.options.response) ||
+        !isObject(parameters.options.response.response))
+        throw new Error(`API ${fragment.nodeId} transport requires options.response.response`);
+    transport.config.parameters = {
+        ...parameters,
+        options: {
+            ...parameters.options,
+            response: {
+                ...parameters.options.response,
+                response: {
+                    ...parameters.options.response.response,
+                    fullResponse: true,
+                    responseFormat: 'file',
+                    outputPropertyName: 'openApiFlowRawResponse',
+                },
+            },
+        },
+    };
+    const runtime = readFileSync(new URL('./response-runtime.bundle.js', import.meta.url), 'utf8');
+    const decoder = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: fragment.nodeId,
+            name: httpResponseNodeName(fragment.nodeId),
+            position: [position[0] + 220, position[1]],
+            notes: 'Decode the raw HTTP response once. Preserve status, headers, body types and item ancestry. Invalid JSON fails without repair.',
+            parameters: {
+                mode: 'runOnceForAllItems',
+                jsCode: `${runtime}\nconst sourceNodeId=${javascriptJsonLiteral(fragment.nodeId)};\nconst method=${javascriptJsonLiteral(method)};\nconst result=[];\nfor(const [inputIndex,item] of $input.all().entries()){\nconst bytes=await this.helpers.getBinaryDataBuffer(inputIndex,'openApiFlowRawResponse');\nconst decoded=OpenApiFlowResponseRuntime.decodeHttpResponse({response:item.json,bytes,method,sourceNodeId});\nconst binary={...item.binary};\nconst raw=binary.openApiFlowRawResponse;\ndelete binary.openApiFlowRawResponse;\nif(decoded.kind==='binary')binary.data=raw;\nresult.push({json:decoded.response,...(Object.keys(binary).length?{binary}:{}),pairedItem:{item:inputIndex}});\n}\nreturn result;`,
+            },
+        },
+    });
+    return {
+        ...fragment,
+        nodes: [...fragment.nodes, decoder],
+        exit: decoder,
+        internalEdges: [
+            ...(fragment.internalEdges ?? []),
+            { from: transport.id, output: 0, to: decoder.id, input: 0 },
+        ],
+    };
+}

package/dist/nodes/request/response/decode-http-response.d.ts

@@ -0,0 +1,3 @@
+import type { DecodedHttpResponse, HttpResponseDecodeInput } from '../../../types/http-response-decoding.js';
+/** Decode raw transport bytes once; never guess or repair an already parsed value. */
+export declare function decodeHttpResponse({ response, bytes, method, sourceNodeId, }: HttpResponseDecodeInput): DecodedHttpResponse;

package/dist/nodes/request/response/decode-http-response.js

@@ -0,0 +1,42 @@
+import { apiResponseValidationValue } from '@openapi-flow/core/runtime';
+import { isBinaryResponseMedia, isJsonResponseMedia, } from './http-response-media.js';
+/** Decode raw transport bytes once; never guess or repair an already parsed value. */
+export function decodeHttpResponse({ response, bytes, method, sourceNodeId, }) {
+    const observed = apiResponseValidationValue(response);
+    if (Object.hasOwn(response, 'body'))
+        throw new Error(`API ${sourceNodeId} raw File transport must not contain body`);
+    if (bytes.byteLength === 0 &&
+        (method === 'HEAD' ||
+            observed.statusCode === 204 ||
+            observed.statusCode === 304))
+        return { response: { ...response }, kind: 'empty' };
+    if (isBinaryResponseMedia(observed.mediaType))
+        return { response: { ...response }, kind: 'binary' };
+    const json = isJsonResponseMedia(observed.mediaType);
+    const contentType = Object.entries(response.headers).find(([name]) => name.toLowerCase() === 'content-type')?.[1];
+    const charset = typeof contentType === 'string'
+        ? /;\s*charset\s*=\s*(?:"([^"]*)"|([^;\s]*))/i.exec(contentType)
+        : null;
+    // JSON uses UTF-8 (RFC 8259 §8.1). Text retains the native UTF-8 codec default
+    // unless the actual HTTP header explicitly declares another charset.
+    const encoding = json || charset === null ? 'utf-8' : (charset[1] ?? charset[2]);
+    let text;
+    try {
+        text = new TextDecoder(encoding, { fatal: true, ignoreBOM: true }).decode(bytes);
+    }
+    catch (cause) {
+        throw new Error(`API ${sourceNodeId} has invalid HTTP response encoding`, {
+            cause,
+        });
+    }
+    if (!json)
+        return { response: { ...response, body: text }, kind: 'text' };
+    try {
+        return { response: { ...response, body: JSON.parse(text) }, kind: 'json' };
+    }
+    catch (cause) {
+        throw new Error(`API ${sourceNodeId} has an invalid JSON HTTP response`, {
+            cause,
+        });
+    }
+}

package/dist/nodes/request/response/http-response-media.d.ts

@@ -0,0 +1,2 @@
+export declare function isJsonResponseMedia(mediaType: string | undefined): boolean;
+export declare function isBinaryResponseMedia(mediaType: string | undefined): boolean;

package/dist/nodes/request/response/http-response-media.js

@@ -0,0 +1,32 @@
+// Preserve the HTTP Request v4.3 binary routing policy (n8n 2.37.10).
+// https://github.com/n8n-io/n8n/blob/n8n%402.37.10/packages/nodes-base/nodes/HttpRequest/GenericFunctions.ts
+const binaryMediaTypes = new Set([
+    'application/octet-stream',
+    'application/gzip',
+    'application/zip',
+    'application/vnd.rar',
+    'application/epub+zip',
+    'application/x-bzip',
+    'application/x-bzip2',
+    'application/x-cdf',
+    'application/vnd.amazon.ebook',
+    'application/msword',
+    'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+    'application/vnd.ms-fontobject',
+    'application/vnd.oasis.opendocument.presentation',
+    'application/pdf',
+    'application/x-tar',
+    'application/vnd.visio',
+    'application/vnd.ms-excel',
+    'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+    'application/x-7z-compressed',
+]);
+export function isJsonResponseMedia(mediaType) {
+    return (mediaType === 'application/json' ||
+        (mediaType !== undefined && /^[^/]+\/[^/]+\+json$/.test(mediaType)));
+}
+export function isBinaryResponseMedia(mediaType) {
+    return (mediaType !== undefined &&
+        (/^(image|audio|video)\//.test(mediaType) ||
+            binaryMediaTypes.has(mediaType)));
+}

package/dist/nodes/request/response/http-response-node-name.d.ts

@@ -0,0 +1,2 @@
+/** One compiler-owned exit identity, shared by producer and reference mapping. */
+export declare function httpResponseNodeName(callId: string): string;

package/dist/nodes/request/response/http-response-node-name.js

@@ -0,0 +1,4 @@
+/** One compiler-owned exit identity, shared by producer and reference mapping. */
+export function httpResponseNodeName(callId) {
+    return `Request ${callId}`;
+}

package/dist/nodes/request/response/response-runtime.bundle.js

@@ -0,0 +1,24 @@
+/*! MIT License
+
+Copyright (c) 2026 carefreelife98
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+ */
+var OpenApiFlowResponseRuntime;
+(()=>{function l(e){if(!e||!Number.isInteger(e.statusCode))throw new Error("API response.statusCode is required");if(!e.headers||typeof e.headers!="object"||Array.isArray(e.headers))throw new Error("API response.headers is required");let t=Object.entries(e.headers).filter(([r])=>r.toLowerCase()==="content-type");if(t.length>1)throw new Error("API response.headers has ambiguous Content-Type");let o={statusCode:e.statusCode};if(t.length){if(typeof t[0][1]!="string")throw new Error("API response Content-Type must be a string");o.mediaType=t[0][1].split(";")[0].trim().toLowerCase()}return Object.hasOwn(e,"body")&&(o.body=e.body),o}var x=new Set(["application/octet-stream","application/gzip","application/zip","application/vnd.rar","application/epub+zip","application/x-bzip","application/x-bzip2","application/x-cdf","application/vnd.amazon.ebook","application/msword","application/vnd.openxmlformats-officedocument.wordprocessingml.document","application/vnd.ms-fontobject","application/vnd.oasis.opendocument.presentation","application/pdf","application/x-tar","application/vnd.visio","application/vnd.ms-excel","application/vnd.openxmlformats-officedocument.spreadsheetml.sheet","application/x-7z-compressed"]);function h(e){return e==="application/json"||e!==void 0&&/^[^/]+\/[^/]+\+json$/.test(e)}function m(e){return e!==void 0&&(/^(image|audio|video)\//.test(e)||x.has(e))}function g({response:e,bytes:t,method:o,sourceNodeId:r}){let s=l(e);if(Object.hasOwn(e,"body"))throw new Error(`API ${r} raw File transport must not contain body`);if(t.byteLength===0&&(o==="HEAD"||s.statusCode===204||s.statusCode===304))return{response:{...e},kind:"empty"};if(m(s.mediaType))return{response:{...e},kind:"binary"};let d=h(s.mediaType),u=Object.entries(e.headers).find(([i])=>i.toLowerCase()==="content-type")?.[1],c=typeof u=="string"?/;\s*charset\s*=\s*(?:"([^"]*)"|([^;\s]*))/i.exec(u):null,w=d||c===null?"utf-8":c[1]??c[2],a;try{a=new TextDecoder(w,{fatal:!0,ignoreBOM:!0}).decode(t)}catch(i){throw new Error(`API ${r} has invalid HTTP response encoding`,{cause:i})}if(!d)return{response:{...e,body:a},kind:"text"};try{return{response:{...e,body:JSON.parse(a)},kind:"json"}}catch(i){throw new Error(`API ${r} has an invalid JSON HTTP response`,{cause:i})}}OpenApiFlowResponseRuntime={decodeHttpResponse:g};})();

package/dist/nodes/request/runtime/materialize-http-request.d.ts

@@ -0,0 +1,4 @@
+import type { DeferredApiInputValues } from '@openapi-flow/core';
+import type { RequestMaterializationConfig, ResponseBodies, RuntimeHttpRequest, RuntimeRequestValidator } from '../../../types/request-materialization.js';
+/** Shared OAS validators/serializers run on the final values before HTTP sends. */
+export declare function materializeHttpRequest(config: RequestMaterializationConfig, responses: ResponseBodies, validate: RuntimeRequestValidator, inputValues?: DeferredApiInputValues): RuntimeHttpRequest;

package/dist/nodes/request/runtime/materialize-http-request.js

@@ -0,0 +1,35 @@
+import { materializeApiArguments, assignRequestInputValue, listMissingRequestedApiInputs, } from '@openapi-flow/core/runtime';
+import { serializeHttpRequest } from '../serialization/serialize-http-request.js';
+/** Shared OAS validators/serializers run on the final values before HTTP sends. */
+export function materializeHttpRequest(config, responses, validate, inputValues) {
+    let literals = JSON.parse(JSON.stringify(config.arguments.values));
+    for (const slot of config.deferredInputs?.slots ?? []) {
+        if (!inputValues || !Object.hasOwn(inputValues, slot.id))
+            throw new Error(`Missing runtime input ${slot.id} for ${slot.callId}${slot.targetPointer}`);
+        literals = assignRequestInputValue(literals, slot.targetPointer, inputValues[slot.id], {
+            callId: config.arguments.callId,
+            operation: config.contract,
+            requestMediaType: config.arguments.requestMediaType,
+        });
+    }
+    const values = materializeApiArguments(literals, config.arguments.bindings, responses, {
+        callId: config.arguments.callId,
+        operation: config.contract,
+        requestMediaType: config.arguments.requestMediaType,
+    });
+    if (!validate(values))
+        throw new Error(`Runtime request ${config.arguments.callId} does not match the OAS schema: ${JSON.stringify(validate.errors)}`);
+    const missing = listMissingRequestedApiInputs({
+        source: `Runtime request ${config.arguments.callId}`,
+        rootPointer: '',
+        value: values,
+        requestedInputs: config.arguments.requestedInputs,
+    });
+    if (missing.length)
+        throw new Error(`Runtime request ${config.arguments.callId} omits scenario-requested inputs: ${missing.join(', ')}`);
+    const request = serializeHttpRequest(config.operation, config.templateUrl, values, config.arguments.requestMediaType);
+    return {
+        ...request,
+        headersJson: JSON.stringify(Object.fromEntries(request.headers.map((header) => [header.name, header.value]))),
+    };
+}