@openapi-flow/n8n 0.0.0-stage → 0.3.0

package/dist/legacy/workflow/request/compile-catalog-sequence.js

@@ -0,0 +1,122 @@
+import { createOperationCatalog } from '@openapi-flow/core/internal';
+import { operationFromDocument } from '@openapi-flow/core/internal';
+import { isObject } from '@openapi-flow/core/internal';
+import { assertSerializablePlan } from '../common/plan-validation.js';
+import { originFrom } from './base-url.js';
+import { isSafeMethod } from './effect-policy.js';
+import { buildSequenceWorkflow } from './build-sequence-workflow.js';
+import { prepareSteps } from './prepare-sequence.js';
+export async function compileCatalogSequence({ sources, profile, plan, }) {
+    if (profile !== 'read-only' && profile !== 'test')
+        throw new Error('profile must be read-only or test');
+    if (!isObject(plan) ||
+        plan.version !== '1' ||
+        typeof plan.goal !== 'string' ||
+        !plan.goal.trim() ||
+        !Array.isArray(plan.steps) ||
+        (plan.gaps !== undefined && !Array.isArray(plan.gaps)) ||
+        (plan.steps.length === 0 && (!plan.gaps || plan.gaps.length === 0)))
+        throw new Error('plan must contain version 1, goal, steps or gaps');
+    assertSerializablePlan(plan);
+    const catalog = await createOperationCatalog(sources);
+    const gaps = plan.gaps ?? [];
+    for (const gap of gaps) {
+        if (!isObject(gap) ||
+            (gap.kind !== 'missing_operation' &&
+                gap.kind !== 'insufficient_contract') ||
+            typeof gap.description !== 'string' ||
+            !gap.description.trim())
+            throw new Error('plan.gaps[] must contain kind and non-empty description');
+        if (gap.kind === 'missing_operation' &&
+            (gap.documentId !== undefined || gap.operationRef !== undefined))
+            throw new Error('plan.gaps[] missing_operation must not identify an operation');
+        if (gap.kind === 'insufficient_contract') {
+            if (typeof gap.documentId !== 'string' ||
+                typeof gap.operationRef !== 'string')
+                throw new Error('plan.gaps[] insufficient_contract needs documentId and operationRef');
+            const source = catalog.sources.get(gap.documentId);
+            if (!source ||
+                !source.operations.some((operation) => operation.operationRef === gap.operationRef))
+                throw new Error('plan.gaps[] insufficient_contract operation is not in sources');
+        }
+    }
+    const stepById = new Map();
+    for (const step of plan.steps) {
+        if (!isObject(step) ||
+            typeof step.documentId !== 'string' ||
+            !step.documentId.trim())
+            throw new Error('plan.steps[].documentId must be non-empty');
+        if (typeof step.id !== 'string' || !step.id.trim() || stepById.has(step.id))
+            throw new Error('plan.steps must have unique non-empty id values');
+        stepById.set(step.id, step.documentId);
+    }
+    const prepared = prepareSteps({
+        profile,
+        plan,
+        resolveStep: (step) => {
+            const documentId = stepById.get(step.id);
+            const source = documentId === undefined ? undefined : catalog.sources.get(documentId);
+            if (!source)
+                throw new Error(`plan.steps[${step.id}].documentId is not in sources: ${documentId}`);
+            const target = sources.find((item) => item.id === source.id);
+            if (!target)
+                throw new Error(`sources[${source.id}] execution configuration is missing`);
+            return {
+                operation: operationFromDocument(source.document, step.operationRef),
+                origin: originFrom(target.baseUrl),
+                effectPolicy: target.effectPolicy,
+                credentialBindings: target.credentialBindings,
+            };
+        },
+    });
+    const evidence = prepared.evidence.map((entry) => ({
+        ...entry,
+        documentId: stepById.get(entry.stepId),
+    }));
+    const diagnostics = [
+        ...gaps.map((gap) => ({
+            code: gap.kind,
+            message: gap.description,
+            ...(gap.documentId === undefined ? {} : { documentId: gap.documentId }),
+            ...(gap.operationRef === undefined
+                ? {}
+                : { operationRef: gap.operationRef }),
+        })),
+        ...prepared.missingInputs.map((missing) => ({
+            code: 'missing_input',
+            message: missing,
+            stepId: missing.split('.')[0],
+        })),
+        ...evidence
+            .filter((entry) => entry.effect === 'unknown' ||
+            (!isSafeMethod(entry.method) && entry.effect !== 'write') ||
+            (profile === 'read-only' &&
+                (!isSafeMethod(entry.method) || entry.effect !== 'read')))
+            .map((entry) => ({
+            code: 'effect_not_approved',
+            message: `step ${entry.stepId} requires an approved effect`,
+            stepId: entry.stepId,
+        })),
+    ];
+    const status = gaps.length
+        ? 'needs_capability'
+        : prepared.blocked
+            ? 'blocked'
+            : prepared.missingInputs.length
+                ? 'needs_input'
+                : 'complete';
+    if (status !== 'complete')
+        return { status, plan, evidence, diagnostics };
+    return {
+        status,
+        plan,
+        evidence,
+        diagnostics,
+        workflow: buildSequenceWorkflow({
+            baseUrl: JSON.stringify(sources.map(({ id, baseUrl }) => ({ id, baseUrl }))),
+            plan,
+            nodes: prepared.nodes,
+            requiredOutputs: prepared.requiredOutputs,
+        }),
+    };
+}

