@openapi-flow/n8n 0.0.0-stage → 0.2.0

package/dist/nodes/native/create-response-collection-capability.js

@@ -0,0 +1,132 @@
+import { node } from '@n8n/workflow-sdk';
+import { readFileSync } from 'node:fs';
+import { createResponseValueSchema } from '@openapi-flow/core';
+import { createResponseCollectionParametersSchema } from '../../schemas/response-collection-schema.js';
+import { createOutputReaderCode } from '../request/bindings/create-output-reader-code.js';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+export function createResponseCollectionCapability(input) {
+    const materials = new Map(input.materials.map((material) => [material.callId, material]));
+    if (!materials.size ||
+        materials.size !== input.materials.length ||
+        input.materials.some((material) => !material.callId.trim()))
+        throw new Error('response collection capability requires unique API materials');
+    const parametersSchema = createResponseCollectionParametersSchema([
+        ...materials.keys(),
+    ]);
+    function source(parameters) {
+        const material = materials.get(parameters.sourceNodeId);
+        if (!material)
+            throw new Error(`response collection: unknown sourceNodeId ${parameters.sourceNodeId}`);
+        createResponseValueSchema(material.operation, parameters.pointer);
+        return material;
+    }
+    return {
+        name: 'collect-api-responses',
+        description: 'Collect unchanged item-linked API response values from one incoming stream into {items: values} using n8n Aggregate. Validates each full OAS response first. Preserves null, nested arrays, duplicates and received order. Not a branch join. Empty streams do not trigger this node or create an artificial result.',
+        parametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: (values) => {
+            const parameters = parametersSchema.parse(values);
+            source(parameters);
+            return [
+                {
+                    source: 'response',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            ];
+        },
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        outputSchema: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return {
+                type: 'object',
+                properties: {
+                    items: {
+                        type: 'array',
+                        items: createResponseValueSchema(source(parameters).operation, parameters.pointer),
+                    },
+                },
+                required: ['items'],
+                additionalProperties: false,
+            };
+        },
+        compile: ({ planned, position, apiNodeNames }) => {
+            const parameters = parametersSchema.parse(planned.parameters);
+            const material = source(parameters);
+            if (!Object.hasOwn(apiNodeNames, material.callId) ||
+                !apiNodeNames[material.callId].trim())
+                throw new Error(`apiNodeNames is missing ${material.callId}`);
+            const runtime = readFileSync(new URL('../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+            const read = createOutputReaderCode([
+                {
+                    kind: 'api-response',
+                    nodeId: material.callId,
+                    nodeName: apiNodeNames[material.callId],
+                    operation: material.operation,
+                },
+            ], true);
+            const extract = node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: `${planned.id}-read-values`,
+                    name: `Read values ${planned.id}`,
+                    position,
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        jsCode: `${runtime}\nconst parameters=${javascriptJsonLiteral(parameters)};\nreturn $input.all().map((_,inputIndex)=>{${read}\nconst value=OpenApiFlowRequestRuntime.pointerValue(responses[parameters.sourceNodeId],parameters.pointer);if(value===undefined)throw new Error('Missing response pointer '+parameters.sourceNodeId+parameters.pointer);return {json:{value},pairedItem:{item:inputIndex}};});`,
+                    },
+                },
+            });
+            const aggregate = node({
+                type: 'n8n-nodes-base.aggregate',
+                version: 1,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position: [position[0] + 220, position[1]],
+                    parameters: {
+                        aggregate: 'aggregateIndividualFields',
+                        fieldsToAggregate: {
+                            fieldToAggregate: [
+                                {
+                                    fieldToAggregate: 'value',
+                                    renameField: true,
+                                    outputFieldName: 'items',
+                                },
+                            ],
+                        },
+                        options: {
+                            disableDotNotation: true,
+                            mergeLists: false,
+                            keepMissing: true,
+                            includeBinaries: false,
+                        },
+                    },
+                },
+            });
+            return {
+                nodeId: planned.id,
+                bindingSources: [
+                    {
+                        kind: 'api-response',
+                        nodeId: material.callId,
+                        nodeName: apiNodeNames[material.callId],
+                        operation: material.operation,
+                    },
+                ],
+                nodes: [extract, aggregate],
+                entry: extract,
+                exit: aggregate,
+                inputPorts: { main: 0 },
+                outputPorts: { main: 0 },
+                internalEdges: [
+                    { from: extract.id, output: 0, to: aggregate.id, input: 0 },
+                ],
+            };
+        },
+    };
+}

