@openapi-flow/n8n 0.2.0 → 0.3.1

package/dist/workflow/templates/compile-n8n-workflow-template.js

@@ -0,0 +1,211 @@
+import { sticky } from '@n8n/workflow-sdk';
+import { validateWorkflowDraft, inspectDraftReadiness, resolveWorkflowDraftMaterials, inspectDeferredApiInputs, inspectNativeRuntimeInputs, createNativeRuntimeParameterMaterializations, } from '@openapi-flow/core';
+import { createTemplateInputNodes } from '../../nodes/inputs/create-template-input-nodes.js';
+import { compileValidatedWorkflowFragments } from '../compile-validated-workflow-fragments.js';
+import { buildN8nWorkflow } from '../build-n8n-workflow.js';
+import { createWorkflowTemplateGuide } from './create-workflow-template-guide.js';
+import { prepareTemplateApiFragments } from './prepare-template-api-fragments.js';
+import { createTemplateArtifactMapping } from './create-template-artifact-mapping.js';
+import { TEMPLATE_INPUT_ID, TEMPLATE_PREFLIGHT_ID, TEMPLATE_PREFLIGHT_NAME, TEMPLATE_GUIDE_ID, } from './workflow-template-identities.js';
+import { n8nTemplateInputValuesSchema } from '../../schemas/workflow-template-schema.js';
+import { createRuntimeInputNativeCapabilities } from '../inputs/create-runtime-input-native-capabilities.js';
+import { resolveN8nNativeMaterials } from '../resolve-n8n-native-materials.js';
+import { compileWorkflowMaterialFragments } from '../compile-workflow-material-fragments.js';
+import { createTemplateGapRegions } from './create-template-gap-regions.js';
+/** An explicit template boundary, never a false fully-resolved strict request. */
+export function compileN8nWorkflowTemplate(source) {
+    if (source.itemMode !== undefined && source.itemMode !== 'linked')
+        throw new Error('template.itemMode must be linked or omitted');
+    const initial = resolveWorkflowDraftMaterials(source);
+    const materialSnapshot = resolveN8nNativeMaterials({
+        apiMaterials: initial.materials,
+        nativeOutputs: [],
+        nativeNodes: source.draft.nativeNodes,
+        capabilities: source.context.capabilities,
+    });
+    // Planning receipts belong to the original declarations. Runtime-bound
+    // capabilities must not replace that source context during draft validation.
+    const input = source;
+    validateWorkflowDraft(input);
+    if (typeof input.name !== 'string' || !input.name.trim())
+        throw new Error('template.name must be non-empty');
+    const readiness = inspectDraftReadiness(input);
+    const { materials, slots, nativeSlots } = resolveWorkflowDraftMaterials(input);
+    const allSlots = [...slots, ...nativeSlots];
+    const checkedValues = n8nTemplateInputValuesSchema.safeParse(input.inputValues === undefined ? {} : input.inputValues);
+    if (!checkedValues.success)
+        throw new Error('template.inputValues must be a JSON value map', {
+            cause: checkedValues.error,
+        });
+    const inputValues = checkedValues.data;
+    const known = new Set(allSlots.map((slot) => slot.id));
+    const unknown = Object.keys(inputValues).filter((id) => !known.has(id));
+    if (unknown.length)
+        throw new Error(`template.inputValues contains undeclared or stale slots ${unknown.join(', ')}`);
+    const apiValues = Object.fromEntries(slots
+        .filter((slot) => Object.hasOwn(inputValues, slot.id))
+        .map((slot) => [slot.id, inputValues[slot.id]]));
+    const nativeValues = Object.fromEntries(nativeSlots
+        .filter((slot) => Object.hasOwn(inputValues, slot.id))
+        .map((slot) => [slot.id, inputValues[slot.id]]));
+    const inputs = inspectDeferredApiInputs({
+        materials,
+        inputValues: apiValues,
+    });
+    if (inputs.status === 'invalid-input')
+        throw new Error(inputs.issues.map((issue) => issue.message).join('; '));
+    const nativeInputs = inspectNativeRuntimeInputs({
+        nativeNodes: input.draft.nativeNodes,
+        capabilities: input.context.capabilities,
+        inputValues: nativeValues,
+    });
+    if (nativeInputs.status === 'invalid-input')
+        throw new Error(nativeInputs.issues.map((issue) => issue.message).join('; '));
+    const capabilities = createRuntimeInputNativeCapabilities({
+        capabilities: materialSnapshot.capabilities,
+        slots: nativeSlots,
+        revision: input.draft.revision,
+        inputNodeName: TEMPLATE_PREFLIGHT_NAME,
+    });
+    const workflowMaterials = materials.map((material) => ({
+        operation: material.operation,
+        arguments: {
+            callId: material.callId,
+            values: material.values,
+            bindings: material.bindings,
+            ...(material.requestedInputs === undefined
+                ? {}
+                : { requestedInputs: material.requestedInputs }),
+            unresolvedInputs: slots
+                .filter((slot) => slot.callId === material.callId)
+                .map((slot) => slot.targetPointer),
+            ...(material.requestMediaType !== undefined
+                ? { requestMediaType: material.requestMediaType }
+                : {}),
+        },
+    }));
+    const nodeIds = [
+        ...input.draft.apiCalls.map((call) => call.id),
+        ...input.draft.nativeNodes.map((node) => node.id),
+        ...(input.draft.gapNodes === undefined
+            ? []
+            : input.draft.gapNodes.map((node) => node.id)),
+    ];
+    if (!nodeIds.length)
+        throw new Error('A workflow template requires at least one API, native or unresolved instance');
+    if (nodeIds.some((id) => [TEMPLATE_INPUT_ID, TEMPLATE_PREFLIGHT_ID, TEMPLATE_GUIDE_ID].includes(id)))
+        throw new Error('Draft node ID conflicts with a template system node');
+    const plan = {
+        nativeNodes: input.draft.nativeNodes,
+        edges: input.draft.edges,
+        starts: nodeIds.filter((id) => !input.draft.edges.some((edge) => edge.to === id)),
+        gaps: [],
+    };
+    const prepared = prepareTemplateApiFragments({
+        template: input,
+        capabilities,
+        materials: workflowMaterials,
+        slots,
+        plan,
+    });
+    const compilation = {
+        id: input.draft.id,
+        name: input.name,
+        plan,
+        materials: workflowMaterials,
+        apiNodes: prepared.apiNodes,
+        capabilities,
+    };
+    const gapNodes = input.draft.gapNodes === undefined ? [] : input.draft.gapNodes;
+    // validateWorkflowDraft above owns the complete graph, including unresolved
+    // structural nodes. The strict compiler continues to reject unresolved graphs.
+    const materialFragments = gapNodes.length
+        ? compileWorkflowMaterialFragments(compilation)
+        : compileValidatedWorkflowFragments(compilation);
+    const gapRegions = createTemplateGapRegions(gapNodes, materialFragments);
+    const fragments = [
+        ...materialFragments,
+        ...gapRegions.map((region) => region.fragment),
+    ];
+    const { mappings, inputSlots } = createTemplateArtifactMapping({
+        context: input.context,
+        draft: input.draft,
+        materials: workflowMaterials,
+        slots: allSlots,
+        fragments,
+    });
+    const { deploymentRequirements } = prepared;
+    const triggerConnected = readiness.designReady && deploymentRequirements.length === 0;
+    const guide = createWorkflowTemplateGuide({
+        draft: input.draft,
+        readiness,
+        slots: inputSlots,
+        mappings,
+        deploymentRequirements,
+        requestInputsReady: inputs.status === 'ready',
+        nativeInputsReady: nativeInputs.status === 'ready',
+        triggerConnected,
+    });
+    const systemNodes = createTemplateInputNodes({
+        revision: input.draft.revision,
+        slots: allSlots,
+        inputValues,
+        requests: prepared.requests,
+        nativeParameters: createNativeRuntimeParameterMaterializations({
+            nativeNodes: input.draft.nativeNodes,
+            capabilities: materialSnapshot.capabilities,
+        }),
+    });
+    const height = 100 +
+        guide
+            .split('\n')
+            .reduce((total, line) => total + Math.max(1, Math.ceil(line.length / 90)) * 24, 0);
+    const workflow = buildN8nWorkflow({
+        id: input.draft.id,
+        name: input.name,
+        nodes: [...systemNodes, ...fragments],
+        edges: [
+            {
+                from: TEMPLATE_INPUT_ID,
+                output: 'main',
+                to: TEMPLATE_PREFLIGHT_ID,
+                input: 'main',
+            },
+            ...plan.starts.map((to) => ({
+                from: TEMPLATE_PREFLIGHT_ID,
+                output: 'main',
+                to,
+                input: 'main',
+            })),
+            ...plan.edges,
+        ],
+        starts: [TEMPLATE_INPUT_ID],
+        triggerConnections: triggerConnected ? 'connected' : 'detached',
+        annotations: [
+            sticky(guide, [], {
+                id: TEMPLATE_GUIDE_ID,
+                name: '워크플로우 사용 안내',
+                position: [0, -height - 100],
+                width: 1000,
+                height,
+                color: triggerConnected ? 5 : 3,
+            }),
+            ...gapRegions.map((region) => region.annotation),
+        ],
+    });
+    workflow.settings = { ...workflow.settings, executionOrder: 'v1' };
+    return {
+        revision: input.draft.revision,
+        workflow,
+        draftReadiness: readiness,
+        requestInputsReady: inputs.status === 'ready',
+        nativeInputsReady: nativeInputs.status === 'ready',
+        runtimeInputsReady: inputs.status === 'ready' && nativeInputs.status === 'ready',
+        deploymentConfigured: deploymentRequirements.length === 0,
+        triggerConnected,
+        inputSlots,
+        deploymentRequirements,
+        nodeMappings: mappings,
+        guide,
+    };
+}