package/dist/legacy/workflow/request/compile-sequence.d.ts

@@ -0,0 +1,2 @@
+import type { SequenceRequest, SequenceResult } from '../../../types/legacy/sequence-workflow.js';
+export declare function compileSequence({ spec, baseUrl, profile, effectPolicy, credentialBindings, plan, }: SequenceRequest): Promise<SequenceResult>;

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

@@ -0,0 +1,41 @@
+import { validateAndResolveOpenApiDocument } from '@openapi-flow/core/internal';
+import { isObject } from '@openapi-flow/core/internal';
+import { assertSerializablePlan } from '../common/plan-validation.js';
+import { originFrom } from './base-url.js';
+import { buildSequenceWorkflow } from './build-sequence-workflow.js';
+import { prepareSequence } from './prepare-sequence.js';
+export async function compileSequence({ spec, baseUrl, profile, effectPolicy, credentialBindings, plan, }) {
+    const origin = originFrom(baseUrl);
+    if (profile !== 'read-only' && profile !== 'test')
+        throw new Error('profile must be read-only or test');
+    if (!isObject(plan) ||
+        plan.version !== '1' ||
+        typeof plan.goal !== 'string' ||
+        !plan.goal.trim() ||
+        !Array.isArray(plan.steps) ||
+        plan.steps.length < 1) {
+        throw new Error('plan must contain version 1, goal, and non-empty steps');
+    }
+    assertSerializablePlan(plan);
+    const document = await validateAndResolveOpenApiDocument(spec);
+    const prepared = prepareSequence({
+        document,
+        origin,
+        profile,
+        effectPolicy,
+        credentialBindings,
+        plan,
+    });
+    const { evidence, missingInputs, nodes, requiredOutputs, blocked } = prepared;
+    if (blocked)
+        return { status: 'blocked', plan, evidence, missingInputs };
+    if (missingInputs.length)
+        return { status: 'needs_input', plan, evidence, missingInputs };
+    return {
+        status: 'complete',
+        plan,
+        evidence,
+        missingInputs,
+        workflow: buildSequenceWorkflow({ baseUrl, plan, nodes, requiredOutputs }),
+    };
+}

package/dist/legacy/workflow/request/compile-workflow.d.ts

@@ -0,0 +1,4 @@
+import type { Operation } from '@openapi-flow/core/internal';
+import type { CompileOperationRequest, CompileRequest, CompileResult } from '../../../types/legacy/request-workflow.js';
+export declare function compileWorkflow(request: CompileRequest): Promise<CompileResult>;
+export declare function compileWorkflowFromOperation({ baseUrl, profile, effectPolicy, credentialBindings, plan, }: CompileOperationRequest, operation: Operation): CompileResult;

