@openapi-flow/n8n 0.0.0-stage → 0.2.0

package/dist/nodes/native/response-checks/create-response-check-reader.d.ts

@@ -0,0 +1,3 @@
+import type { CreateResponseCheckReaderInput, CompiledResponseCheckReader } from '../../../types/response-check-compilation.js';
+/** Reuse full OAS response validation before native comparisons, without changing data. */
+export declare function createResponseCheckReader({ nodeId, checks, apiNodeNames, apiResponseContracts, linked, }: CreateResponseCheckReaderInput): CompiledResponseCheckReader;

package/dist/nodes/native/response-checks/create-response-check-reader.js

@@ -0,0 +1,23 @@
+import { readFileSync } from 'node:fs';
+import { responseReferences } from '../common/response-references.js';
+import { createOutputReaderCode } from '../../request/bindings/create-output-reader-code.js';
+/** Reuse full OAS response validation before native comparisons, without changing data. */
+export function createResponseCheckReader({ nodeId, checks, apiNodeNames, apiResponseContracts, linked, }) {
+    const ids = [...new Set(responseReferences(checks).map((ref) => ref.nodeId))];
+    const bindingSources = ids.map((id) => {
+        const operation = apiResponseContracts?.[id];
+        if (!operation)
+            throw new Error(`native node ${nodeId}: apiResponseContracts is missing ${id}`);
+        const nodeName = apiNodeNames[id];
+        if (typeof nodeName !== 'string' || !nodeName.trim())
+            throw new Error(`native node ${nodeId}: apiNodeNames is missing ${id}`);
+        return { kind: 'api-response', nodeId: id, nodeName, operation };
+    });
+    if (!bindingSources.length)
+        return { code: 'const responses=Object.create(null);', bindingSources };
+    const runtime = readFileSync(new URL('../../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    return {
+        code: `${runtime}\n${createOutputReaderCode(bindingSources, linked)}`,
+        bindingSources,
+    };
+}

package/dist/nodes/native/stop-and-error-capability.d.ts

@@ -0,0 +1,2 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+export declare function createStopAndErrorCapability(): N8nNativeCapability;

package/dist/nodes/native/stop-and-error-capability.js

@@ -0,0 +1,29 @@
+import { node } from '@n8n/workflow-sdk';
+import { stopParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+export function createStopAndErrorCapability() {
+    return {
+        name: 'stop-and-error',
+        description: 'n8n StopAndError: main input, no outputs. Fail the workflow with an explicit message.',
+        parametersSchema: stopParametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => [],
+        responseReferences: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        compile: ({ planned, position }) => createNativeFragment(node({
+            type: 'n8n-nodes-base.stopAndError',
+            version: 1,
+            config: {
+                id: planned.id,
+                name: planned.id,
+                position,
+                parameters: {
+                    errorType: 'errorMessage',
+                    errorMessage: stopParametersSchema.parse(planned.parameters)
+                        .message,
+                },
+            },
+        }), ['main'], []),
+    };
+}

package/dist/nodes/request/authentication/credential-field-name.d.ts

@@ -0,0 +1 @@
+export declare function looksLikeCredential(name: string): boolean;

package/dist/nodes/request/authentication/credential-field-name.js

@@ -0,0 +1,3 @@
+export function looksLikeCredential(name) {
+    return /(token|secret|password|authorization|api.?key)/i.test(name);
+}

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

@@ -0,0 +1,2 @@
+import type { HttpRequestAuthenticationMapping, ResolveHttpRequestAuthenticationInput } from '../../../types/authentication.js';
+export declare function resolveHttpRequestAuthentication(input: ResolveHttpRequestAuthenticationInput): HttpRequestAuthenticationMapping | undefined;

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

@@ -0,0 +1,42 @@
+import { resolveOpenApiSecurity } from '@openapi-flow/core';
+import { UnsupportedOperationError } from '@openapi-flow/core/internal';
+export function resolveHttpRequestAuthentication(input) {
+    const contract = input.operation;
+    const selected = resolveOpenApiSecurity({
+        operationRef: contract.key.operationRef,
+        security: contract.effective.security,
+        securitySchemes: contract.effective.securitySchemes,
+        requirementIndex: input.securityRequirementIndex,
+    });
+    if (!selected || !selected.schemes.length)
+        return undefined;
+    if (selected.schemes.length !== 1)
+        throw new UnsupportedOperationError(contract.key.operationRef, `${contract.key.operationRef}: combined security schemes require a separate composite credential mapping`);
+    const { name, definition, scopes } = selected.schemes[0];
+    if (definition.type === 'http') {
+        const scheme = String(definition.scheme).toLowerCase();
+        if (scheme === 'bearer')
+            return { schemeName: name, credentialType: 'httpBearerAuth' };
+        if (scheme === 'basic')
+            return { schemeName: name, credentialType: 'httpBasicAuth' };
+        if (scheme === 'digest')
+            return { schemeName: name, credentialType: 'httpDigestAuth' };
+    }
+    if (definition.type === 'apiKey' &&
+        ['header', 'query'].includes(String(definition.in))) {
+        if (typeof definition.name !== 'string' || !definition.name.trim())
+            throw new Error(`${contract.key.operationRef}.securitySchemes.${name}.name is required`);
+        return {
+            schemeName: name,
+            credentialType: definition.in === 'header' ? 'httpHeaderAuth' : 'httpQueryAuth',
+            credentialRequirements: `OAS ${name}: configure the credential ${definition.in} Name as ${JSON.stringify(definition.name)}. The workflow contains only a credential reference; the stored secret and Name are owned by n8n.`,
+        };
+    }
+    if (definition.type === 'oauth2')
+        return {
+            schemeName: name,
+            credentialType: 'oAuth2Api',
+            credentialRequirements: `OAS ${name}: use an existing OAuth2 credential configured for the declared flows and required scopes ${JSON.stringify(scopes)}. This compiler does not create grants, invent tokens or verify the stored credential configuration.`,
+        };
+    throw new UnsupportedOperationError(contract.key.operationRef, `${contract.key.operationRef}.securitySchemes.${name}: ${definition.type}/${definition.scheme ?? definition.in ?? ''} has no implemented HTTP Request credential mapping`);
+}

package/dist/nodes/request/bindings/compile-native-output-validators.d.ts

@@ -0,0 +1,3 @@
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+/** Every producer retains its own schema resource root and reference scope. */
+export declare function compileNativeOutputValidators(sources: N8nOutputBindingSource[]): string;

package/dist/nodes/request/bindings/compile-native-output-validators.js

@@ -0,0 +1,12 @@
+import { compileStandaloneValidator } from '../../common/validation/compile-standalone-validator.js';
+/** Every producer retains its own schema resource root and reference scope. */
+export function compileNativeOutputValidators(sources) {
+    return sources
+        .map((source, index) => source.kind === 'native-json'
+        ? compileStandaloneValidator({
+            schema: source.schema,
+            globalName: `OpenApiFlowNativeOutputValidator${index}`,
+        })
+        : '')
+        .join('\n');
+}

package/dist/nodes/request/bindings/compile-request-validator.d.ts

@@ -0,0 +1,3 @@
+import type { RequestMaterializationConfig } from '../../../types/request-materialization.js';
+/** Compile OAS schemas on the host; n8n receives no schema compiler/eval. */
+export declare function compileRequestValidator(config: RequestMaterializationConfig): string;

package/dist/nodes/request/bindings/compile-request-validator.js

@@ -0,0 +1,13 @@
+import { createApiRequestSchema } from '@openapi-flow/core';
+import { compileStandaloneValidator } from '../../common/validation/compile-standalone-validator.js';
+/** Compile OAS schemas on the host; n8n receives no schema compiler/eval. */
+export function compileRequestValidator(config) {
+    const schema = createApiRequestSchema({
+        operation: config.contract,
+        requestMediaType: config.arguments.requestMediaType,
+    });
+    return compileStandaloneValidator({
+        schema,
+        globalName: 'OpenApiFlowRequestValidator',
+    });
+}

package/dist/nodes/request/bindings/compile-source-response-validators.d.ts

@@ -0,0 +1,2 @@
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+export declare function compileSourceResponseValidators(sources: N8nOutputBindingSource[]): string;

package/dist/nodes/request/bindings/compile-source-response-validators.js

@@ -0,0 +1,12 @@
+import { createApiResponseSchema } from '@openapi-flow/core';
+import { compileStandaloneValidator } from '../../common/validation/compile-standalone-validator.js';
+export function compileSourceResponseValidators(sources) {
+    return sources
+        .map((source, index) => source.kind === 'api-response' && source.operation
+        ? compileStandaloneValidator({
+            schema: createApiResponseSchema({ operation: source.operation }),
+            globalName: `OpenApiFlowResponseValidator${index}`,
+        })
+        : '')
+        .join('\n');
+}

package/dist/nodes/request/bindings/create-bound-request-fragment.d.ts

@@ -0,0 +1,3 @@
+import type { CreateBoundHttpRequestNodeInput, N8nNodeFragment } from '../../../types/node-fragment.js';
+import type { RequestMaterializationConfig } from '../../../types/request-materialization.js';
+export declare function createBoundRequestFragment(input: CreateBoundHttpRequestNodeInput, config: RequestMaterializationConfig): N8nNodeFragment;

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

@@ -0,0 +1,77 @@
+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)`;
+    const code = `${runtime}\n${validator}\nconst config=${javascriptJsonLiteral(config)};\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/'));
+    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-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): 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';
+/** Read declared JSON roots without coercion or ambiguous item selection. */
+export function createOutputReaderCode(sources, linked = false) {
+    const declarations = sources.map((source, index) => ({
+        nodeId: source.nodeId,
+        nodeName: source.nodeName,
+        kind: source.kind,
+        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 = linked
+        ? 'const item=$(source.nodeName).itemMatching(inputIndex);'
+        : "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');const item=items[0];";
+    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,94 @@
+import { validateApiArguments } from '@openapi-flow/core';
+import { mapHttpOperationContract } from '@openapi-flow/core/internal';
+import { originFrom } from '../../legacy/workflow/request/base-url.js';
+import { resolveCredentialBinding } from '../../legacy/workflow/request/credential-binding.js';
+import { absoluteOperationPath } from '../../legacy/workflow/request/request-url.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 { resolveHttpRequestDeployment } from './deployment/resolve-http-request-deployment.js';
+import { createRequestDeploymentNotes } from './deployment/create-request-deployment-notes.js';
+import { resolveHttpRequestAuthentication } from './authentication/resolve-http-request-authentication.js';
+import { createHttpResponseDecoder } from './response/create-http-response-decoder.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 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,
+    });
+    const resolvedInput = { ...input, ...deployment };
+    let fragment;
+    if (args.bindings.length) {
+        fragment = createBoundRequestFragment(resolvedInput, {
+            contract,
+            operation,
+            arguments: args,
+            templateUrl: new URL(absoluteOperationPath(originFrom(deployment.baseUrl), operation.path)).href,
+        });
+    }
+    else {
+        const { url, body, headers } = serializeHttpRequest(operation, new URL(absoluteOperationPath(originFrom(deployment.baseUrl), operation.path)).href, 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(deployment, deployment.credentialBindings),
+            shouldAssert: false,
+        });
+        fragment = {
+            nodeId: args.callId,
+            preservesInputItems: true,
+            nodes: [request],
+            entry: request,
+            exit: request,
+            inputPorts: { main: 0 },
+            outputPorts: { main: 0 },
+        };
+    }
+    fragment = createHttpResponseDecoder({ fragment, method: contract.method });
+    if (deployment.pendingFields.length ||
+        authentication?.credentialRequirements) {
+        const notes = [
+            ...(deployment.pendingFields.length
+                ? [createRequestDeploymentNotes(contract.key.documentId, deployment)]
+                : []),
+            ...(authentication?.credentialRequirements
+                ? [authentication.credentialRequirements]
+                : []),
+        ].join('\n');
+        for (const requestNode of fragment.nodes) {
+            requestNode.config.notes = notes;
+            requestNode.config.notesInFlow = true;
+        }
+    }
+    return fragment;
+}

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/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,56 @@
+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';
+/** 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: `Request ${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)));
+}