@openapi-flow/n8n 0.0.0-stage → 0.2.0

package/dist/legacy/workflow/request/sequence-url.js

@@ -0,0 +1,104 @@
+import { responseFieldSchemas, responseFieldType, } from '@openapi-flow/core/internal';
+import { checkSchemaValue } from '@openapi-flow/core/internal';
+import { serializePathParameter, serializeQueryParameter, } from '@openapi-flow/core/internal';
+import { UnsupportedOperationError } from '@openapi-flow/core/internal';
+import { isObject } from '@openapi-flow/core/internal';
+import { looksLikeCredential } from './credential-binding.js';
+import { absoluteOperationPath, makeUrl } from './request-url.js';
+export function sequenceUrl(operation, origin, inputs, previous, requiredOutputs, missing) {
+    let path = operation.path;
+    const references = new Map();
+    for (const parameter of operation.parameters) {
+        if (parameter.in !== 'path' && parameter.in !== 'query')
+            continue;
+        const key = parameter.in + '.' + parameter.name;
+        const value = inputs[key];
+        if (value === undefined) {
+            if (parameter.required)
+                missing.push(key);
+            continue;
+        }
+        if (isObject(value)) {
+            if (typeof value.fromStep !== 'string' ||
+                typeof value.field !== 'string' ||
+                Object.keys(value).length !== 2) {
+                throw new Error('plan.inputs.' + key + ' must have fromStep and field');
+            }
+            if (looksLikeCredential(value.field)) {
+                throw new Error('plan.inputs.' + key + ' references a credential-like response field');
+            }
+            const source = previous.get(value.fromStep);
+            if (!source || responseFieldSchemas(source, value.field).length === 0) {
+                throw new Error('plan.inputs.' + key + ' must reference a prior response field');
+            }
+            const sourceType = responseFieldType(source, value.field);
+            const targetType = typeof parameter.schema === 'object'
+                ? parameter.schema.type
+                : undefined;
+            if ((parameter.in === 'path' && parameter.style !== 'simple') ||
+                (parameter.in === 'query' && parameter.style !== 'form') ||
+                parameter.contentMediaType !== undefined ||
+                parameter.allowReserved ||
+                !['string', 'number', 'integer', 'boolean'].includes(String(targetType)))
+                throw new UnsupportedOperationError(operation.operationRef, `operationRef ${operation.operationRef} parameter ${key} cannot serialize a sequence response reference`);
+            if (sourceType !== targetType &&
+                !(sourceType === 'integer' && targetType === 'number')) {
+                throw new Error('plan.inputs.' + key + ' has a response type mismatch');
+            }
+            const required = requiredOutputs.get(value.fromStep) ?? new Set();
+            required.add(value.field);
+            requiredOutputs.set(value.fromStep, required);
+            references.set(key, '$node[' +
+                JSON.stringify('Request ' + value.fromStep) +
+                '].json.body[' +
+                JSON.stringify(value.field) +
+                ']');
+        }
+        else {
+            checkSchemaValue(value, parameter.schema, 'plan.inputs.' + key);
+            if (parameter.in === 'path')
+                path = path.replace('{' + parameter.name + '}', serializePathParameter(parameter, operation.operationRef, value));
+        }
+    }
+    if (missing.length)
+        return '';
+    if (references.size === 0)
+        return makeUrl(operation, origin, inputs, []);
+    const absolute = absoluteOperationPath(origin, path);
+    const parts = [];
+    let offset = 0;
+    for (const match of absolute.matchAll(/\{([^}]+)\}/g)) {
+        const key = 'path.' + match[1];
+        const reference = references.get(key);
+        if (!reference)
+            throw new Error('plan.inputs.' + key + ' is required');
+        parts.push(JSON.stringify(absolute.slice(offset, match.index)), 'encodeURIComponent(' + reference + ')');
+        offset = match.index + match[0].length;
+    }
+    parts.push(JSON.stringify(absolute.slice(offset)));
+    let expression = parts.join(' + ');
+    let firstQuery = true;
+    for (const parameter of operation.parameters) {
+        if (parameter.in !== 'query' ||
+            inputs['query.' + parameter.name] === undefined)
+            continue;
+        const key = 'query.' + parameter.name;
+        const reference = references.get(key);
+        if (reference) {
+            expression +=
+                ' + ' +
+                    JSON.stringify((firstQuery ? '?' : '&') + encodeURIComponent(parameter.name) + '=') +
+                    ' + encodeURIComponent(' +
+                    reference +
+                    ')';
+        }
+        else {
+            expression +=
+                ' + ' +
+                    JSON.stringify((firstQuery ? '?' : '&') +
+                        serializeQueryParameter(parameter, operation.operationRef, inputs[key]).join('&'));
+        }
+        firstQuery = false;
+    }
+    return '={{ ' + expression + ' }}';
+}

