@openapi-flow/core 0.1.0 → 0.2.0

package/dist/openapi/common/normalize-oas-value-schema.js

@@ -0,0 +1,50 @@
+import { isObject } from '../../utils/is-object.js';
+/** Convert only OAS 3.0 assertion syntax, not formats, annotations or data. */
+export function normalizeOasValueSchema(input, dialect) {
+    if (dialect === 'draft-2020-12' || typeof input === 'boolean')
+        return structuredClone(input);
+    const schema = structuredClone(input);
+    if (schema.nullable === true && typeof schema.type === 'string')
+        schema.type = [schema.type, 'null'];
+    delete schema.nullable;
+    for (const bound of ['Minimum', 'Maximum']) {
+        const exclusive = `exclusive${bound}`;
+        const inclusive = bound.toLowerCase();
+        if (typeof schema[exclusive] !== 'boolean')
+            continue;
+        if (schema[exclusive] === true && typeof schema[inclusive] === 'number') {
+            schema[exclusive] = schema[inclusive];
+            delete schema[inclusive];
+        }
+        else
+            delete schema[exclusive];
+    }
+    for (const key of [
+        'properties',
+        'patternProperties',
+        '$defs',
+        'definitions',
+    ]) {
+        if (!isObject(schema[key]))
+            continue;
+        schema[key] = Object.fromEntries(Object.entries(schema[key]).map(([name, child]) => [
+            name,
+            isObject(child) || typeof child === 'boolean'
+                ? normalizeOasValueSchema(child, dialect)
+                : child,
+        ]));
+    }
+    for (const key of ['items', 'additionalProperties', 'not']) {
+        const child = schema[key];
+        if (isObject(child) || typeof child === 'boolean')
+            schema[key] = normalizeOasValueSchema(child, dialect);
+    }
+    for (const key of ['allOf', 'anyOf', 'oneOf', 'prefixItems']) {
+        if (!Array.isArray(schema[key]))
+            continue;
+        schema[key] = schema[key].map((child) => isObject(child) || typeof child === 'boolean'
+            ? normalizeOasValueSchema(child, dialect)
+            : child);
+    }
+    return schema;
+}

package/dist/openapi/common/operation-metadata.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject, OperationMetadata } from '../../types/openapi.js';
+export declare function operationMetadata(operation: JsonObject, source: string): OperationMetadata;

package/dist/openapi/common/operation-metadata.js

@@ -0,0 +1,25 @@
+export function operationMetadata(operation, source) {
+    if (operation.operationId !== undefined &&
+        typeof operation.operationId !== 'string') {
+        throw new Error(`${source}.operationId must be a string`);
+    }
+    if (operation.tags !== undefined &&
+        (!Array.isArray(operation.tags) ||
+            !operation.tags.every((tag) => typeof tag === 'string'))) {
+        throw new Error(`${source}.tags must be an array of strings`);
+    }
+    if (operation.summary !== undefined &&
+        typeof operation.summary !== 'string') {
+        throw new Error(`${source}.summary must be a string`);
+    }
+    if (operation.description !== undefined &&
+        typeof operation.description !== 'string') {
+        throw new Error(`${source}.description must be a string`);
+    }
+    return {
+        operationId: operation.operationId,
+        summary: operation.summary === undefined ? '' : operation.summary,
+        description: operation.description === undefined ? '' : operation.description,
+        tags: operation.tags === undefined ? [] : operation.tags,
+    };
+}

package/dist/openapi/common/operation-reference.d.ts

@@ -0,0 +1,3 @@
+import type { OperationEntry } from '../../types/openapi.js';
+export declare function pointerSegment(value: string): string;
+export declare function operationEntries(pathItem: Record<string, unknown>): OperationEntry[];

package/dist/openapi/{operation-reference.js → common/operation-reference.js}

@@ -9,7 +9,7 @@ const methods = [
     'trace',
     'query',
 ];