package/dist/workflow/templates/create-template-artifact-mapping.d.ts

@@ -0,0 +1,2 @@
+import type { CreateTemplateArtifactMappingInput, TemplateArtifactMapping } from '../../types/workflow-template.js';
+export declare function createTemplateArtifactMapping(input: CreateTemplateArtifactMappingInput): TemplateArtifactMapping;

package/dist/workflow/templates/create-template-artifact-mapping.js

@@ -0,0 +1,58 @@
+import { inspectWorkflowDraftCapabilityGap } from '@openapi-flow/core';
+import { TEMPLATE_INPUT_ID, TEMPLATE_INPUT_NAME, } from './workflow-template-identities.js';
+export function createTemplateArtifactMapping(input) {
+    const mappings = input.fragments.map((fragment) => {
+        const common = {
+            nodeId: fragment.nodeId,
+            sdkNodeIds: fragment.nodes.map((node) => node.id),
+            entryNodeName: fragment.entry.name,
+            exitNodeName: fragment.exit.name,
+        };
+        const material = input.materials.find((item) => item.arguments.callId === fragment.nodeId);
+        if (material) {
+            const { key, method, path } = material.operation;
+            const { summary } = material.operation.operation;
+            return {
+                ...common,
+                kind: 'api',
+                operation: {
+                    key,
+                    method,
+                    path,
+                    ...(summary !== undefined ? { summary } : {}),
+                },
+            };
+        }
+        const gap = input.draft.gapNodes?.find((node) => node.id === fragment.nodeId);
+        if (gap)
+            return {
+                ...common,
+                kind: 'capability-gap',
+                gap: structuredClone(gap),
+                inventoryCurrent: inspectWorkflowDraftCapabilityGap({
+                    gap,
+                    context: input.context,
+                }).inventoryCurrent,
+            };
+        const planned = input.draft.nativeNodes.find((node) => node.id === fragment.nodeId);
+        if (!planned)
+            throw new Error(`Template fragment ${fragment.nodeId} has no original API or native instance`);
+        return { ...common, kind: 'native', capability: planned.capability };
+    });
+    const inputSlots = input.slots.map((slot) => {
+        const mapping = mappings.find((mapping) => mapping.kind ===
+            (slot.kind === 'api-request-input' ? 'api' : 'native') &&
+            mapping.nodeId ===
+                (slot.kind === 'api-request-input' ? slot.callId : slot.nodeId));
+        if (!mapping)
+            throw new Error(`Template slot ${slot.id} has no compiled source node mapping`);
+        return {
+            ...slot,
+            editNodeId: TEMPLATE_INPUT_ID,
+            editNodeName: TEMPLATE_INPUT_NAME,
+            editParameter: 'jsCode',
+            materializerNodeName: mapping.entryNodeName,
+        };
+    });
+    return { mappings, inputSlots };
+}