package/dist/legacy-api.d.ts

@@ -0,0 +1,25 @@
+export * from './legacy/workflow/common/plan-validation.js';
+export * from './legacy/workflow/common/workflow-id.js';
+export * from './legacy/workflow/inbound/build-inbound-workflow.js';
+export * from './legacy/workflow/inbound/compile-inbound-workflow.js';
+export * from './legacy/workflow/inbound/inbound-response.js';
+export * from './legacy/workflow/request/base-url.js';
+export * from './legacy/workflow/request/build-request-workflow.js';
+export * from './legacy/workflow/request/build-sequence-workflow.js';
+export * from './legacy/workflow/request/compile-catalog-sequence.js';
+export * from './legacy/workflow/request/compile-sequence.js';
+export * from './legacy/workflow/request/compile-workflow.js';
+export * from './legacy/workflow/request/credential-binding.js';
+export * from './legacy/workflow/request/effect-policy.js';
+export * from './legacy/workflow/request/http-request-node.js';
+export * from './legacy/workflow/request/prepare-sequence.js';
+export * from './legacy/workflow/request/request-body.js';
+export * from './legacy/workflow/request/request-headers.js';
+export * from './legacy/workflow/request/request-url.js';
+export * from './legacy/workflow/request/response-assertion-code.js';
+export * from './legacy/workflow/request/sequence-url.js';
+export type * from './types/legacy/catalog-workflow.js';
+export type * from './types/legacy/inbound-workflow.js';
+export type * from './types/legacy/request-node.js';
+export type * from './types/legacy/request-workflow.js';
+export type * from './types/legacy/sequence-workflow.js';

package/dist/legacy-api.js

@@ -0,0 +1,20 @@
+export * from './legacy/workflow/common/plan-validation.js';
+export * from './legacy/workflow/common/workflow-id.js';
+export * from './legacy/workflow/inbound/build-inbound-workflow.js';
+export * from './legacy/workflow/inbound/compile-inbound-workflow.js';
+export * from './legacy/workflow/inbound/inbound-response.js';
+export * from './legacy/workflow/request/base-url.js';
+export * from './legacy/workflow/request/build-request-workflow.js';
+export * from './legacy/workflow/request/build-sequence-workflow.js';
+export * from './legacy/workflow/request/compile-catalog-sequence.js';
+export * from './legacy/workflow/request/compile-sequence.js';
+export * from './legacy/workflow/request/compile-workflow.js';
+export * from './legacy/workflow/request/credential-binding.js';
+export * from './legacy/workflow/request/effect-policy.js';
+export * from './legacy/workflow/request/http-request-node.js';
+export * from './legacy/workflow/request/prepare-sequence.js';
+export * from './legacy/workflow/request/request-body.js';
+export * from './legacy/workflow/request/request-headers.js';
+export * from './legacy/workflow/request/request-url.js';
+export * from './legacy/workflow/request/response-assertion-code.js';
+export * from './legacy/workflow/request/sequence-url.js';

package/dist/nodes/common/validation/compile-standalone-validator.d.ts