package/dist/legacy/workflow/request/compile-workflow.js

@@ -0,0 +1,93 @@
+import { operationFromSpec } from '@openapi-flow/core/internal';
+import { validateResponseField } from '@openapi-flow/core/internal';
+import { isObject } from '@openapi-flow/core/internal';
+import { assertSerializablePlan } from '../common/plan-validation.js';
+import { originFrom } from './base-url.js';
+import { approvedEffect, isSafeMethod } from './effect-policy.js';
+import { looksLikeCredential, resolveCredentialBinding, } from './credential-binding.js';
+import { makeBody } from './request-body.js';
+import { makeHeaders } from './request-headers.js';
+import { makeUrl } from './request-url.js';
+import { buildRequestWorkflow } from './build-request-workflow.js';
+export async function compileWorkflow(request) {
+    if (!isObject(request.plan) ||
+        typeof request.plan.operationRef !== 'string') {
+        throw new Error('plan must contain version 1, goal, and operationRef');
+    }
+    const operation = await operationFromSpec(request.spec, request.plan.operationRef);
+    return compileWorkflowFromOperation(request, operation);
+}
+export function compileWorkflowFromOperation({ baseUrl, profile, effectPolicy, credentialBindings, plan, }, operation) {
+    const origin = originFrom(baseUrl);
+    if (profile !== 'read-only' && profile !== 'test')
+        throw new Error('profile must be read-only or test');
+    if (!isObject(plan) ||
+        plan.version !== '1' ||
+        typeof plan.goal !== 'string' ||
+        !plan.goal.trim() ||
+        typeof plan.operationRef !== 'string') {
+        throw new Error('plan must contain version 1, goal, and operationRef');
+    }
+    assertSerializablePlan(plan);
+    const effect = approvedEffect(operation, effectPolicy);
+    const authentication = resolveCredentialBinding(operation, credentialBindings);
+    const evidence = {
+        operationRef: operation.operationRef,
+        operationId: operation.operationId,
+        method: operation.method,
+        path: operation.path,
+        effect,
+    };
+    const inputs = plan.inputs === undefined ? {} : plan.inputs;
+    if (!isObject(inputs))
+        throw new Error('plan.inputs must be an object');
+    const expectedBody = plan.expectedBody === undefined ? {} : plan.expectedBody;
+    if (!isObject(expectedBody))
+        throw new Error('plan.expectedBody must be an object');
+    for (const [key, value] of Object.entries(expectedBody)) {
+        if (looksLikeCredential(key)) {
+            throw new Error('plan.expectedBody.' + key + ' looks like a credential');
+        }
+        validateResponseField(operation, key, value, 'plan.expectedBody.' + key);
+    }
+    const allowed = new Set(operation.parameters.map((parameter) => parameter.in + '.' + parameter.name));
+    if (operation.body)
+        allowed.add('body');
+    for (const key of Object.keys(inputs)) {
+        if (!allowed.has(key))
+            throw new Error('plan.inputs.' + key + ' is not declared in the OAS operation');
+        if (looksLikeCredential(key)) {
+            throw new Error('plan.inputs.' +
+                key +
+                ' looks like a credential; bind an existing n8n credential through credentialBindings instead');
+        }
+    }
+    const missingInputs = [];
+    const url = makeUrl(operation, origin, inputs, missingInputs);
+    const body = makeBody(operation, inputs, missingInputs, plan.requestMediaType);
+    const headers = makeHeaders(operation, inputs, missingInputs);
+    if (effect === 'unknown' ||
+        (!isSafeMethod(operation.method) && effect !== 'write') ||
+        (profile === 'read-only' &&
+            (!isSafeMethod(operation.method) || effect !== 'read'))) {
+        return { status: 'blocked', plan, evidence, missingInputs };
+    }
+    if (missingInputs.length)
+        return { status: 'needs_input', plan, evidence, missingInputs };
+    return {
+        status: 'complete',
+        plan,
+        evidence,
+        missingInputs,
+        workflow: buildRequestWorkflow({
+            baseUrl,
+            plan,
+            operation,
+            url,
+            body,
+            headers,
+            authentication,
+            expectedBody,
+        }),
+    };
+}