package/dist/nodes/native/if-capability.d.ts

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

package/dist/nodes/native/if-capability.js

@@ -0,0 +1,76 @@
+import { node } from '@n8n/workflow-sdk';
+import { ifParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createIfPlanningParametersSchema } from '../../schemas/create-native-comparison-planning-schema.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+import { responseReferences } from './common/response-references.js';
+import { conditionExpression } from './response-check-code.js';
+import { createResponseCheckReader } from './response-checks/create-response-check-reader.js';
+import { createResponseCheckGuard } from './response-checks/create-response-check-guard.js';
+export function createIfCapability(input = {}) {
+    return {
+        name: 'if',
+        description: 'n8n IF: main input; true and false OUTPUT PORTS are mutually exclusive. Multiple edges from the SAME port all execute (fan-out) and can be joined. Type-strict declarative conditions.',
+        parametersSchema: ifParametersSchema,
+        createPlanningParametersSchema: createIfPlanningParametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['true', 'false'],
+        responseReferences: (parameters) => responseReferences(ifParametersSchema.parse(parameters).conditions),
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: true,
+        compile: ({ planned, apiNodeNames, apiResponseContracts, position }) => {
+            const parameters = ifParametersSchema.parse(planned.parameters);
+            const reader = createResponseCheckReader({
+                nodeId: planned.id,
+                checks: parameters.conditions,
+                apiNodeNames,
+                apiResponseContracts,
+                linked: input.itemMode === 'linked',
+            });
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.if',
+                version: 2.2,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        conditions: {
+                            options: {
+                                caseSensitive: true,
+                                leftValue: '',
+                                typeValidation: 'strict',
+                                version: 2,
+                            },
+                            conditions: parameters.conditions.map((check, index) => ({
+                                id: `${planned.id}-${index}`,
+                                leftValue: conditionExpression(check, apiNodeNames, input.itemMode === 'linked'),
+                                rightValue: true,
+                                operator: { type: 'boolean', operation: 'equals' },
+                            })),
+                            combinator: parameters.combinator,
+                        },
+                        options: {},
+                    },
+                },
+            }), ['main'], ['true', 'false']);
+            const partition = { ...fragment, partitionsInputItems: true };
+            if (!reader.bindingSources.length)
+                return partition;
+            const guard = createResponseCheckGuard({
+                nodeId: planned.id,
+                readerCode: reader.code,
+                linked: input.itemMode === 'linked',
+                position,
+            });
+            return {
+                ...partition,
+                entry: guard,
+                nodes: [guard, ...fragment.nodes],
+                internalEdges: [
+                    { from: guard.id, output: 0, to: fragment.entry.id, input: 0 },
+                ],
+                bindingSources: reader.bindingSources,
+            };
+        },
+    };
+}