@@ -0,0 +1,3 @@
+import type { CompileStandaloneValidatorInput } from '../../../types/schema-compilation.js';
+/** Compile on the host; generated n8n nodes receive validators, not eval. */
+export declare function compileStandaloneValidator({ schema, globalName, }: CompileStandaloneValidatorInput): string;

package/dist/nodes/common/validation/compile-standalone-validator.js

@@ -0,0 +1,44 @@
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import { _ } from 'ajv/dist/compile/codegen/index.js';
+import addFormats from 'ajv-formats';
+import standaloneCode from 'ajv/dist/standalone/index.js';
+import { buildSync } from 'esbuild';
+import { createRequire } from 'node:module';
+import { dirname } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { bundledLicenseBanner } from '../../../utils/bundled-license-banner.js';
+/** Compile on the host; generated n8n nodes receive validators, not eval. */
+export function compileStandaloneValidator({ schema, globalName, }) {
+    const ajv = new Ajv2020({
+        strict: false,
+        allErrors: true,
+        discriminator: true,
+        code: {
+            source: true,
+            // Own the standalone format expression with this compiler's Code class.
+            formats: _ `require("ajv-formats/dist/formats").fullFormats`,
+        },
+    });
+    addFormats.default(ajv);
+    const compiled = standaloneCode.default(ajv, ajv.compile(schema));
+    const built = buildSync({
+        stdin: { contents: compiled, resolveDir: import.meta.dirname },
+        bundle: true,
+        platform: 'browser',
+        format: 'iife',
+        globalName,
+        target: 'es2022',
+        minify: true,
+        write: false,
+        legalComments: 'inline',
+        metafile: true,
+        // Standard keywords stay intact. JSON equality must not inspect constructors.
+        alias: {
+            'ajv/dist/runtime/equal': fileURLToPath(new URL('../../../utils/json-values-equal.cjs', import.meta.url)),
+        },
+    });
+    const require = createRequire(import.meta.url);
+    return (bundledLicenseBanner(built.metafile, [
+        dirname(require.resolve('ajv/package.json')),
+    ]) + built.outputFiles[0].text);
+}

package/dist/nodes/gap/create-gap-node.d.ts

@@ -0,0 +1,3 @@
+import type { CreateGapNodeInput } from '../../types/reviewable-workflow.js';
+import type { N8nNodeFragment } from '../../types/node-fragment.js';
+export declare function createGapNode(input: CreateGapNodeInput): N8nNodeFragment;

package/dist/nodes/gap/create-gap-node.js

@@ -0,0 +1,35 @@
+import { node } from '@n8n/workflow-sdk';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+export function createGapNode(input) {
+    if (!input.nodeId.trim() || !input.gaps.length)
+        throw new Error('gap node requires an ID and reported gaps');
+    const message = 'OPENAPI_FLOW_UNRESOLVED_STEP ' +
+        input.nodeId +
+        ': ' +
+        input.gaps.map((gap) => gap.description).join('; ');
+    const placeholder = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: input.nodeId,
+            name: '확인 필요 · ' + input.nodeId,
+            position: input.position,
+            notes: '미해결 단계입니다. 실행하면 오류로 중단됩니다.',
+            notesInFlow: true,
+            onError: 'stopWorkflow',
+            parameters: {
+                mode: 'runOnceForAllItems',
+                language: 'javaScript',
+                jsCode: `throw new Error(${javascriptJsonLiteral(message)});`,
+            },
+        },
+    });
+    return {
+        nodeId: input.nodeId,
+        nodes: [placeholder],
+        entry: placeholder,
+        exit: placeholder,
+        inputPorts: { main: 0 },
+        outputPorts: { main: 0 },
+    };
+}

package/dist/nodes/native/arrays/create-array-node-fragment.d.ts