package/dist/legacy/workflow/request/credential-binding.d.ts

@@ -0,0 +1,5 @@
+import type { CredentialBindingRequest } from '../../../types/authentication.js';
+import type { CredentialBindings } from '../../../types/legacy/request-workflow.js';
+import type { ResolvedAuthentication } from '../../../types/legacy/request-node.js';
+export { looksLikeCredential } from '../../../nodes/request/authentication/credential-field-name.js';
+export declare function resolveCredentialBinding(operation: CredentialBindingRequest, credentialBindings: CredentialBindings): ResolvedAuthentication | undefined;

package/dist/legacy/workflow/request/credential-binding.js

@@ -0,0 +1,31 @@
+import { newCredential } from '@n8n/workflow-sdk';
+import { isObject } from '@openapi-flow/core/internal';
+export { looksLikeCredential } from '../../../nodes/request/authentication/credential-field-name.js';
+export function resolveCredentialBinding(operation, credentialBindings) {
+    if (!isObject(credentialBindings)) {
+        throw new Error('credentialBindings must be an OAS-scheme-to-n8n-credential map');
+    }
+    if (operation.authentication === undefined)
+        return undefined;
+    const schemeName = operation.authentication.schemeName;
+    const binding = credentialBindings[schemeName];
+    if (!isObject(binding) ||
+        Object.keys(binding).some((key) => key !== 'id' && key !== 'name') ||
+        typeof binding.id !== 'string' ||
+        !binding.id.trim() ||
+        typeof binding.name !== 'string' ||
+        !binding.name.trim()) {
+        throw new Error('credentialBindings.' +
+            schemeName +
+            ' must contain an existing n8n credential id and name');
+    }
+    return {
+        parameters: {
+            authentication: 'genericCredentialType',
+            genericAuthType: operation.authentication.credentialType,
+        },
+        credentials: {
+            [operation.authentication.credentialType]: newCredential(binding.name, binding.id),
+        },
+    };
+}

package/dist/legacy/workflow/request/effect-policy.d.ts

@@ -0,0 +1,4 @@
+import type { Operation } from '@openapi-flow/core/internal';
+import type { EffectPolicy, OperationEffect } from '../../../types/legacy/request-workflow.js';
+export declare function isSafeMethod(method: string): boolean;
+export declare function approvedEffect(operation: Operation, effectPolicy: EffectPolicy): OperationEffect;

package/dist/legacy/workflow/request/effect-policy.js

@@ -0,0 +1,16 @@
+import { isObject } from '@openapi-flow/core/internal';
+export function isSafeMethod(method) {
+    return ['GET', 'HEAD', 'OPTIONS', 'TRACE', 'QUERY'].includes(method);
+}
+export function approvedEffect(operation, effectPolicy) {
+    if (!isObject(effectPolicy)) {
+        throw new Error('effectPolicy must be a trusted operationRef-to-effect map');
+    }
+    if (!Object.hasOwn(effectPolicy, operation.operationRef))
+        return 'unknown';
+    const effect = effectPolicy[operation.operationRef];
+    if (effect !== 'read' && effect !== 'write') {
+        throw new Error('effectPolicy.' + operation.operationRef + ' must be read or write');
+    }
+    return effect;
+}

package/dist/legacy/workflow/request/http-request-node.d.ts

@@ -0,0 +1,2 @@
+import type { HttpRequestNodeInput } from '../../../types/legacy/request-node.js';
+export declare function httpRequestNode({ operation, id, name, position, url, body, headers, authentication, shouldAssert, }: HttpRequestNodeInput): import("@n8n/workflow-sdk").NodeInstance<string, `${number}`, unknown>;

package/dist/legacy/workflow/request/http-request-node.js