package/dist/workflow/templates/create-template-gap-regions.d.ts

@@ -0,0 +1,5 @@
+import type { WorkflowDraftCapabilityGap } from '@openapi-flow/core';
+import type { GapReviewRegion } from '../../types/reviewable-workflow.js';
+import type { N8nNodeFragment } from '../../types/node-fragment.js';
+/** Existing warning region and stop-on-execution surrogate; no invented API/response. */
+export declare function createTemplateGapRegions(gaps: WorkflowDraftCapabilityGap[], materialFragments: N8nNodeFragment[]): GapReviewRegion[];

package/dist/workflow/templates/create-template-gap-regions.js

@@ -0,0 +1,22 @@
+import { createGapReviewRegion } from '../review/create-gap-review-region.js';
+import { GAP_REVIEW_REGION_WIDTH, GAP_REVIEW_REGION_SPACING, } from '../review/gap-review-region-layout.js';
+/** Existing warning region and stop-on-execution surrogate; no invented API/response. */
+export function createTemplateGapRegions(gaps, materialFragments) {
+    const top = Math.max(0, ...materialFragments.flatMap((fragment) => fragment.nodes.map((node) => node.config.position?.[1] === undefined ? 0 : node.config.position[1]))) + 240;
+    return gaps.map((gap, index) => createGapReviewRegion({
+        nodeId: gap.id,
+        position: [
+            700 + index * (GAP_REVIEW_REGION_WIDTH + GAP_REVIEW_REGION_SPACING),
+            top,
+        ],
+        gaps: [
+            {
+                id: gap.id,
+                stage: gap.finding.kind === 'unsupported-native'
+                    ? 'workflow-graph'
+                    : 'api-selection',
+                description: `요청한 기능: ${gap.requestedBehavior}\n판단 근거: ${gap.finding.reason}${gap.finding.kind === 'api-contract-gap' ? '\n대상 OAS 작업: ' + gap.finding.operation.documentId + ' ' + gap.finding.operation.operationRef : ''}\n제공된 OAS·native 계약에서 충족하지 못한 기능입니다. 전체 서비스에 API가 없다는 확정이나 실행 가능한 구현이 아닙니다.`,
+            },
+        ],
+    }));
+}