@@ -0,0 +1,4 @@
+import type { CreateArrayNodeFragmentInput } from '../../../types/array-split.js';
+import type { N8nNodeFragment } from '../../../types/node-fragment.js';
+/** Share SDK array mechanics without merging API and native source contracts. */
+export declare function createArrayNodeFragment({ planned, position, source, parameters, linked, }: CreateArrayNodeFragmentInput): N8nNodeFragment;

package/dist/nodes/native/arrays/create-array-node-fragment.js

@@ -0,0 +1,42 @@
+import { node } from '@n8n/workflow-sdk';
+import { createArrayReaderCode } from './create-array-reader-code.js';
+/** Share SDK array mechanics without merging API and native source contracts. */
+export function createArrayNodeFragment({ planned, position, source, parameters, linked, }) {
+    const extract = node({
+        type: 'n8n-nodes-base.code',
+        version: 2,
+        config: {
+            id: `${planned.id}-read-array`,
+            name: `Read array ${planned.id}`,
+            position,
+            parameters: {
+                mode: 'runOnceForAllItems',
+                jsCode: createArrayReaderCode(source, parameters, linked),
+            },
+        },
+    });
+    const split = node({
+        type: 'n8n-nodes-base.splitOut',
+        version: 1,
+        config: {
+            id: planned.id,
+            name: planned.id,
+            position: [position[0] + 220, position[1]],
+            parameters: {
+                fieldToSplitOut: 'items',
+                include: 'noOtherFields',
+                options: { destinationFieldName: 'item', disableDotNotation: true },
+            },
+        },
+    });
+    return {
+        nodeId: planned.id,
+        bindingSources: [source],
+        nodes: [extract, split],
+        entry: extract,
+        exit: split,
+        inputPorts: { main: 0 },
+        outputPorts: { main: 0 },
+        internalEdges: [{ from: extract.id, output: 0, to: split.id, input: 0 }],
+    };
+}

package/dist/nodes/native/arrays/create-array-reader-code.d.ts

@@ -0,0 +1,3 @@
+import type { N8nOutputBindingSource } from '../../../types/output-binding-source.js';
+import type { ArraySplitParameters } from '../../../types/array-split.js';
+export declare function createArrayReaderCode(source: N8nOutputBindingSource, parameters: ArraySplitParameters, linked: boolean): string;

package/dist/nodes/native/arrays/create-array-reader-code.js

@@ -0,0 +1,12 @@
+import { readFileSync } from 'node:fs';
+import { createOutputReaderCode } from '../../request/bindings/create-output-reader-code.js';
+import { javascriptJsonLiteral } from '../../../utils/javascript-json-literal.js';
+export function createArrayReaderCode(source, parameters, linked) {
+    const runtime = readFileSync(new URL('../../request/runtime/request-runtime.bundle.js', import.meta.url), 'utf8');
+    const read = createOutputReaderCode([source], linked);
+    const extract = `${read}\nconst parameters=${javascriptJsonLiteral(parameters)};\nconst array=OpenApiFlowRequestRuntime.pointerValue(responses[parameters.sourceNodeId],parameters.pointer);if(array===undefined)throw new Error('Missing array pointer '+parameters.sourceNodeId+parameters.pointer);if(!Array.isArray(array))throw new Error('Output '+parameters.sourceNodeId+parameters.pointer+' must be an array');`;
+    const iteration = linked
+        ? `return inputItems.map((_,inputIndex)=>{${extract}\nreturn {json:{items:array},pairedItem:{item:inputIndex}};});`
+        : `if(inputItems.length!==1)throw new Error('Array extraction requires one input item; got '+inputItems.length);\n${extract}\nreturn [{json:{items:array},pairedItem:{item:0}}];`;
+    return `${runtime}\nconst inputItems=$input.all();\n${iteration}`;
+}