-function pointerSegment(value) {
+export function pointerSegment(value) {
     return value.replace(/~/g, '~0').replace(/\//g, '~1');
 }
 export function operationEntries(pathItem) {
@@ -36,6 +36,3 @@ export function operationEntries(pathItem) {
     }
     return entries;
 }
-export function operationReference(path, key) {
-    return '#/paths/' + pointerSegment(path) + '/' + key;
-}

package/dist/openapi/common/parse-spec-utils.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject } from '../../types/openapi.js';
+export declare function object(value: unknown, source: string): JsonObject;
+export declare function dereferencedObject(value: unknown, source: string): JsonObject;

package/dist/openapi/common/parse-spec-utils.js

@@ -0,0 +1,12 @@
+export function object(value, source) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${source} must be an object`);
+    }
+    return value;
+}
+export function dereferencedObject(value, source) {
+    const item = object(value, source);
+    if (item.$ref !== undefined)
+        throw new Error(`${source} has an unresolved $ref`);
+    return item;
+}

package/dist/openapi/common/resolve-openapi-security.d.ts

@@ -0,0 +1,3 @@
+import type { ResolveOpenApiSecurityInput, ResolvedOpenApiSecurity } from '../../types/security.js';
+/** Preserve OAS OR alternatives and AND schemes; adapters own credential mappings. */
+export declare function resolveOpenApiSecurity(input: ResolveOpenApiSecurityInput): ResolvedOpenApiSecurity | undefined;

package/dist/openapi/common/resolve-openapi-security.js

@@ -0,0 +1,28 @@
+import { dereferencedObject, object } from './parse-spec-utils.js';
+/** Preserve OAS OR alternatives and AND schemes; adapters own credential mappings. */
+export function resolveOpenApiSecurity(input) {
+    const source = `${input.operationRef}.security`;
+    if (!Array.isArray(input.security))
+        throw new Error(`${source} must be an array`);
+    if (!input.security.length && input.requirementIndex === undefined)
+        return undefined;
+    if (input.security.length > 1 && input.requirementIndex === undefined)
+        throw new Error(`${source} has alternatives; securityRequirementIndex is required`);
+    const index = input.requirementIndex === undefined ? 0 : input.requirementIndex;
+    if (!Number.isInteger(index) || index < 0 || index >= input.security.length)
+        throw new Error(`${source} securityRequirementIndex ${index} is not declared`);
+    const requirement = object(input.security[index], `${source}[${index}]`);
+    return {
+        requirementIndex: index,
+        schemes: Object.entries(requirement).map(([name, scopes]) => {
+            if (!Array.isArray(scopes) ||
+                scopes.some((scope) => typeof scope !== 'string'))
+                throw new Error(`${source}[${index}].${name} scopes must be strings`);
+            return {
+                name,
+                scopes: [...scopes],
+                definition: dereferencedObject(input.securitySchemes[name], `${input.operationRef}.securitySchemes.${name}`),
+            };
+        }),
+    };
+}

package/dist/openapi/common/unsupported-operation-error.d.ts

@@ -0,0 +1,4 @@
+export declare class UnsupportedOperationError extends Error {
+    readonly operationRef: string;
+    constructor(operationRef: string, message: string);
+}

package/dist/openapi/common/unsupported-operation-error.js

@@ -0,0 +1,8 @@
+export class UnsupportedOperationError extends Error {
+    operationRef;
+    constructor(operationRef, message) {
+        super(message);
+        this.name = 'UnsupportedOperationError';
+        this.operationRef = operationRef;
+    }
+}

package/dist/openapi/common/validate-spec.d.ts

@@ -0,0 +1,3 @@
+import type { OpenApiDocument, ParsedDocument } from '../../types/openapi.js';
+export declare function validateOpenApi(input: unknown): OpenApiDocument;
+export declare function validateAndResolveOpenApiDocument(input: OpenApiDocument): Promise<ParsedDocument>;

package/dist/openapi/{validate-spec.js → common/validate-spec.js}

@@ -17,9 +17,10 @@ export function validateOpenApi(input) {
         throw new Error('spec OpenAPI validation failed: ' +
             result.errors.map((error) => error.message).join('; '));
     }
+    // The external validator proved the OpenAPI contract before narrowing.
     return spec;
 }
-export async function validatedDocument(input) {
+export async function validateAndResolveOpenApiDocument(input) {
     const spec = validateOpenApi(input);
     const result = await resolveAndValidate(spec);
     if (!result.valid) {

package/dist/openapi/inbound/callback/parse-callback-operations.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedDocument } from '../../../types/openapi.js';
+import type { CallbackOperationSource } from '../../../types/inbound.js';
+export declare function callbackOperationsFromDocument(document: ParsedDocument): CallbackOperationSource[];

package/dist/openapi/inbound/callback/parse-callback-operations.js

@@ -0,0 +1,31 @@
+import { operationEntries, pointerSegment, } from '../../common/operation-reference.js';
+import { dereferencedObject, object } from '../../common/parse-spec-utils.js';
+import { inboundPathItemOperations } from '../inbound-path-item-operations.js';
+export function callbackOperationsFromDocument(document) {
+    const candidates = [];
+    for (const [path, rawPathItem] of Object.entries(document.paths)) {
+        const pathItem = dereferencedObject(rawPathItem, `spec.paths[${path}]`);
+        for (const entry of operationEntries(pathItem)) {
+            const parentOperationRef = '#/paths/' + pointerSegment(path) + '/' + entry.key;
+            const operation = object(entry.value, `operationRef ${parentOperationRef}`);
+            if (operation.callbacks === undefined)
+                continue;
+            const callbacks = object(operation.callbacks, `operationRef ${parentOperationRef}.callbacks`);
+            for (const [name, rawCallback] of Object.entries(callbacks)) {
+                const callback = dereferencedObject(rawCallback, `operationRef ${parentOperationRef}.callbacks.${name}`);
+                for (const [expression, raw] of Object.entries(callback)) {
+                    if (expression.startsWith('x-'))
+                        continue;
+                    const pointer = parentOperationRef +
+                        '/callbacks/' +
+                        pointerSegment(name) +
+                        '/' +
+                        pointerSegment(expression);
+                    const callbackPathItem = dereferencedObject(raw, `operationRef ${pointer}`);
+                    candidates.push(...inboundPathItemOperations(callbackPathItem, expression, pointer, 'callbacks', parentOperationRef));
+                }
+            }
+        }
+    }
+    return candidates;
+}

package/dist/openapi/inbound/inbound-path-item-operations.d.ts

@@ -0,0 +1,4 @@
+import type { JsonObject } from '../../types/openapi.js';
+import type { CallbackOperationSource, WebhookOperationSource } from '../../types/inbound.js';
+export declare function inboundPathItemOperations(pathItem: JsonObject, path: string, pointer: string, source: 'webhooks'): WebhookOperationSource[];
+export declare function inboundPathItemOperations(pathItem: JsonObject, path: string, pointer: string, source: 'callbacks', parentOperationRef: string): CallbackOperationSource[];

package/dist/openapi/inbound/inbound-path-item-operations.js

@@ -0,0 +1,31 @@
+import { operationMetadata } from '../common/operation-metadata.js';
+import { operationEntries } from '../common/operation-reference.js';
+import { object } from '../common/parse-spec-utils.js';
+function requiredCallbackParent(pointer, parentOperationRef) {
+    if (parentOperationRef === undefined)
+        throw new Error(`operationRef ${pointer} callback has no parent operation`);
+    return parentOperationRef;
+}
+export function inboundPathItemOperations(pathItem, path, pointer, source, parentOperationRef) {
+    return operationEntries(pathItem).map((entry) => {
+        const operationRef = pointer + '/' + entry.key;
+        const operation = object(entry.value, `operationRef ${operationRef}`);
+        const shared = {
+            operationRef,
+            ...operationMetadata(operation, `operationRef ${operationRef}`),
+            method: entry.method,
+            path,
+        };
+        const result = source === 'callbacks'
+            ? {
+                candidate: {
+                    ...shared,
+                    source,
+                    parentOperationRef: requiredCallbackParent(pointer, parentOperationRef),
+                },
+                operation,
+            }
+            : { candidate: { ...shared, source }, operation };
+        return result;
+    });
+}

package/dist/openapi/inbound/list-inbound-operations.d.ts

@@ -0,0 +1,4 @@
+import type { OpenApiDocument, ParsedDocument } from '../../types/openapi.js';
+import type { InboundOperationCandidate, InboundOperationSource } from '../../types/inbound.js';
+export declare function inboundOperationSourcesFromDocument(document: ParsedDocument): InboundOperationSource[];
+export declare function inboundOperationsFromSpec(input: OpenApiDocument): Promise<InboundOperationCandidate[]>;

package/dist/openapi/inbound/list-inbound-operations.js

@@ -0,0 +1,13 @@
+import { validateAndResolveOpenApiDocument } from '../common/validate-spec.js';
+import { callbackOperationsFromDocument } from './callback/parse-callback-operations.js';
+import { webhookOperationsFromDocument } from './webhook/parse-webhook-operations.js';
+export function inboundOperationSourcesFromDocument(document) {
+    return [
+        ...webhookOperationsFromDocument(document),
+        ...callbackOperationsFromDocument(document),
+    ];
+}
+export async function inboundOperationsFromSpec(input) {
+    const document = await validateAndResolveOpenApiDocument(input);
+    return inboundOperationSourcesFromDocument(document).map((source) => source.candidate);
+}

package/dist/openapi/inbound/webhook/parse-webhook-operations.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedDocument } from '../../../types/openapi.js';
+import type { WebhookOperationSource } from '../../../types/inbound.js';
+export declare function webhookOperationsFromDocument(document: ParsedDocument): WebhookOperationSource[];

package/dist/openapi/inbound/webhook/parse-webhook-operations.js

@@ -0,0 +1,13 @@
+import { pointerSegment } from '../../common/operation-reference.js';
+import { dereferencedObject, object } from '../../common/parse-spec-utils.js';
+import { inboundPathItemOperations } from '../inbound-path-item-operations.js';
+export function webhookOperationsFromDocument(document) {
+    if (document.spec.webhooks === undefined)
+        return [];
+    const webhooks = object(document.spec.webhooks, 'spec.webhooks');
+    return Object.entries(webhooks).flatMap(([name, raw]) => {
+        const pointer = '#/webhooks/' + pointerSegment(name);
+        const pathItem = dereferencedObject(raw, `spec.webhooks[${name}]`);
+        return inboundPathItemOperations(pathItem, name, pointer, 'webhooks');
+    });
+}

package/dist/openapi/request/create-operation-catalog.d.ts

@@ -0,0 +1,2 @@
+import type { CatalogSource, OperationCatalog } from '../../types/catalog.js';
+export declare function createOperationCatalog(sources: CatalogSource[]): Promise<OperationCatalog>;

package/dist/openapi/request/create-operation-catalog.js

@@ -0,0 +1,24 @@
+import { validateAndResolveOpenApiDocument } from '../common/validate-spec.js';
+import { operationsFromDocument } from './parse-request-operations.js';
+import { isObject } from '../../utils/is-object.js';
+export async function createOperationCatalog(sources) {
+    if (!Array.isArray(sources) || sources.length === 0)
+        throw new Error('sources must be a non-empty array of OAS documents');
+    const catalog = { sources: new Map(), entries: [] };
+    for (const source of sources) {
+        if (!isObject(source) || typeof source.id !== 'string' || !source.id.trim())
+            throw new Error('sources[].id must be a non-empty string');
+        if (catalog.sources.has(source.id))
+            throw new Error(`sources has duplicate id ${source.id}`);
+        try {
+            const document = await validateAndResolveOpenApiDocument(source.spec);
+            const operations = operationsFromDocument(document);
+            catalog.sources.set(source.id, { ...source, document, operations });
+            catalog.entries.push(...operations.map((candidate) => ({ id: source.id, candidate })));
+        }
+        catch (error) {
+            throw new Error(`sources[${source.id}] is invalid`, { cause: error });
+        }
+    }
+    return catalog;
+}

package/dist/openapi/request/encode-form-field.d.ts

@@ -0,0 +1,2 @@
+/** WHATWG form percent-encode set; works in restricted n8n Code VMs too. */
+export declare function encodeFormField(value: string): string;

package/dist/openapi/request/encode-form-field.js

@@ -0,0 +1,6 @@
+/** WHATWG form percent-encode set; works in restricted n8n Code VMs too. */
+export function encodeFormField(value) {
+    return encodeURIComponent(value.toWellFormed())
+        .replace(/[!'()~]/g, (character) => '%' + character.charCodeAt(0).toString(16).toUpperCase())
+        .replaceAll('%20', '+');
+}

package/dist/openapi/request/map-http-operation-contract.d.ts

@@ -0,0 +1,4 @@
+import type { JsonObject, OperationMethod } from '../../types/openapi.js';
+import type { Operation } from '../../types/request.js';
+/** HTTP contracts only. Authentication is resolved separately by the engine adapter. */
+export declare function mapHttpOperationContract(path: string, method: OperationMethod, operationRef: string, pathItem: JsonObject, raw: unknown): Operation;

package/dist/openapi/request/map-http-operation-contract.js

@@ -0,0 +1,21 @@
+import { operationMetadata } from '../common/operation-metadata.js';
+import { object } from '../common/parse-spec-utils.js';
+import { parseOperationResponses } from './parse-operation-responses.js';
+import { parseRequestBody } from './parse-request-body.js';
+import { parseRequestParameters } from './parse-request-parameters.js';
+/** HTTP contracts only. Authentication is resolved separately by the engine adapter. */
+export function mapHttpOperationContract(path, method, operationRef, pathItem, raw) {
+    const operation = object(raw, `spec.paths[${path}].${method.toLowerCase()}`);
+    if (!path.startsWith('/'))
+        throw new Error(`operationRef ${operationRef} path must start with /`);
+    return {
+        operationRef,
+        source: 'paths',
+        ...operationMetadata(operation, `operationRef ${operationRef}`),
+        method,
+        path,
+        parameters: parseRequestParameters(path, pathItem, operation, operationRef),
+        body: parseRequestBody(operation, operationRef),
+        responses: parseOperationResponses(operation, operationRef),
+    };
+}

package/dist/openapi/request/operation-mapping.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject, OperationMethod } from '../../types/openapi.js';
+import type { Operation } from '../../types/request.js';
+export declare function mapOperationForWorkflow(spec: JsonObject, path: string, method: OperationMethod, operationRef: string, pathItem: JsonObject, raw: unknown): Operation;

package/dist/openapi/request/operation-mapping.js

@@ -0,0 +1,10 @@
+import { object } from '../common/parse-spec-utils.js';
+import { parseOperationSecurity } from './parse-security.js';
+import { mapHttpOperationContract } from './map-http-operation-contract.js';
+export function mapOperationForWorkflow(spec, path, method, operationRef, pathItem, raw) {
+    const operation = object(raw, `spec.paths[${path}].${method.toLowerCase()}`);
+    return {
+        ...mapHttpOperationContract(path, method, operationRef, pathItem, operation),
+        authentication: parseOperationSecurity(spec, operation, operationRef),
+    };
+}

package/dist/openapi/request/parse-operation-responses.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject } from '../../types/openapi.js';
+import type { OperationResponses } from '../../types/request.js';
+export declare function parseOperationResponses(operation: JsonObject, operationRef: string): OperationResponses;

package/dist/openapi/request/parse-operation-responses.js

@@ -0,0 +1,30 @@
+import { dereferencedObject, object } from '../common/parse-spec-utils.js';
+export function parseOperationResponses(operation, operationRef) {
+    const responses = object(operation.responses, `operationRef ${operationRef}.responses`);
+    const parsedResponses = {};
+    for (const [responseCode, rawResponse] of Object.entries(responses)) {
+        const response = dereferencedObject(rawResponse, `operationRef ${operationRef}.responses.${responseCode}`);
+        const responseProperties = {};
+        if (response.content !== undefined) {
+            const content = object(response.content, `operationRef ${operationRef}.responses.${responseCode}.content`);
+            if (content['application/json'] !== undefined) {
+                const media = object(content['application/json'], `operationRef ${operationRef}.responses.${responseCode}.application/json`);
+                const responseSchema = media.schema === undefined || typeof media.schema === 'boolean'
+                    ? undefined
+                    : dereferencedObject(media.schema, `operationRef ${operationRef}.responses.${responseCode}.schema`);
+                if (responseSchema?.type === 'object' &&
+                    responseSchema.properties !== undefined) {
+                    const properties = object(responseSchema.properties, `operationRef ${operationRef}.responses.${responseCode}.schema.properties`);
+                    for (const [name, property] of Object.entries(properties)) {
+                        responseProperties[name] =
+                            typeof property === 'boolean'
+                                ? property
+                                : dereferencedObject(property, `operationRef ${operationRef}.responses.${responseCode}.schema.properties.${name}`);
+                    }
+                }
+            }
+        }
+        parsedResponses[responseCode] = responseProperties;
+    }
+    return parsedResponses;
+}

package/dist/openapi/request/parse-request-body.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject } from '../../types/openapi.js';
+import type { OperationBody } from '../../types/request.js';
+export declare function parseRequestBody(operation: JsonObject, operationRef: string): OperationBody | undefined;

package/dist/openapi/request/parse-request-body.js

@@ -0,0 +1,29 @@
+import { dereferencedObject, object } from '../common/parse-spec-utils.js';
+export function parseRequestBody(operation, operationRef) {
+    if (operation.requestBody === undefined)
+        return undefined;
+    const requestBody = dereferencedObject(operation.requestBody, `operationRef ${operationRef}.requestBody`);
+    const content = object(requestBody.content, `operationRef ${operationRef}.requestBody.content`);
+    const mediaTypes = Object.create(null);
+    for (const [mediaType, value] of Object.entries(content)) {
+        const media = object(value, `operationRef ${operationRef}.requestBody.${mediaType}`);
+        const bodySchema = media.schema === undefined
+            ? undefined
+            : typeof media.schema === 'boolean'
+                ? media.schema
+                : dereferencedObject(media.schema, `operationRef ${operationRef}.requestBody.${mediaType}.schema`);
+        const properties = typeof bodySchema !== 'object' || bodySchema.properties === undefined
+            ? {}
+            : object(bodySchema.properties, `operationRef ${operationRef}.requestBody.${mediaType}.schema.properties`);
+        mediaTypes[mediaType] = {
+            schema: bodySchema,
+            properties,
+            ...(media.encoding === undefined
+                ? {}
+                : {
+                    encoding: object(media.encoding, `operationRef ${operationRef}.requestBody.${mediaType}.encoding`),
+                }),
+        };
+    }
+    return { required: requestBody.required === true, mediaTypes };
+}

package/dist/openapi/request/parse-request-operations.d.ts

@@ -0,0 +1,7 @@
+import type { OpenApiDocument, OperationCandidate, ParsedDocument } from '../../types/openapi.js';
+import type { Operation, OperationSource } from '../../types/request.js';
+export declare function operationsFromDocument({ paths, }: ParsedDocument): OperationCandidate[];
+export declare function operationsFromSpec(input: OpenApiDocument): Promise<OperationCandidate[]>;
+export declare function operationFromSpec(input: OpenApiDocument, operationRef: string): Promise<Operation>;
+export declare function selectedOperationSource(parsed: ParsedDocument, operationRef: string): OperationSource;
+export declare function operationFromDocument(parsed: ParsedDocument, operationRef: string): Operation;

package/dist/openapi/request/parse-request-operations.js

@@ -0,0 +1,50 @@
+import { mapOperationForWorkflow } from './operation-mapping.js';
+import { operationMetadata } from '../common/operation-metadata.js';
+import { operationEntries } from '../common/operation-reference.js';
+import { dereferencedObject, object } from '../common/parse-spec-utils.js';
+import { validateAndResolveOpenApiDocument } from '../common/validate-spec.js';
+import { requestOperationReference } from './request-operation-reference.js';
+export function operationsFromDocument({ paths, }) {
+    const operations = [];
+    for (const [path, pathValue] of Object.entries(paths)) {
+        const pathItem = dereferencedObject(pathValue, `spec.paths[${path}]`);
+        for (const { method, key, value } of operationEntries(pathItem)) {
+            const operation = object(value, `spec.paths[${path}].${key}`);
+            operations.push({
+                operationRef: requestOperationReference(path, key),
+                source: 'paths',
+                ...operationMetadata(operation, `spec.paths[${path}].${key}`),
+                method,
+                path,
+            });
+        }
+    }
+    const ids = operations.flatMap(({ operationId }) => operationId === undefined ? [] : [operationId]);
+    if (new Set(ids).size !== ids.length)
+        throw new Error('spec.paths has duplicate operationId values');
+    return operations;
+}
+export async function operationsFromSpec(input) {
+    return operationsFromDocument(await validateAndResolveOpenApiDocument(input));
+}
+export async function operationFromSpec(input, operationRef) {
+    return operationFromDocument(await validateAndResolveOpenApiDocument(input), operationRef);
+}
+export function selectedOperationSource(parsed, operationRef) {
+    const candidates = operationsFromDocument(parsed);
+    const matches = candidates.filter((item) => item.operationRef === operationRef || item.operationId === operationRef);
+    if (matches.length > 1)
+        throw new Error('plan.operationRef identifies multiple operations: ' + operationRef);
+    const candidate = matches[0];
+    if (!candidate)
+        throw new Error('plan.operationRef is not in spec.paths: ' + operationRef);
+    const pathItem = dereferencedObject(parsed.paths[candidate.path], `spec.paths[${candidate.path}]`);
+    const operationEntry = operationEntries(pathItem).find(({ key }) => requestOperationReference(candidate.path, key) === candidate.operationRef);
+    if (!operationEntry)
+        throw new Error('spec.paths is missing operation: ' + candidate.operationRef);
+    return { candidate, pathItem, entry: operationEntry };
+}
+export function operationFromDocument(parsed, operationRef) {
+    const { candidate, pathItem, entry } = selectedOperationSource(parsed, operationRef);
+    return mapOperationForWorkflow(parsed.spec, candidate.path, candidate.method, candidate.operationRef, pathItem, entry.value);
+}

package/dist/openapi/request/parse-request-parameters.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject } from '../../types/openapi.js';
+import type { OperationParameter } from '../../types/request.js';
+export declare function parseRequestParameters(path: string, pathItem: JsonObject, operation: JsonObject, operationRef: string): OperationParameter[];

package/dist/openapi/request/parse-request-parameters.js

@@ -0,0 +1,93 @@
+import { dereferencedObject, object } from '../common/parse-spec-utils.js';
+import { UnsupportedOperationError } from '../common/unsupported-operation-error.js';
+function parseParameter(raw, operationRef, index) {
+    const parameter = dereferencedObject(raw, `operationRef ${operationRef} parameter ${index}`);
+    if (typeof parameter.name !== 'string' ||
+        !parameter.name ||
+        (parameter.in === 'path' && parameter.required !== true)) {
+        throw new Error(`operationRef ${operationRef} has an invalid parameter`);
+    }
+    if (!['path', 'query', 'header', 'cookie'].includes(String(parameter.in))) {
+        throw new UnsupportedOperationError(operationRef, `operationRef ${operationRef} has an unsupported parameter`);
+    }
+    if (parameter.in === 'header' &&
+        ['accept', 'content-type', 'authorization'].includes(parameter.name.toLowerCase())) {
+        return undefined;
+    }
+    let schema;
+    let contentMediaType;
+    if (parameter.content !== undefined) {
+        const content = object(parameter.content, `operationRef ${operationRef} parameter ${parameter.name}.content`);
+        const types = Object.keys(content);
+        if (types.length !== 1 || types[0] !== 'application/json')
+            throw new UnsupportedOperationError(operationRef, `operationRef ${operationRef} parameter ${parameter.name} content media type is not mapped`);
+        contentMediaType = types[0];
+        const media = dereferencedObject(content[contentMediaType], `operationRef ${operationRef} parameter ${parameter.name}.content.${contentMediaType}`);
+        schema =
+            media.schema === undefined
+                ? true
+                : typeof media.schema === 'boolean'
+                    ? media.schema
+                    : dereferencedObject(media.schema, `operationRef ${operationRef} parameter ${parameter.name}.content.${contentMediaType}.schema`);
+    }
+    else {
+        schema =
+            typeof parameter.schema === 'boolean'
+                ? parameter.schema
+                : dereferencedObject(parameter.schema, `operationRef ${operationRef} parameter ${parameter.name}.schema`);
+    }
+    const style = typeof parameter.style === 'string'
+        ? parameter.style
+        : parameter.in === 'path' || parameter.in === 'header'
+            ? 'simple'
+            : 'form';
+    const explode = typeof parameter.explode === 'boolean'
+        ? parameter.explode
+        : style === 'form' || style === 'cookie';
+    return {
+        name: parameter.name,
+        in: parameter.in,
+        required: parameter.required === true,
+        schema,
+        style,
+        explode,
+        allowReserved: parameter.allowReserved === true,
+        ...(contentMediaType === undefined ? {} : { contentMediaType }),
+    };
+}
+export function parseRequestParameters(path, pathItem, operation, operationRef) {
+    if ((pathItem.parameters !== undefined &&
+        !Array.isArray(pathItem.parameters)) ||
+        (operation.parameters !== undefined && !Array.isArray(operation.parameters))) {
+        throw new Error(`operationRef ${operationRef} parameters must be arrays`);
+    }
+    const pathParameters = Array.isArray(pathItem.parameters)
+        ? pathItem.parameters
+        : [];
+    const operationParameters = Array.isArray(operation.parameters)
+        ? operation.parameters
+        : [];
+    const parametersByName = new Map();
+    for (const rawParameters of [pathParameters, operationParameters]) {
+        const namesAtLevel = new Set();
+        for (const [index, rawParameter] of rawParameters.entries()) {
+            const parameter = parseParameter(rawParameter, operationRef, index);
+            if (parameter === undefined)
+                continue;
+            const name = `${parameter.in}.${parameter.name}`;
+            if (namesAtLevel.has(name))
+                throw new Error(`operationRef ${operationRef} has duplicate parameters`);
+            namesAtLevel.add(name);
+            parametersByName.set(name, parameter);
+        }
+    }
+    const parameters = [...parametersByName.values()];
+    for (const name of path
+        .match(/\{([^}]+)\}/g)
+        ?.map((token) => token.slice(1, -1)) ?? []) {
+        if (!parameters.some((parameter) => parameter.in === 'path' && parameter.name === name)) {
+            throw new Error(`operationRef ${operationRef} is missing path parameter ${name}`);
+        }
+    }
+    return parameters;
+}

package/dist/openapi/request/parse-security.d.ts

@@ -0,0 +1,3 @@
+import type { JsonObject } from '../../types/openapi.js';
+import type { OperationAuthentication } from '../../types/request.js';
+export declare function parseOperationSecurity(spec: JsonObject, operation: JsonObject, operationRef: string): OperationAuthentication | undefined;