package/dist/workflow/templates/create-workflow-template-guide.d.ts

@@ -0,0 +1,3 @@
+import type { CreateTemplateGuideInput } from '../../types/workflow-template.js';
+/** Status and edit locations derive from the same revision and compiled mapping. */
+export declare function createWorkflowTemplateGuide(input: CreateTemplateGuideInput): string;

package/dist/workflow/templates/create-workflow-template-guide.js

@@ -0,0 +1,44 @@
+import { escapeReviewMarkdown } from '../review/escape-review-markdown.js';
+/** Status and edit locations derive from the same revision and compiled mapping. */
+export function createWorkflowTemplateGuide(input) {
+    const text = escapeReviewMarkdown;
+    const lines = [
+        '# 워크플로우 사용 안내',
+        `초안 버전: ${input.draft.revision}`,
+        `설계 결정: ${input.readiness.designReady ? '확정' : '확인 필요'} / 사람 검토: ${input.readiness.reviewed ? '완료' : '미완료'} / 실제 요청 입력: ${input.requestInputsReady ? '준비됨' : '미입력 있음'} / native 입력: ${input.nativeInputsReady ? '준비됨' : '미입력 있음'}`,
+        input.triggerConnected
+            ? 'Start → 입력 설정 → 입력 사전 검사 → 업무 흐름 순서로 실행됩니다. 미입력·잘못된 값은 외부 호출 전에 오류로 중단됩니다.'
+            : '미확정 설계 또는 배포 설정이 있어 Start 연결을 끊었습니다. 아래 항목을 해결한 뒤 다시 생성하거나 설정을 확인하고 Start를 입력 설정에 연결하세요.',
+        '## 입력 슬롯',
+        '입력 설정 노드의 jsCode에 있는 inputValues 객체에 슬롯 ID를 키로 실제 JSON 값을 추가하세요. API 값은 원래 OAS, native 값은 등록된 파라미터 스키마를 따릅니다. native 슬롯에는 표시된 필드의 값 또는 전체 파라미터 객체를 입력합니다. 이미 정한 리터럴은 보존하며, 포트·참조·연결을 바꾸는 설정은 실행 입력으로 미루지 않습니다. 비밀값은 여기에 넣지 말고 n8n credential을 사용하세요.',
+        ...input.slots.map((slot) => `- ${text(slot.id)}: ${text(slot.kind === 'api-request-input' ? slot.callId + slot.targetPointer : 'native ' + slot.nodeId + (slot.targetPointer === '' ? ' 전체 파라미터' : slot.targetPointer))} → ${text(slot.materializerNodeName)} / 원래 스키마: ${text(JSON.stringify(slot.schema))}${slot.kind === 'api-request-input' && slot.requestedInputs !== undefined ? ' / 사용자 요청으로 포함할 입력: ' + text(slot.requestedInputs.join(', ')) + ' (OAS 필수 여부와 별도)' : ''}`),
+        ...(input.slots.length ? [] : ['추가로 입력할 필수 실행 값이 없습니다.']),
+        '## 노드 구성',
+        ...input.mappings.map((mapping) => `- ${text(mapping.nodeId)} (${mapping.kind === 'api' ? text(mapping.operation.method + ' ' + mapping.operation.path) : mapping.kind === 'native' ? text('등록 native ' + mapping.capability) : '확인 필요 · 미해결 기능'}): ${text(mapping.entryNodeName)} → ${text(mapping.exitNodeName)}`),
+        '## 연결과 데이터 출처',
+        ...input.draft.edges.map((edge) => `- ${text(edge.from)} (${text(edge.output)}) → ${text(edge.to)} (${text(edge.input)})`),
+        ...input.draft.apiCalls.flatMap((call) => call.bindings.map((binding) => `- ${text(binding.sourceNodeId + binding.sourcePointer)} 값을 ${text(call.id + binding.targetPointer)}에 타입 변환 없이 전달합니다.`)),
+        '## 미확정 결정',
+        ...(input.draft.gapNodes === undefined
+            ? []
+            : input.draft.gapNodes.flatMap((gap) => [
+                `- ${text(gap.id)}: ${text(gap.requestedBehavior)} / ${text(gap.finding.kind)} / 판단 근거: ${text(gap.finding.reason)}`,
+                ...(gap.finding.kind === 'api-contract-gap'
+                    ? [
+                        `  대상 OAS 작업: ${text(gap.finding.operation.documentId + ' ' + gap.finding.operation.operationRef)}`,
+                    ]
+                    : []),
+                `  제공된 계약에서 충족하지 못한 기능이며 전체 서비스의 API 부재를 확정하지 않습니다. 원래 검토 범위: OAS ${gap.inventory.operations.length}개 작업·native ${gap.inventory.capabilities.length}개 계약. 대역을 실제 구현으로 교체하고 검증하기 전에는 Start를 연결하지 마세요.`,
+                `  검토 범위 일치: ${input.mappings.some((mapping) => mapping.kind === 'capability-gap' && mapping.nodeId === gap.id && mapping.inventoryCurrent) ? '현재 계약과 일치' : '계약 변경됨. 새 계약으로 다시 검토해야 하며 결손을 자동 해소하지 않았습니다.'}`,
+            ])),
+        ...input.draft.requirements
+            .filter((item) => item.state !== 'confirmed')
+            .map((item) => `- ${text(item.id)}: ${text(item.text)} / 영향 범위: ${text(item.scope.kind === 'workflow' ? '전체' : item.scope.nodeIds.join(', '))}`),
+        '## 배포 설정',
+        ...input.deploymentRequirements.map((item) => `- ${text(item.documentId)} / ${text(item.callId)}: ${text(item.fields.join(', '))}. 주소는 ${text(item.materializerNodeName)}의 config.templateUrl, credential은 ${text(item.requestNodeName)}에서 설정하세요. 호스트에 배포 옵션을 제공하고 다시 생성하는 방법을 권장합니다.`),
+        'credential 참조를 제공해도 실제 n8n에서 해당 credential을 사용할 권한이 있는지는 여기서 확인하지 않습니다. 실행 전 n8n에서 확인하세요.',
+        '## 실행 전 확인',
+        '입력 사전 검사와 요청 전 OAS 검사는 정상 실행 경로의 오류 방지 장치입니다. 부분 실행·pinning·JSON 직접 편집으로 건너뛸 수 있으므로 보안 경계가 아닙니다. 이 산출물은 사용자 n8n에 저장·활성화·실행하지 않습니다.',
+    ];
+    return lines.join('\n\n');
+}