package/dist/nodes/native/arrays/create-native-array-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../../types/native-capability.js';
+import type { CreateNativeArrayCapabilityInput } from '../../../types/native-array.js';
+export declare function createNativeArrayCapability(input: CreateNativeArrayCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/arrays/create-native-array-capability.js

@@ -0,0 +1,64 @@
+import { createNativeArrayItemSchema, validateNativeOutputContracts, } from '@openapi-flow/core';
+import { createNativeArrayParametersSchema } from '../../../schemas/native-array-schema.js';
+import { createArrayNodeFragment } from './create-array-node-fragment.js';
+export function createNativeArrayCapability(input) {
+    if (input.itemMode !== undefined && input.itemMode !== 'linked')
+        throw new Error('native array capability: itemMode must be linked or omitted');
+    validateNativeOutputContracts(input.sources);
+    if (!input.sources.length ||
+        input.sources.some((source) => typeof source.nodeName !== 'string' || !source.nodeName.trim()))
+        throw new Error('native array capability requires sources with compiled names');
+    const sources = new Map(input.sources.map((source) => [source.nodeId, source]));
+    const parametersSchema = createNativeArrayParametersSchema([
+        ...sources.keys(),
+    ]);
+    function source(parameters) {
+        const output = sources.get(parameters.sourceNodeId);
+        if (!output)
+            throw new Error(`native array: unknown sourceNodeId ${parameters.sourceNodeId}`);
+        createNativeArrayItemSchema(output, parameters.pointer);
+        return { ...output, kind: 'native-json' };
+    }
+    return {
+        name: 'split-native-output-array',
+        description: 'Split a supplied native JSON output array into {item: unchangedElement} using official n8n Split Out. Validate the full native output schema first. Linked mode preserves parent ancestry across nested splits. Empty arrays emit no child items; never convert, flatten or fabricate values.',
+        parametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        nodeOutputReferences: (values) => {
+            const parameters = parametersSchema.parse(values);
+            source(parameters);
+            return [
+                {
+                    source: 'node-output',
+                    nodeId: parameters.sourceNodeId,
+                    pointer: parameters.pointer,
+                },
+            ];
+        },
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        outputSchema: (values) => {
+            const parameters = parametersSchema.parse(values);
+            return {
+                type: 'object',
+                properties: {
+                    item: createNativeArrayItemSchema(source(parameters), parameters.pointer),
+                },
+                required: ['item'],
+                additionalProperties: false,
+            };
+        },
+        compile: ({ planned, position }) => {
+            const parameters = parametersSchema.parse(planned.parameters);
+            return createArrayNodeFragment({
+                planned,
+                position,
+                source: source(parameters),
+                parameters,
+                linked: input.itemMode === 'linked',
+            });
+        },
+    };
+}

package/dist/nodes/native/common/create-native-fragment.d.ts

@@ -0,0 +1,2 @@
+import type { N8nNodeFragment, N8nSdkNode } from '../../../types/node-fragment.js';
+export declare function createNativeFragment(sdkNode: N8nSdkNode, inputs: string[], outputs: string[]): N8nNodeFragment;

package/dist/nodes/native/common/create-native-fragment.js

@@ -0,0 +1,10 @@
+export function createNativeFragment(sdkNode, inputs, outputs) {
+    return {
+        nodeId: sdkNode.id,
+        nodes: [sdkNode],
+        entry: sdkNode,
+        exit: sdkNode,
+        inputPorts: Object.fromEntries(inputs.map((port, index) => [port, index])),
+        outputPorts: Object.fromEntries(outputs.map((port, index) => [port, index])),
+    };
+}

package/dist/nodes/native/common/response-references.d.ts

@@ -0,0 +1,3 @@
+import type { WorkflowResponseReference } from '@openapi-flow/core';
+import type { NativeCheck } from '../../../types/native-capability.js';
+export declare function responseReferences(checks: NativeCheck[]): WorkflowResponseReference[];

package/dist/nodes/native/common/response-references.js

@@ -0,0 +1,5 @@
+export function responseReferences(checks) {
+    return checks
+        .flatMap((check) => [check.left, check.right])
+        .filter((operand) => operand.source === 'response');
+}

package/dist/nodes/native/create-exclusive-branch-merge-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+/** Separate semantic contract from the all-independent-inputs Merge capability. */
+export declare function createExclusiveBranchMergeCapability(): N8nNativeCapability;

package/dist/nodes/native/create-exclusive-branch-merge-capability.js

@@ -0,0 +1,33 @@
+import { node } from '@n8n/workflow-sdk';
+import { exclusiveBranchMergeParametersSchema } from '../../schemas/exclusive-branch-merge-schema.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+/** Separate semantic contract from the all-independent-inputs Merge capability. */
+export function createExclusiveBranchMergeCapability() {
+    return {
+        name: 'rejoin-exclusive-branches',
+        description: 'Rejoin both alternative paths of one supplied IF instance using official Merge append. input1 and input2 each cover a distinct true/false path. Preserves existing items and ancestry; never creates an empty completion item. Both paths must return, including a skip path when no business call is required.',
+        parametersSchema: exclusiveBranchMergeParametersSchema,
+        inputPorts: () => ['input1', 'input2'],
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        rejoinsExclusiveOutputs: (parameters) => exclusiveBranchMergeParametersSchema.parse(parameters).sourceNodeId,
+        compile: ({ planned, position }) => {
+            const { sourceNodeId } = exclusiveBranchMergeParametersSchema.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: 2 },
+                    },
+                }), ['input1', 'input2'], ['main']),
+                rejoinsExclusiveOutputs: sourceNodeId,
+            };
+        },
+    };
+}