package/dist/nodes/native/item-join/create-item-join-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+import type { CreateItemJoinCapabilityInput } from '../../../types/item-join.js';
+export declare function createItemJoinCapability({ materials, scopes, }: CreateItemJoinCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/item-join/create-item-join-capability.js

@@ -0,0 +1,153 @@
+import { node } from '@n8n/workflow-sdk';
+import { readFileSync } from 'node:fs';
+import { createResponseValueSchema } from '@openapi-flow/core';
+import { createItemJoinParametersSchema } from '../../../schemas/item-join-schema.js';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+import { createItemJoinReaderCode } from './create-item-join-reader-code.js';
+export function createItemJoinCapability({ materials, scopes, }) {
+    const apis = new Map(materials.map((material) => [material.callId, material]));
+    const scopeById = new Map(scopes.map((scope) => [scope.nodeId, scope]));
+    if (apis.size !== materials.length ||
+        materials.some((material) => !material.callId.trim()))
+        throw new Error('item join materials require unique non-empty callIds');
+    if (scopeById.size !== scopes.length ||
+        scopes.some((scope) => !scope.nodeId.trim() || !scope.nodeName.trim()))
+        throw new Error('item join scopes require unique non-empty identities and compiled names');
+    const parametersSchema = createItemJoinParametersSchema([...scopeById.keys()], [...apis.keys()]);
+    const ports = (count) => Array.from({ length: count }, (_, i) => `input${i + 1}`);
+    return {
+        name: 'join-api-items',
+        description: 'Join API branches by their shared native scope item ancestry. Each participating item requires exactly one full OAS-valid response per API. Different orders and duplicate JSON values are safe. Missing/duplicate branch responses fail; no business-ID matching, index zip, Cartesian product or value conversion. Output {responses: {callId: unchangedBody}}.',
+        parametersSchema,
+        inputPorts: (values) => ports(parametersSchema.parse(values).sourceCallIds.length),
+        outputPorts: () => ['main'],
+        responseReferences: (values) => parametersSchema.parse(values).sourceCallIds.map((nodeId) => ({
+            source: 'response',
+            nodeId,
+            pointer: '',
+        })),
+        nodeOutputReferences: (values) => [
+            {
+                source: 'node-output',
+                nodeId: parametersSchema.parse(values).scopeNodeId,
+                pointer: '',
+            },
+        ],
+        inputReferences: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return Object.fromEntries(parameters.sourceCallIds.map((nodeId, i) => [
+                `input${i + 1}`,
+                [
+                    { source: 'response', nodeId, pointer: '' },
+                    {
+                        source: 'node-output',
+                        nodeId: parameters.scopeNodeId,
+                        pointer: '',
+                    },
+                ],
+            ]));
+        },
+        waitsForAllInputs: true,
+        exclusiveOutputPorts: false,
+        outputSchema: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return {
+                type: 'object',
+                required: ['responses'],
+                additionalProperties: false,
+                properties: {
+                    responses: {
+                        type: 'object',
+                        additionalProperties: false,
+                        required: parameters.sourceCallIds,
+                        properties: Object.fromEntries(parameters.sourceCallIds.map((id) => [
+                            id,
+                            createResponseValueSchema(apis.get(id).operation, ''),
+                        ])),
+                    },
+                },
+            };
+        },
+        compile: ({ planned, position, apiNodeNames }) => {
+            const parameters = parametersSchema.parse(planned.parameters);
+            const scope = scopeById.get(parameters.scopeNodeId);
+            const bindingSources = [
+                { ...scope, kind: 'native-json' },
+                ...parameters.sourceCallIds.map((id) => {
+                    if (!Object.hasOwn(apiNodeNames, id) || !apiNodeNames[id].trim())
+                        throw new Error(`item join apiNodeNames is missing ${id}`);
+                    return {
+                        kind: 'api-response',
+                        nodeId: id,
+                        nodeName: apiNodeNames[id],
+                        operation: apis.get(id).operation,
+                    };
+                }),
+            ];
+            const readers = parameters.sourceCallIds.map((id, index) => node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: `${planned.id}-read-${index}`,
+                    name: `Read branch ${index + 1} ${planned.id}`,
+                    position: [position[0], position[1] + index * 180],
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        jsCode: createItemJoinReaderCode({
+                            scope,
+                            sourceCallId: id,
+                            sources: [bindingSources[0], bindingSources[index + 1]],
+                        }),
+                    },
+                },
+            }));
+            const merge = node({
+                type: 'n8n-nodes-base.merge',
+                version: 3.2,
+                config: {
+                    id: `${planned.id}-wait`,
+                    name: `Wait branches ${planned.id}`,
+                    position: [position[0] + 220, position[1]],
+                    parameters: { mode: 'append', numberInputs: readers.length },
+                },
+            });
+            const runtime = readFileSync(new URL('./runtime/item-join-runtime.bundle.js', import.meta.url), 'utf8');
+            const joined = node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position: [position[0] + 440, position[1]],
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        jsCode: `${runtime}\nreturn OpenApiFlowItemJoinRuntime.joinApiItems({items:$input.all(),sourceCallIds:${javascriptJsonLiteral(parameters.sourceCallIds)}});`,
+                    },
+                },
+            });
+            return {
+                nodeId: planned.id,
+                joinsInputItemsByAncestry: { scopeNodeId: parameters.scopeNodeId },
+                nodes: [...readers, merge, joined],
+                entry: readers[0],
+                exit: joined,
+                inputPorts: Object.fromEntries(ports(readers.length).map((port) => [port, 0])),
+                inputEndpoints: Object.fromEntries(readers.map((reader, i) => [
+                    `input${i + 1}`,
+                    { nodeId: reader.id, input: 0 },
+                ])),
+                outputPorts: { main: 0 },
+                bindingSources,
+                internalEdges: [
+                    ...readers.map((reader, index) => ({
+                        from: reader.id,
+                        output: 0,
+                        to: merge.id,
+                        input: index,
+                    })),
+                    { from: merge.id, output: 0, to: joined.id, input: 0 },
+                ],
+            };
+        },
+    };
+}