package/dist/workflow/templates/prepare-template-api-fragments.d.ts

@@ -0,0 +1,3 @@
+import type { PrepareTemplateApiFragmentsInput, PreparedTemplateApiFragments } from '../../types/workflow-template.js';
+/** Resolve deployment and request runtime configuration only from supplied contracts. */
+export declare function prepareTemplateApiFragments(input: PrepareTemplateApiFragmentsInput): PreparedTemplateApiFragments;

package/dist/workflow/templates/prepare-template-api-fragments.js

@@ -0,0 +1,74 @@
+import { resolveHttpRequestNodeConfiguration } from '../../nodes/request/resolve-http-request-node-configuration.js';
+import { createBoundRequestFragment } from '../../nodes/request/bindings/create-bound-request-fragment.js';
+import { finalizeHttpRequestFragment } from '../../nodes/request/finalize-http-request-fragment.js';
+import { httpResponseNodeName } from '../../nodes/request/response/http-response-node-name.js';
+import { createN8nNativeOutputSources } from '../create-n8n-native-output-sources.js';
+import { TEMPLATE_PREFLIGHT_NAME } from './workflow-template-identities.js';
+import { n8nTemplateDeploymentsSchema } from '../../schemas/workflow-template-schema.js';
+/** Resolve deployment and request runtime configuration only from supplied contracts. */
+export function prepareTemplateApiFragments(input) {
+    const deployments = n8nTemplateDeploymentsSchema.parse(input.template.deployments === undefined ? [] : input.template.deployments);
+    const usedDocuments = new Set(input.materials.map((material) => material.operation.key.documentId));
+    if (deployments.some((item) => !usedDocuments.has(item.documentId)))
+        throw new Error('template.deployments contains an unused documentId');
+    const apiNodeNames = Object.fromEntries(input.materials.map((material) => [
+        material.arguments.callId,
+        httpResponseNodeName(material.arguments.callId),
+    ]));
+    const apiResponseContracts = Object.fromEntries(input.materials.map((material) => [
+        material.arguments.callId,
+        material.operation,
+    ]));
+    const nativeOutputSources = createN8nNativeOutputSources({
+        nativeNodes: input.plan.nativeNodes,
+        capabilities: input.capabilities,
+        apiNodeNames,
+        apiResponseContracts,
+    });
+    const prepared = input.materials.map((material, index) => {
+        const deployment = deployments.find((item) => item.documentId === material.operation.key.documentId);
+        const result = resolveHttpRequestNodeConfiguration({
+            ...material,
+            baseUrl: deployment?.baseUrl,
+            credentialBindings: deployment?.credentialBindings,
+            securityRequirementIndex: deployment?.securityRequirementIndex,
+            position: [700, index * 260],
+            apiNodeNames,
+            nativeOutputSources,
+            apiResponseContracts,
+            itemMode: input.template.itemMode,
+        });
+        result.config.deferredInputs = {
+            revision: input.template.draft.revision,
+            inputNodeName: TEMPLATE_PREFLIGHT_NAME,
+            slots: input.slots.filter((slot) => slot.callId === material.arguments.callId),
+        };
+        return result;
+    });
+    const apiNodes = prepared.map((item) => finalizeHttpRequestFragment({
+        fragment: createBoundRequestFragment(item.input, item.config),
+        method: item.config.contract.method,
+        documentId: item.config.contract.key.documentId,
+        deployment: item.input,
+    }));
+    const deploymentRequirements = prepared
+        .filter((item) => item.input.pendingFields.length > 0)
+        .map((item) => {
+        const fragment = apiNodes.find((fragment) => fragment.nodeId === item.config.arguments.callId);
+        const request = fragment?.nodes.find((node) => node.type === 'n8n-nodes-base.httpRequest');
+        if (!fragment || !request)
+            throw new Error(`Template ${item.config.arguments.callId} requires its compiled HTTP request mapping`);
+        return {
+            callId: item.config.arguments.callId,
+            documentId: item.config.contract.key.documentId,
+            fields: item.input.pendingFields,
+            materializerNodeName: fragment.entry.name,
+            requestNodeName: request.name,
+        };
+    });
+    return {
+        apiNodes,
+        requests: prepared.map((item) => item.config),
+        deploymentRequirements,
+    };
+}