package/dist/nodes/native/create-json-output-capability.d.ts

@@ -0,0 +1,3 @@
+import type { CreateJsonOutputCapabilityInput, N8nNativeCapability } from '../../types/native-capability.js';
+/** Explicit typed literals through Edit Fields JSON mode; no casts or mapping expressions. */
+export declare function createJsonOutputCapability(input: CreateJsonOutputCapabilityInput): N8nNativeCapability;

package/dist/nodes/native/create-json-output-capability.js

@@ -0,0 +1,38 @@
+import { node } from '@n8n/workflow-sdk';
+import { z } from 'zod';
+import { parseNativeNodeParameters } from '@openapi-flow/core';
+import { javascriptJsonLiteral } from '../../utils/javascript-json-literal.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+/** Explicit typed literals through Edit Fields JSON mode; no casts or mapping expressions. */
+export function createJsonOutputCapability(input) {
+    if (!input.name.trim() || !input.description.trim())
+        throw new Error('JSON output capability requires name and description');
+    const capability = {
+        ...input,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        outputSchema: () => z.toJSONSchema(input.parametersSchema, { io: 'output' }),
+        compile: ({ planned, position }) => {
+            const parameters = parseNativeNodeParameters(planned, capability);
+            return createNativeFragment(node({
+                type: 'n8n-nodes-base.set',
+                version: 3.4,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {
+                        mode: 'raw',
+                        jsonOutput: `={{ ${javascriptJsonLiteral(parameters)} }}`,
+                        includeOtherFields: false,
+                        options: { dotNotation: false },
+                    },
+                },
+            }), ['main'], ['main']);
+        },
+    };
+    return capability;
+}

package/dist/nodes/native/create-native-capabilities.d.ts

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

package/dist/nodes/native/create-native-capabilities.js

@@ -0,0 +1,14 @@
+import { createIfCapability } from './if-capability.js';
+import { createMergeAppendCapability } from './merge-append-capability.js';
+import { createResponseAssertionCapability } from './response-assertion-capability.js';
+import { createStopAndErrorCapability } from './stop-and-error-capability.js';
+export function createN8nNativeCapabilities(input = {}) {
+    if (input.itemMode !== undefined && input.itemMode !== 'linked')
+        throw new Error('native itemMode must be linked or omitted');
+    return [
+        createIfCapability(input),
+        createMergeAppendCapability(),
+        createResponseAssertionCapability(input),
+        createStopAndErrorCapability(),
+    ];
+}