package/dist/nodes/native/item-join/create-item-join-reader-code.d.ts

@@ -0,0 +1,2 @@
+import type { CreateItemJoinReaderCodeInput } from '../../../types/item-join.js';
+export declare function createItemJoinReaderCode({ scope, sourceCallId, sources, }: CreateItemJoinReaderCodeInput): string;

package/dist/nodes/native/item-join/create-item-join-reader-code.js

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+import { createOutputReaderCode } from '../../request/bindings/create-output-reader-code.js';
+export function createItemJoinReaderCode({ scope, sourceCallId, sources, }) {
+    const runtime = readFileSync(new URL('../../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    const read = createOutputReaderCode(sources, true);
+    return `${runtime}
+const scopeName=${javascriptJsonLiteral(scope.nodeName)};
+const sourceCallId=${javascriptJsonLiteral(sourceCallId)};
+const scopeItems=$(scopeName).all();
+return $input.all().map((_,inputIndex)=>{
+${read}
+const ancestor=$(scopeName).itemMatching(inputIndex);
+const matches=scopeItems.flatMap((item,index)=>item===ancestor?[index]:[]);
+if(matches.length!==1)throw new Error('Item join '+sourceCallId+': scope ancestry must identify exactly one item in the current scope execution');
+return {json:{scopeIndex:matches[0],sourceCallId,response:responses[sourceCallId]},pairedItem:{item:inputIndex}};
+});`;
+}

package/dist/nodes/native/item-join/runtime/item-join-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 OpenApiFlowItemJoinRuntime;
+(()=>{function r({items:p,sourceCallIds:i}){if(i.length<2||new Set(i).size!==i.length)throw new Error("item join requires unique sourceCallIds");let s=new Map;for(let[n,o]of p.entries()){let e=o.json;if(!e||!Number.isInteger(e.scopeIndex)||e.scopeIndex<0)throw new Error(`item join input ${n}: scopeIndex is missing or invalid`);if(!i.includes(e.sourceCallId))throw new Error(`item join input ${n}: unknown sourceCallId ${e.sourceCallId}`);if(!Object.hasOwn(e,"response")||e.response===void 0)throw new Error(`item join input ${n}: response is missing`);let t=s.get(e.scopeIndex);if(t||(t={values:new Map,inputIndexes:[]},s.set(e.scopeIndex,t)),t.values.has(e.sourceCallId))throw new Error(`item join scope item ${e.scopeIndex}: duplicate response ${e.sourceCallId}`);t.values.set(e.sourceCallId,e.response),t.inputIndexes.push(n)}for(let[n,o]of s)for(let e of i)if(!o.values.has(e))throw new Error(`item join scope item ${n}: missing response ${e}`);return[...s].sort(([n],[o])=>n-o).map(([,n])=>({json:{responses:Object.fromEntries(i.map(o=>[o,n.values.get(o)]))},pairedItem:n.inputIndexes.map(o=>({item:o}))}))}OpenApiFlowItemJoinRuntime={joinApiItems:r};})();

package/dist/nodes/native/item-join/runtime/join-api-items.d.ts

@@ -0,0 +1,3 @@
+import type { ItemJoinOutputItem, JoinApiItemsInput } from '../../../../types/item-join.js';
+/** Join only reader-attested ancestry, never JSON business fields or stream positions. */
+export declare function joinApiItems({ items, sourceCallIds, }: JoinApiItemsInput): ItemJoinOutputItem[];

package/dist/nodes/native/item-join/runtime/join-api-items.js

@@ -0,0 +1,37 @@
+/** Join only reader-attested ancestry, never JSON business fields or stream positions. */
+export function joinApiItems({ items, sourceCallIds, }) {
+    if (sourceCallIds.length < 2 ||
+        new Set(sourceCallIds).size !== sourceCallIds.length)
+        throw new Error('item join requires unique sourceCallIds');
+    const groups = new Map();
+    for (const [inputIndex, item] of items.entries()) {
+        const row = item.json;
+        if (!row || !Number.isInteger(row.scopeIndex) || row.scopeIndex < 0)
+            throw new Error(`item join input ${inputIndex}: scopeIndex is missing or invalid`);
+        if (!sourceCallIds.includes(row.sourceCallId))
+            throw new Error(`item join input ${inputIndex}: unknown sourceCallId ${row.sourceCallId}`);
+        if (!Object.hasOwn(row, 'response') || row.response === undefined)
+            throw new Error(`item join input ${inputIndex}: response is missing`);
+        let group = groups.get(row.scopeIndex);
+        if (!group) {
+            group = { values: new Map(), inputIndexes: [] };
+            groups.set(row.scopeIndex, group);
+        }
+        if (group.values.has(row.sourceCallId))
+            throw new Error(`item join scope item ${row.scopeIndex}: duplicate response ${row.sourceCallId}`);
+        group.values.set(row.sourceCallId, row.response);
+        group.inputIndexes.push(inputIndex);
+    }
+    for (const [scopeIndex, group] of groups)
+        for (const id of sourceCallIds)
+            if (!group.values.has(id))
+                throw new Error(`item join scope item ${scopeIndex}: missing response ${id}`);
+    return [...groups]
+        .sort(([left], [right]) => left - right)
+        .map(([, group]) => ({
+        json: {
+            responses: Object.fromEntries(sourceCallIds.map((id) => [id, group.values.get(id)])),
+        },
+        pairedItem: group.inputIndexes.map((item) => ({ item })),
+    }));
+}

package/dist/nodes/native/merge-append-capability.d.ts

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

package/dist/nodes/native/merge-append-capability.js

@@ -0,0 +1,31 @@
+import { node } from '@n8n/workflow-sdk';
+import { mergeParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+export function createMergeAppendCapability() {
+    return {
+        name: 'merge-append',
+        description: 'n8n Merge append: input1..inputN; main output. Waits for all independent incoming branches.',
+        parametersSchema: mergeParametersSchema,
+        inputPorts: (parameters) => Array.from({ length: mergeParametersSchema.parse(parameters).numberInputs }, (_, index) => `input${index + 1}`),
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        waitsForAllInputs: true,
+        exclusiveOutputPorts: false,
+        compile: ({ planned, position }) => {
+            const parameters = mergeParametersSchema.parse(planned.parameters);
+            return createNativeFragment(node({
+                type: 'n8n-nodes-base.merge',
+                version: 3.2,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        mode: 'append',
+                        numberInputs: parameters.numberInputs,
+                    },
+                },
+            }), Array.from({ length: parameters.numberInputs }, (_, index) => `input${index + 1}`), ['main']);
+        },
+    };
+}

package/dist/nodes/native/response-assertion-capability.d.ts

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

package/dist/nodes/native/response-assertion-capability.js

@@ -0,0 +1,53 @@
+import { node } from '@n8n/workflow-sdk';
+import { assertionParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createAssertionPlanningParametersSchema } from '../../schemas/create-native-comparison-planning-schema.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+import { responseReferences } from './common/response-references.js';
+import { responseCheckCode } from './response-check-code.js';
+import { createResponseCheckReader } from './response-checks/create-response-check-reader.js';
+export function createResponseAssertionCapability(input = {}) {
+    return {
+        name: 'assert-responses',
+        description: 'n8n Code: library-generated JSON comparisons. main input/output. Returns pass/assertionCount on success and can be the final node; no separate success/end node is needed. Failed checks throw their message and fail the workflow, without a failure output port. Join branches before comparing their responses.',
+        parametersSchema: assertionParametersSchema,
+        createPlanningParametersSchema: createAssertionPlanningParametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: (parameters) => responseReferences(assertionParametersSchema.parse(parameters).checks),
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        compile: ({ planned, apiNodeNames, apiResponseContracts, position }) => {
+            const parameters = assertionParametersSchema.parse(planned.parameters);
+            const reader = createResponseCheckReader({
+                nodeId: planned.id,
+                checks: parameters.checks,
+                apiNodeNames,
+                apiResponseContracts,
+                linked: input.itemMode === 'linked',
+            });
+            const checkCode = `${responseCheckCode(reader.code)}\nconst checks = ${JSON.stringify(parameters.checks)};\nfor (const check of checks) if (!compare(check)) throw new Error(check.message);`;
+            const code = input.itemMode === 'linked'
+                ? `return $input.all().map((_,inputIndex)=>{${checkCode}\nreturn {json:{pass:true,assertionCount:checks.length},pairedItem:{item:inputIndex}};});`
+                : `${checkCode}\nreturn [{json: {pass: true, assertionCount: checks.length}}];`;
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.code',
+                version: 2,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        mode: 'runOnceForAllItems',
+                        language: 'javaScript',
+                        jsCode: code,
+                    },
+                },
+            }), ['main'], ['main']);
+            return {
+                ...fragment,
+                preservesInputItems: input.itemMode === 'linked',
+                bindingSources: reader.bindingSources,
+            };
+        },
+    };
+}