package/dist/workflow/templates/select-n8n-template-deployments.d.ts

@@ -0,0 +1,3 @@
+import type { SelectN8nTemplateDeploymentsInput, N8nTemplateDeployment } from '../../types/workflow-template.js';
+/** Validate the whole supplied registry first, then project declared settings onto the selected OAS documents. */
+export declare function selectN8nTemplateDeployments(input: SelectN8nTemplateDeploymentsInput): N8nTemplateDeployment[];

package/dist/workflow/templates/select-n8n-template-deployments.js

@@ -0,0 +1,12 @@
+import { templateDeploymentSelectionSchema } from '../../schemas/template-deployment-selection-schema.js';
+/** Validate the whole supplied registry first, then project declared settings onto the selected OAS documents. */
+export function selectN8nTemplateDeployments(input) {
+    const parsed = templateDeploymentSelectionSchema.parse(input);
+    for (const deployment of parsed.deployments)
+        if (!parsed.availableDocumentIds.includes(deployment.documentId))
+            throw new Error(`deployments.${deployment.documentId} does not belong to an available original OAS document`);
+    for (const documentId of parsed.selectedDocumentIds)
+        if (!parsed.availableDocumentIds.includes(documentId))
+            throw new Error(`selectedDocumentIds.${documentId} is not an available original OAS document`);
+    return structuredClone(parsed.deployments.filter((deployment) => parsed.selectedDocumentIds.includes(deployment.documentId)));
+}