package/dist/nodes/native/create-pass-through-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+/** An explicit identity step; never generate a request, value or completion item. */
+export declare function createPassThroughCapability(): N8nNativeCapability;

package/dist/nodes/native/create-pass-through-capability.js

@@ -0,0 +1,30 @@
+import { node } from '@n8n/workflow-sdk';
+import { passThroughParametersSchema } from '../../schemas/native-capability-schemas.js';
+import { createNativeFragment } from './common/create-native-fragment.js';
+/** An explicit identity step; never generate a request, value or completion item. */
+export function createPassThroughCapability() {
+    return {
+        name: 'pass-through',
+        description: 'n8n No Operation: forward all input items unchanged with their original links. Main input/output, no configuration or new data. Can provide a common entry before a fan-out. This does not merge branches, collect results or replace a missing API.',
+        parametersSchema: passThroughParametersSchema,
+        inputPorts: () => ['main'],
+        outputPorts: () => ['main'],
+        responseReferences: () => [],
+        waitsForAllInputs: false,
+        exclusiveOutputPorts: false,
+        compile: ({ planned, position }) => {
+            passThroughParametersSchema.parse(planned.parameters);
+            const fragment = createNativeFragment(node({
+                type: 'n8n-nodes-base.noOp',
+                version: 1,
+                config: {
+                    id: planned.id,
+                    name: planned.id,
+                    position,
+                    parameters: {},
+                },
+            }), ['main'], ['main']);
+            return { ...fragment, preservesInputItems: true };
+        },
+    };
+}

package/dist/nodes/native/create-response-array-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+import type { CreateResponseArrayCapabilityInput } from '../../types/array-iteration.js';
+export declare function createResponseArrayCapability(input: CreateResponseArrayCapabilityInput): N8nNativeCapability;

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

@@ -0,0 +1,73 @@
+import { createResponseArrayItemSchema } from '@openapi-flow/core';
+import { createResponseArrayParametersSchema } from '../../schemas/response-array-schema.js';
+import { createArrayNodeFragment } from './arrays/create-array-node-fragment.js';
+export function createResponseArrayCapability(input) {
+    if (input.itemMode !== undefined && input.itemMode !== 'linked')
+        throw new Error('response array capability: itemMode must be linked or omitted');
+    const linked = input.itemMode === 'linked';
+    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 array capability requires unique API materials');
+    const parametersSchema = createResponseArrayParametersSchema([
+        ...materials.keys(),
+    ]);
+    function source(parameters) {
+        const material = materials.get(parameters.sourceNodeId);
+        if (!material)
+            throw new Error(`response array: unknown sourceNodeId ${parameters.sourceNodeId}`);
+        createResponseArrayItemSchema(material.operation, parameters.pointer);
+        return material;
+    }
+    return {
+        name: 'split-api-response-array',
+        description: 'Split a declared OAS response array into one unchanged JSON item per element using n8n Split Out. Output is {item: element}. Downstream bound requests must use linked item mode. An empty array creates no downstream items.',
+        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: {
+                    item: createResponseArrayItemSchema(source(parameters).operation, parameters.pointer),
+                },
+                required: ['item'],
+                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}`);
+            return createArrayNodeFragment({
+                planned,
+                position,
+                parameters,
+                linked,
+                source: {
+                    kind: 'api-response',
+                    nodeId: material.callId,
+                    nodeName: apiNodeNames[material.callId],
+                    operation: material.operation,
+                },
+            });
+        },
+    };
+}

package/dist/nodes/native/create-response-collection-capability.d.ts

@@ -0,0 +1,3 @@
+import type { N8nNativeCapability } from '../../types/native-capability.js';
+import type { CreateResponseCollectionCapabilityInput } from '../../types/response-collection.js';
+export declare function createResponseCollectionCapability(input: CreateResponseCollectionCapabilityInput): N8nNativeCapability;