@@ -0,0 +1,69 @@
+import { node } from '@n8n/workflow-sdk';
+import { UnsupportedOperationError } from '@openapi-flow/core/internal';
+// n8n HTTP Request V3, node version 4.3 (verified against n8n 2.37.10).
+const httpRequestMethods = new Set([
+    'DELETE',
+    'GET',
+    'HEAD',
+    'OPTIONS',
+    'PATCH',
+    'POST',
+    'PUT',
+]);
+export function httpRequestNode({ operation, id, name, position, url, body, headers, authentication, shouldAssert, }) {
+    if (operation.source !== 'paths') {
+        throw new Error(`operationRef ${operation.operationRef} is not an outgoing path request`);
+    }
+    if (!httpRequestMethods.has(operation.method)) {
+        throw new UnsupportedOperationError(operation.operationRef, `operationRef ${operation.operationRef} uses HTTP method ${operation.method}, which n8n HTTP Request node v4.3 does not expose`);
+    }
+    if (body !== undefined && ['HEAD', 'OPTIONS'].includes(operation.method)) {
+        throw new UnsupportedOperationError(operation.operationRef, `operationRef ${operation.operationRef} has a request body that n8n HTTP Request node v4.3 does not send for ${operation.method}`);
+    }
+    return node({
+        type: 'n8n-nodes-base.httpRequest',
+        version: 4.3,
+        config: {
+            id,
+            name,
+            position,
+            parameters: {
+                method: operation.method,
+                url,
+                ...authentication?.parameters,
+                ...(headers.length
+                    ? {
+                        sendHeaders: true,
+                        specifyHeaders: 'keypair',
+                        headerParameters: { parameters: headers },
+                    }
+                    : {}),
+                ...(body === undefined
+                    ? {}
+                    : body.contentType === 'json'
+                        ? {
+                            sendBody: true,
+                            contentType: 'json',
+                            specifyBody: 'json',
+                            jsonBody: body.value,
+                        }
+                        : {
+                            sendBody: true,
+                            contentType: 'raw',
+                            rawContentType: 'application/x-www-form-urlencoded',
+                            body: body.value,
+                        }),
+                options: {
+                    response: {
+                        response: {
+                            fullResponse: true,
+                            ...(shouldAssert ? { neverError: true } : {}),
+                            responseFormat: 'autodetect',
+                        },
+                    },
+                },
+            },
+            ...(authentication ? { credentials: authentication.credentials } : {}),
+        },
+    });
+}

package/dist/legacy/workflow/request/prepare-sequence.d.ts

@@ -0,0 +1,4 @@
+import type { PrepareStepsInput } from './../../../types/legacy/catalog-workflow.js';
+import type { PreparedSequence, PrepareSequenceInput } from '../../../types/legacy/sequence-workflow.js';
+export declare function prepareSequence({ document, origin, profile, effectPolicy, credentialBindings, plan, }: PrepareSequenceInput): PreparedSequence;
+export declare function prepareSteps({ profile, plan, resolveStep, }: PrepareStepsInput): PreparedSequence;

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