package/dist/nodes/native/response-check-code.d.ts

@@ -0,0 +1,3 @@
+import type { NativeCheck } from '../../types/native-capability.js';
+export declare function responseCheckCode(responseReaderCode: string): string;
+export declare function conditionExpression(check: NativeCheck, names: Record<string, string>, linked?: boolean): string;

package/dist/nodes/native/response-check-code.js

@@ -0,0 +1,59 @@
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+import { responseReferences } from './common/response-references.js';
+/** Library-owned runtime, shared by IF expressions and assertion Code nodes. */
+function responseCheckRuntime() {
+    return `
+function read(operand) {
+  if (operand.source === 'literal') return operand.value;
+  if (!Object.hasOwn(responses, operand.nodeId) || responses[operand.nodeId] === undefined)
+    throw new Error('Missing response body: ' + operand.nodeId);
+  let value = responses[operand.nodeId];
+  if (operand.pointer === '') return value;
+  for (const encoded of operand.pointer.slice(1).split('/')) {
+    const key = encoded.replace(/~1/g, '/').replace(/~0/g, '~');
+    if (value === null || typeof value !== 'object' || !Object.hasOwn(value, key))
+      throw new Error('Missing response pointer: ' + operand.nodeId + operand.pointer);
+    value = value[key];
+  }
+  return value;
+}
+function equal(a, b) {
+  if (a === b) return true;
+  if (a === null || b === null || typeof a !== 'object' || typeof b !== 'object') return false;
+  if (Array.isArray(a) !== Array.isArray(b)) return false;
+  const keys = Object.keys(a);
+  return keys.length === Object.keys(b).length && keys.every(key => Object.hasOwn(b, key) && equal(a[key], b[key]));
+}
+function compare(check) {
+  const left = read(check.left), right = read(check.right);
+  switch (check.operator) {
+    case 'equals': return equal(left, right);
+    case 'notEquals': return !equal(left, right);
+    case 'keysEqual':
+      if (left === null || right === null || typeof left !== 'object' || typeof right !== 'object' || Array.isArray(left) || Array.isArray(right))
+        throw new Error('keysEqual requires objects');
+      return equal(Object.keys(left).sort(), Object.keys(right).sort());
+    case 'greaterThan': case 'lessThan':
+      if (typeof left !== 'number' || typeof right !== 'number') throw new Error('Numeric comparison requires numbers');
+      return check.operator === 'greaterThan' ? left > right : left < right;
+    default: throw new Error('Unknown comparison operator');
+  }
+}`;
+}
+export function responseCheckCode(responseReaderCode) {
+    return `${responseReaderCode}\n${responseCheckRuntime()}`;
+}
+export function conditionExpression(check, names, linked = false) {
+    const declaredNames = Object.fromEntries(responseReferences([check]).map((ref) => [ref.nodeId, names[ref.nodeId]]));
+    // The preceding Code guard validates full responses. Keep IF expressions small.
+    const reader = `const names=${javascriptJsonLiteral(declaredNames)};
+const responses=Object.create(null);
+for (const id of Object.keys(names)) {
+  ${linked ? 'const envelope=$(names[id]).itemMatching(inputIndex);' : "const items=$(names[id]).all();if(items.length!==1)throw new Error('Response '+id+' requires an unambiguous single JSON item');const envelope=items[0];"}
+  if (!envelope || !envelope.json || !Object.hasOwn(envelope.json, 'body'))
+    throw new Error('Missing response body: '+id);
+  responses[id]=envelope.json.body;
+}
+`;
+    return `={{ (() => { ${linked ? 'const inputIndex=$itemIndex;' : ''}${responseCheckCode(reader)}; return compare(${javascriptJsonLiteral(check)}); })() }}`;
+}

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