package/dist/workflow/templates/workflow-template-identities.d.ts

@@ -0,0 +1,5 @@
+export declare const TEMPLATE_INPUT_ID = "openapi-flow-inputs";
+export declare const TEMPLATE_INPUT_NAME = "\uC785\uB825 \uC124\uC815";
+export declare const TEMPLATE_PREFLIGHT_ID = "openapi-flow-preflight";
+export declare const TEMPLATE_PREFLIGHT_NAME = "\uC785\uB825 \uC0AC\uC804 \uAC80\uC0AC";
+export declare const TEMPLATE_GUIDE_ID = "openapi-flow-template-guide";

package/dist/workflow/templates/workflow-template-identities.js

@@ -0,0 +1,5 @@
+export const TEMPLATE_INPUT_ID = 'openapi-flow-inputs';
+export const TEMPLATE_INPUT_NAME = '입력 설정';
+export const TEMPLATE_PREFLIGHT_ID = 'openapi-flow-preflight';
+export const TEMPLATE_PREFLIGHT_NAME = '입력 사전 검사';
+export const TEMPLATE_GUIDE_ID = 'openapi-flow-template-guide';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openapi-flow/n8n",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "license": "MIT",
   "type": "module",
   "description": "Deterministic OpenAPI request nodes and n8n workflow assembly",
@@ -24,13 +24,13 @@
     "THIRD_PARTY_NOTICES.md"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.json && node ../../scripts/build-request-runtime.mjs && node ../../scripts/build-item-join-runtime.mjs && node ../../scripts/build-response-runtime.mjs",
+    "build": "tsc -p tsconfig.json && node ../../scripts/build-request-runtime.mjs && node ../../scripts/build-native-input-runtime.mjs && node ../../scripts/build-item-join-runtime.mjs && node ../../scripts/build-response-runtime.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit"
   },
   "dependencies": {
     "@n8n/config": "2.41.2",
     "@n8n/workflow-sdk": "0.36.4",
-    "@openapi-flow/core": "0.2.0",
+    "@openapi-flow/core": "0.3.1",
     "@sentry/node": "10.70.0",
     "@types/estree": "1.0.8",
     "@types/express": "5.0.1",
@@ -41,7 +41,12 @@
     "ajv": "8.20.0",
     "ajv-formats": "3.0.1",
     "esbuild": "0.28.2",
-    "nock": "14.0.14",
+    "nock": "14.0.14"
+  },
+  "peerDependencies": {
+    "zod": "^4.6.5"
+  },
+  "devDependencies": {
     "zod": "4.6.5"
   },
   "publishConfig": {