@@ -0,0 +1,103 @@
+import { operationFromDocument } from '@openapi-flow/core/internal';
+import { validateResponseField } from '@openapi-flow/core/internal';
+import { isObject } from '@openapi-flow/core/internal';
+import { approvedEffect, isSafeMethod } from './effect-policy.js';
+import { looksLikeCredential, resolveCredentialBinding, } from './credential-binding.js';
+import { makeBody } from './request-body.js';
+import { makeHeaders } from './request-headers.js';
+import { sequenceUrl } from './sequence-url.js';
+export function prepareSequence({ document, origin, profile, effectPolicy, credentialBindings, plan, }) {
+    return prepareSteps({
+        profile,
+        plan,
+        resolveStep: (step) => ({
+            operation: operationFromDocument(document, step.operationRef),
+            origin,
+            effectPolicy,
+            credentialBindings,
+        }),
+    });
+}
+export function prepareSteps({ profile, plan, resolveStep, }) {
+    const previous = new Map();
+    const requiredOutputs = new Map();
+    const evidence = [];
+    const missingInputs = [];
+    const nodes = [];
+    let blocked = false;
+    for (const step of plan.steps) {
+        if (!isObject(step) ||
+            typeof step.id !== 'string' ||
+            !step.id.trim() ||
+            previous.has(step.id) ||
+            typeof step.operationRef !== 'string') {
+            throw new Error('plan.steps must have unique id and operationRef values');
+        }
+        const source = resolveStep(step);
+        const { operation, origin, effectPolicy, credentialBindings } = source;
+        const effect = approvedEffect(operation, effectPolicy);
+        const authentication = resolveCredentialBinding(operation, credentialBindings);
+        const inputs = step.inputs === undefined ? {} : step.inputs;
+        const expectedBody = step.expectedBody === undefined ? {} : step.expectedBody;
+        if (!isObject(inputs) || !isObject(expectedBody)) {
+            throw new Error('plan.steps[' + step.id + '] inputs and expectedBody must be objects');
+        }
+        for (const [key, value] of Object.entries(expectedBody)) {
+            if (looksLikeCredential(key)) {
+                throw new Error('plan.steps[' +
+                    step.id +
+                    '].expectedBody.' +
+                    key +
+                    ' looks like a credential');
+            }
+            validateResponseField(operation, key, value, 'plan.steps[' + step.id + '].expectedBody.' + key);
+        }
+        const allowed = new Set(operation.parameters.map((parameter) => parameter.in + '.' + parameter.name));
+        if (operation.body)
+            allowed.add('body');
+        for (const key of Object.keys(inputs)) {
+            if (!allowed.has(key))
+                throw new Error('plan.steps[' +
+                    step.id +
+                    '].inputs.' +
+                    key +
+                    ' is not declared in OAS');
+            if (looksLikeCredential(key)) {
+                throw new Error('plan.steps[' +
+                    step.id +
+                    '].inputs.' +
+                    key +
+                    ' looks like a credential');
+            }
+        }
+        const stepMissing = [];
+        const url = sequenceUrl(operation, origin, inputs, previous, requiredOutputs, stepMissing);
+        const body = makeBody(operation, inputs, stepMissing, step.requestMediaType);
+        const headers = makeHeaders(operation, inputs, stepMissing);
+        missingInputs.push(...stepMissing.map((key) => step.id + '.' + key));
+        if (effect === 'unknown' ||
+            (!isSafeMethod(operation.method) && effect !== 'write') ||
+            (profile === 'read-only' &&
+                (!isSafeMethod(operation.method) || effect !== 'read')))
+            blocked = true;
+        evidence.push({
+            stepId: step.id,
+            operationRef: operation.operationRef,
+            operationId: operation.operationId,
+            method: operation.method,
+            path: operation.path,
+            effect,
+        });
+        nodes.push({
+            operation,
+            id: step.id,
+            url,
+            body,
+            headers,
+            expectedBody: expectedBody,
+            authentication,
+        });
+        previous.set(step.id, operation);
+    }
+    return { evidence, missingInputs, nodes, requiredOutputs, blocked };
+}

package/dist/legacy/workflow/request/request-body.d.ts

@@ -0,0 +1,4 @@
+import type { Operation } from '@openapi-flow/core/internal';
+import type { PreparedRequestBody } from '../../../types/legacy/request-node.js';
+import type { InputValues } from '../../../types/legacy/request-workflow.js';
+export declare function makeBody(operation: Operation, inputs: InputValues, missing: string[], requestMediaType?: string): PreparedRequestBody | undefined;

package/dist/legacy/workflow/request/request-body.js