@@ -0,0 +1,4 @@
+import type { CreateResponseCheckGuardInput } from '../../../types/response-check-guard.js';
+import type { N8nSdkNode } from '../../../types/node-fragment.js';
+/** Validate in Code, not inside n8n's expression-delimited IF parameter. */
+export declare function createResponseCheckGuard({ nodeId, readerCode, linked, position, }: CreateResponseCheckGuardInput): N8nSdkNode;

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

@@ -0,0 +1,22 @@
+import { node } from '@n8n/workflow-sdk';
+/** Validate in Code, not inside n8n's expression-delimited IF parameter. */
+export function createResponseCheckGuard({ nodeId, readerCode, linked, position, }) {
+    const forward = 'return {...item,pairedItem:{item:inputIndex}};';
+    const code = linked
+        ? `return $input.all().map((item,inputIndex)=>{${readerCode}\n${forward}});`
+        : `${readerCode}\nreturn $input.all().map((item,inputIndex)=>{${forward}});`;
+    return node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: `${nodeId}-response-contract`,
+            name: `Validate responses ${nodeId}`,
+            position: [position[0] - 220, position[1]],
+            parameters: {
+                mode: 'runOnceForAllItems',
+                language: 'javaScript',
+                jsCode: code,
+            },
+        },
+    });
+}