@@ -0,0 +1,64 @@
+import { checkSchemaValue } from '@openapi-flow/core/internal';
+import { UnsupportedOperationError } from '@openapi-flow/core/internal';
+import { serializeFormBody } from '@openapi-flow/core/internal';
+import { isObject } from '@openapi-flow/core/internal';
+import { looksLikeCredential } from '../../../nodes/request/authentication/credential-field-name.js';
+export function makeBody(operation, inputs, missing, requestMediaType) {
+    if (!operation.body) {
+        if (requestMediaType !== undefined)
+            throw new Error('plan.requestMediaType is not declared by the OAS operation');
+        return undefined;
+    }
+    if (requestMediaType !== undefined &&
+        !Object.hasOwn(operation.body.mediaTypes, requestMediaType)) {
+        throw new Error('plan.requestMediaType is not declared by the OAS operation');
+    }
+    const value = inputs.body;
+    if (value === undefined) {
+        if (operation.body.required)
+            missing.push('body');
+        return undefined;
+    }
+    const declared = Object.keys(operation.body.mediaTypes);
+    const mediaType = requestMediaType ?? (declared.length === 1 ? declared[0] : undefined);
+    if (mediaType === undefined) {
+        missing.push('requestMediaType');
+        return undefined;
+    }
+    const media = operation.body.mediaTypes[mediaType];
+    if (mediaType !== 'application/json' &&
+        mediaType !== 'application/x-www-form-urlencoded') {
+        throw new UnsupportedOperationError(operation.operationRef, `operationRef ${operation.operationRef}.requestBody media type ${mediaType} has no n8n mapping`);
+    }
+    if (isObject(value)) {
+        for (const name of Object.keys(value)) {
+            if (looksLikeCredential(name)) {
+                throw new Error('plan.inputs.body.' +
+                    name +
+                    ' looks like a credential; bind an existing n8n credential through credentialBindings instead');
+            }
+        }
+        if (typeof media.schema === 'object' &&
+            Array.isArray(media.schema.required)) {
+            for (const name of media.schema.required) {
+                if (typeof name === 'string' && !Object.hasOwn(value, name)) {
+                    missing.push('body.' + name);
+                }
+            }
+        }
+    }
+    if (missing.some((key) => key.startsWith('body.')))
+        return undefined;
+    if (media.schema !== undefined)
+        checkSchemaValue(value, media.schema, 'plan.inputs.body');
+    if (mediaType === 'application/json') {
+        return { contentType: 'json', value: JSON.stringify(value) };
+    }
+    if (!isObject(value)) {
+        throw new Error('plan.inputs.body must be an object for application/x-www-form-urlencoded');
+    }
+    return {
+        contentType: 'form-urlencoded',
+        value: serializeFormBody(operation.operationRef, media, value),
+    };
+}

package/dist/legacy/workflow/request/request-headers.d.ts

@@ -0,0 +1,4 @@
+import type { Operation } from '@openapi-flow/core/internal';
+import type { RequestHeader } from '../../../types/legacy/request-node.js';
+import type { InputValues } from '../../../types/legacy/request-workflow.js';
+export declare function makeHeaders(operation: Operation, inputs: InputValues, missing: string[]): RequestHeader[];

package/dist/legacy/workflow/request/request-headers.js

@@ -0,0 +1,30 @@
+import { checkSchemaValue } from '@openapi-flow/core/internal';
+import { serializeCookieParameter, serializeHeaderParameter, } from '@openapi-flow/core/internal';
+export function makeHeaders(operation, inputs, missing) {
+    const headers = [];
+    const cookies = [];
+    for (const parameter of operation.parameters) {
+        if (parameter.in !== 'header' && parameter.in !== 'cookie')
+            continue;
+        const key = parameter.in + '.' + parameter.name;
+        const value = inputs[key];
+        if (value === undefined) {
+            if (parameter.required)
+                missing.push(key);
+            continue;
+        }
+        checkSchemaValue(value, parameter.schema, 'plan.inputs.' + key);
+        if (parameter.in === 'header') {
+            headers.push({
+                name: parameter.name,
+                value: serializeHeaderParameter(parameter, operation.operationRef, value),
+            });
+        }
+        else {
+            cookies.push(...serializeCookieParameter(parameter, operation.operationRef, value));
+        }
+    }
+    if (cookies.length)
+        headers.push({ name: 'Cookie', value: cookies.join('; ') });
+    return headers;
+}

package/dist/legacy/workflow/request/request-url.d.ts

@@ -0,0 +1,4 @@
+import type { Operation } from '@openapi-flow/core/internal';
+import type { InputValues } from '../../../types/legacy/request-workflow.js';
+export declare function absoluteOperationPath(baseUrl: URL, path: string): string;
+export declare function makeUrl(operation: Operation, origin: URL, inputs: InputValues, missing: string[]): string;