@openapi-flow/core 0.1.0 → 0.3.0

package/dist/inputs/inspect-deferred-api-inputs.js

@@ -0,0 +1,98 @@
+import { deferredApiInputValuesSchema } from '../schemas/deferred-api-input-schema.js';
+import { collectDeferredApiInputSlots } from './collect-deferred-api-input-slots.js';
+import { createOasValueValidator } from '../openapi/common/create-oas-value-validator.js';
+import { assignApiInputValue } from '../arguments/clarification/assign-api-input-value.js';
+import { validateApiArguments } from '../arguments/validate-api-arguments.js';
+import { listMissingRequestedApiInputs } from '../arguments/clarification/list-missing-requested-api-inputs.js';
+/** Missing values are explicit state; malformed supplied values are never repaired. */
+export function inspectDeferredApiInputs(input) {
+    const slots = collectDeferredApiInputSlots(input);
+    const parsed = deferredApiInputValuesSchema.safeParse(input.inputValues);
+    if (!parsed.success)
+        return {
+            status: 'invalid-input',
+            slots,
+            issues: parsed.error.issues.map((issue) => ({
+                code: 'invalid-value',
+                inputId: String(issue.path[0] ?? ''),
+                message: `inputValues must contain JSON values: ${issue.message}`,
+            })),
+        };
+    const values = parsed.data;
+    const known = new Set(slots.map((slot) => slot.id));
+    const issues = Object.keys(values)
+        .filter((id) => !known.has(id))
+        .map((inputId) => ({
+        code: 'unknown-input',
+        inputId,
+        message: `inputValues contains undeclared or stale input slot ${inputId}`,
+    }));
+    for (const slot of slots) {
+        if (!Object.hasOwn(values, slot.id)) {
+            issues.push({
+                code: 'missing-input',
+                inputId: slot.id,
+                callId: slot.callId,
+                targetPointer: slot.targetPointer,
+                message: `Missing runtime input ${slot.id} for ${slot.callId}${slot.targetPointer}`,
+            });
+            continue;
+        }
+        const checked = createOasValueValidator(slot.schema, slot.openapiVersion.startsWith('3.0.') ? 'openapi-3.0' : 'draft-2020-12', `inputValues[${slot.id}] for ${slot.callId}${slot.targetPointer}`).validate(values[slot.id]);
+        if (!checked.valid)
+            issues.push({
+                code: 'invalid-value',
+                inputId: slot.id,
+                callId: slot.callId,
+                targetPointer: slot.targetPointer,
+                message: `Runtime input ${slot.id} for ${slot.callId}${slot.targetPointer} violates its OAS schema: ${checked.errors.map((issue) => issue.message).join('; ')}`,
+            });
+        else {
+            const missing = listMissingRequestedApiInputs({
+                source: `Runtime input ${slot.id}`,
+                rootPointer: slot.targetPointer,
+                value: values[slot.id],
+                requestedInputs: slot.requestedInputs,
+            });
+            if (missing.length)
+                issues.push({
+                    code: 'invalid-value',
+                    inputId: slot.id,
+                    callId: slot.callId,
+                    targetPointer: slot.targetPointer,
+                    message: `Runtime input omits scenario-requested inputs: ${missing.join(', ')}`,
+                });
+        }
+    }
+    if (issues.length)
+        return {
+            status: issues.every((issue) => issue.code === 'missing-input')
+                ? 'needs-input'
+                : 'invalid-input',
+            slots,
+            issues,
+        };
+    const args = input.materials.map((material) => {
+        const resolved = structuredClone(material.values);
+        for (const slot of slots.filter((slot) => slot.callId === material.callId))
+            assignApiInputValue(resolved, slot.targetPointer, values[slot.id], material);
+        // Preserve the complete original OAS check after slot assignment. A union
+        // projection for one field never substitutes for the final request contract.
+        const checked = validateApiArguments({ ...material, values: resolved });
+        if (!checked.valid)
+            throw new Error(`Resolved request ${material.callId} still requires ${checked.missingInputs.join(', ')}`);
+        return {
+            callId: material.callId,
+            values: resolved,
+            bindings: structuredClone(material.bindings),
+            unresolvedInputs: [],
+            ...(material.requestMediaType !== undefined
+                ? { requestMediaType: material.requestMediaType }
+                : {}),
+            ...(material.requestedInputs === undefined
+                ? {}
+                : { requestedInputs: structuredClone(material.requestedInputs) }),
+        };
+    });
+    return { status: 'ready', slots, arguments: args, issues: [] };
+}

package/dist/inputs/materialize-deferred-api-inputs.d.ts

@@ -0,0 +1,4 @@
+import type { ApiCallArguments } from '../types/api-arguments.js';
+import type { InspectDeferredApiInputsInput } from '../types/deferred-api-inputs.js';
+/** Execution boundary: no missing slot can become an outbound request value. */
+export declare function materializeDeferredApiInputs(input: InspectDeferredApiInputsInput): ApiCallArguments[];

package/dist/inputs/materialize-deferred-api-inputs.js

@@ -0,0 +1,9 @@
+import { inspectDeferredApiInputs } from './inspect-deferred-api-inputs.js';
+import { DeferredApiInputError } from './deferred-api-input-error.js';
+/** Execution boundary: no missing slot can become an outbound request value. */
+export function materializeDeferredApiInputs(input) {
+    const checked = inspectDeferredApiInputs(input);
+    if (checked.status !== 'ready')
+        throw new DeferredApiInputError(checked.issues);
+    return checked.arguments;
+}

package/dist/inputs/native/collect-native-runtime-input-slots.d.ts

@@ -0,0 +1,3 @@
+import type { CollectNativeRuntimeInputSlotsInput, NativeRuntimeInputSlot } from '../../types/native-runtime-inputs.js';
+/** Slot identities are owned by code and scoped to the original node and schema. */
+export declare function collectNativeRuntimeInputSlots(input: CollectNativeRuntimeInputSlotsInput): NativeRuntimeInputSlot[];

package/dist/inputs/native/collect-native-runtime-input-slots.js

@@ -0,0 +1,65 @@
+import { createHash } from 'node:crypto';
+import { resolveNativeStructureParameters } from '../../workflow/resolve-native-structure-parameters.js';
+import { createNativeRuntimeParametersSchema } from '../../schemas/create-native-runtime-parameters-schema.js';
+import { schemasAtPointer } from '../../bindings/schema-at-pointer.js';
+import { createSchemaResourceContext } from '../../bindings/resources/create-schema-resource-context.js';
+/** Slot identities are owned by code and scoped to the original node and schema. */
+export function collectNativeRuntimeInputSlots(input) {
+    if (!Array.isArray(input.nativeNodes) || !Array.isArray(input.capabilities))
+        throw new Error('native runtime input nativeNodes and capabilities must be arrays');
+    const registry = new Map(input.capabilities.map((capability) => [capability.name, capability]));
+    if (registry.size !== input.capabilities.length)
+        throw new Error('native runtime input capabilities requires distinct names');
+    const ids = new Set();
+    return input.nativeNodes.flatMap((planned) => {
+        if (!planned ||
+            typeof planned.id !== 'string' ||
+            !planned.id.trim() ||
+            ids.has(planned.id))
+            throw new Error('native runtime inputs require distinct non-empty node IDs');
+        ids.add(planned.id);
+        const capability = registry.get(planned.capability);
+        if (!capability)
+            throw new Error(`node ${planned.id}: unknown capability ${planned.capability}`);
+        resolveNativeStructureParameters(planned, capability);
+        if (planned.runtimeParameters === undefined)
+            return [];
+        const originalSchema = createNativeRuntimeParametersSchema(capability);
+        const resources = createSchemaResourceContext(originalSchema);
+        const pointers = planned.runtimeParameters === true
+            ? ['']
+            : planned.runtimeParameters.pointers;
+        return pointers.map((targetPointer) => {
+            const projection = targetPointer === ''
+                ? originalSchema
+                : schemasAtPointer(resources.root, targetPointer, resources)[0];
+            if (projection === undefined)
+                throw new Error(`node ${planned.id}: runtime parameter ${targetPointer} is not permitted by its original schema`);
+            const schema = targetPointer === '' ? originalSchema : resources.bundle(projection);
+            const hash = createHash('sha256')
+                .update(JSON.stringify({
+                nodeId: planned.id,
+                capability: capability.name,
+                schema,
+                ...(targetPointer === ''
+                    ? {}
+                    : {
+                        targetPointer,
+                        parameters: planned.parameters,
+                        pointers: [...pointers].sort(),
+                    }),
+            }))
+                .digest('hex');
+            return {
+                kind: 'native-parameters-input',
+                state: 'deferred',
+                id: `native-input:${hash}`,
+                nodeId: planned.id,
+                capability: capability.name,
+                targetPointer,
+                schema,
+                description: capability.description,
+            };
+        });
+    });
+}

package/dist/inputs/native/create-native-runtime-parameter-materialization.d.ts

@@ -0,0 +1,3 @@
+import type { CollectNativeRuntimeInputSlotsInput, NativeRuntimeParameterMaterialization } from '../../types/native-runtime-inputs.js';
+/** Derive immutable execution material from explicit owners and the actual registered schema. */
+export declare function createNativeRuntimeParameterMaterializations(input: CollectNativeRuntimeInputSlotsInput): NativeRuntimeParameterMaterialization[];

package/dist/inputs/native/create-native-runtime-parameter-materialization.js

@@ -0,0 +1,47 @@
+import { collectNativeRuntimeInputSlots } from './collect-native-runtime-input-slots.js';
+import { createNativeRuntimeParametersSchema } from '../../schemas/create-native-runtime-parameters-schema.js';
+import { createSchemaResourceContext } from '../../bindings/resources/create-schema-resource-context.js';
+import { schemasAtPointer } from '../../bindings/schema-at-pointer.js';
+import { schemaAllowsContainer } from '../../bindings/schema-allows-container.js';
+import { pointerTokens, hasPointer } from '../../bindings/json-pointer.js';
+/** Derive immutable execution material from explicit owners and the actual registered schema. */
+export function createNativeRuntimeParameterMaterializations(input) {
+    const slots = collectNativeRuntimeInputSlots(input);
+    return input.nativeNodes
+        .filter((node) => node.runtimeParameters !== undefined)
+        .map((node) => {
+        const capability = input.capabilities.find((entry) => entry.name === node.capability);
+        const schema = createNativeRuntimeParametersSchema(capability);
+        const resources = createSchemaResourceContext(schema);
+        return {
+            nodeId: node.id,
+            parameters: structuredClone(node.parameters),
+            schema,
+            inputs: slots
+                .filter((slot) => slot.nodeId === node.id)
+                .map((slot) => {
+                const containerKinds = Object.create(null);
+                const tokens = pointerTokens(slot.targetPointer);
+                for (let length = 1; length < tokens.length; length++) {
+                    const pointer = '/' +
+                        tokens
+                            .slice(0, length)
+                            .map((part) => part.replaceAll('~', '~0').replaceAll('/', '~1'))
+                            .join('/');
+                    if (hasPointer(node.parameters, pointer))
+                        continue;
+                    const projections = schemasAtPointer(resources.root, pointer, resources);
+                    const kinds = ['object', 'array'].filter((kind) => projections.some((projection) => schemaAllowsContainer(projection, kind)));
+                    if (kinds.length !== 1)
+                        throw new Error(`node ${node.id}: runtime parameter ${pointer} needs an explicit literal container; schema does not determine object versus array`);
+                    containerKinds[pointer] = kinds[0];
+                }
+                return {
+                    id: slot.id,
+                    targetPointer: slot.targetPointer,
+                    containerKinds,
+                };
+            }),
+        };
+    });
+}

package/dist/inputs/native/inspect-native-runtime-inputs.d.ts

@@ -0,0 +1,2 @@
+import type { InspectNativeRuntimeInputsInput, NativeRuntimeInputInspection } from '../../types/native-runtime-inputs.js';
+export declare function inspectNativeRuntimeInputs(input: InspectNativeRuntimeInputsInput): NativeRuntimeInputInspection;

package/dist/inputs/native/inspect-native-runtime-inputs.js

@@ -0,0 +1,116 @@
+import { deferredApiInputValuesSchema } from '../../schemas/deferred-api-input-schema.js';
+import { collectNativeRuntimeInputSlots } from './collect-native-runtime-input-slots.js';
+import { parseNativeNodeParameters } from '../../workflow/parse-native-node-parameters.js';
+import { createOasValueValidator } from '../../openapi/common/create-oas-value-validator.js';
+import { nativeParameterValuesSchema } from '../../schemas/native-runtime-input-slot-schema.js';
+import { createNativeRuntimeParameterMaterializations } from './create-native-runtime-parameter-materialization.js';
+import { materializeNativeRuntimeParameters } from './materialize-native-runtime-parameters.js';
+export function inspectNativeRuntimeInputs(input) {
+    const slots = collectNativeRuntimeInputSlots(input);
+    const parsed = deferredApiInputValuesSchema.safeParse(input.inputValues);
+    if (!parsed.success)
+        return {
+            status: 'invalid-input',
+            slots,
+            issues: [
+                {
+                    code: 'invalid-value',
+                    inputId: '',
+                    message: 'native inputValues must be a JSON value map',
+                },
+            ],
+        };
+    const values = parsed.data;
+    const known = new Set(slots.map((slot) => slot.id));
+    const issues = Object.keys(values)
+        .filter((id) => !known.has(id))
+        .map((inputId) => ({
+        code: 'unknown-input',
+        inputId,
+        message: `Undeclared or stale native runtime input ${inputId}`,
+    }));
+    const resolved = new Map();
+    for (const slot of slots) {
+        if (!Object.hasOwn(values, slot.id)) {
+            issues.push({
+                code: 'missing-input',
+                inputId: slot.id,
+                nodeId: slot.nodeId,
+                message: `Missing native runtime input ${slot.id} for ${slot.nodeId}`,
+            });
+            continue;
+        }
+        if (slot.targetPointer === '' &&
+            !nativeParameterValuesSchema.safeParse(values[slot.id]).success) {
+            issues.push({
+                code: 'invalid-value',
+                inputId: slot.id,
+                nodeId: slot.nodeId,
+                message: `Native runtime input ${slot.nodeId} must be a JSON parameter object`,
+            });
+            continue;
+        }
+        try {
+            const checked = createOasValueValidator(slot.schema, 'draft-2020-12', `native input ${slot.nodeId}`).validate(values[slot.id]);
+            if (!checked.valid)
+                throw new Error(checked.errors.map((error) => error.message).join('; '));
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            issues.push({
+                code: 'invalid-value',
+                inputId: slot.id,
+                nodeId: slot.nodeId,
+                message: `Native runtime input ${slot.nodeId} violates its original parameter schema: ${error.message}`,
+            });
+        }
+    }
+    if (issues.length)
+        return {
+            status: issues.every((issue) => issue.code === 'missing-input')
+                ? 'needs-input'
+                : 'invalid-input',
+            slots,
+            issues,
+        };
+    for (const material of createNativeRuntimeParameterMaterializations(input)) {
+        const node = input.nativeNodes.find((node) => node.id === material.nodeId);
+        const capability = input.capabilities.find((entry) => entry.name === node.capability);
+        try {
+            const parameters = parseNativeNodeParameters({
+                id: node.id,
+                capability: node.capability,
+                parameters: materializeNativeRuntimeParameters(material, values),
+            }, capability);
+            const checked = createOasValueValidator(material.schema, 'draft-2020-12', `native complete input ${node.id}`).validate(parameters);
+            if (!checked.valid)
+                throw new Error(checked.errors.map((error) => error.message).join('; '));
+            resolved.set(node.id, {
+                id: node.id,
+                capability: node.capability,
+                parameters: structuredClone(parameters),
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error))
+                throw error;
+            issues.push({
+                code: 'invalid-value',
+                inputId: material.inputs[0].id,
+                nodeId: node.id,
+                message: `Native runtime input ${node.id} violates its complete original parameter schema: ${error.message}`,
+            });
+        }
+    }
+    if (issues.length)
+        return { status: 'invalid-input', slots, issues };
+    return {
+        status: 'ready',
+        slots,
+        issues: [],
+        nativeNodes: input.nativeNodes.map((node) => node.runtimeParameters !== undefined
+            ? resolved.get(node.id)
+            : structuredClone(node)),
+    };
+}

package/dist/inputs/native/materialize-native-runtime-parameters.d.ts

@@ -0,0 +1,4 @@
+import type { NativeRuntimeParameterMaterialization, NativeRuntimeInputValues } from '../../types/native-runtime-inputs.js';
+import type { JsonValueObject } from '../../types/api-arguments.js';
+/** Pure runtime assignment shared by in-process inspection and generated offline n8n guards. */
+export declare function materializeNativeRuntimeParameters(material: NativeRuntimeParameterMaterialization, values: NativeRuntimeInputValues): JsonValueObject;

package/dist/inputs/native/materialize-native-runtime-parameters.js

@@ -0,0 +1,47 @@
+import { assignJsonInputValue } from '../../bindings/assign-json-input-value.js';
+import { pointerTokens } from '../../bindings/json-pointer.js';
+import { cloneJsonValue } from '../../utils/clone-json-value.js';
+/** Pure runtime assignment shared by in-process inspection and generated offline n8n guards. */
+export function materializeNativeRuntimeParameters(material, values) {
+    let parameters = cloneJsonValue(material.parameters);
+    const inputs = [...material.inputs].sort((left, right) => {
+        const a = pointerTokens(left.targetPointer), b = pointerTokens(right.targetPointer);
+        for (let index = 0; index < Math.min(a.length, b.length); index++) {
+            if (a[index] === b[index])
+                continue;
+            return /^(0|[1-9][0-9]*)$/.test(a[index]) &&
+                /^(0|[1-9][0-9]*)$/.test(b[index])
+                ? Number(a[index]) - Number(b[index])
+                : a[index].localeCompare(b[index]);
+        }
+        return a.length - b.length;
+    });
+    for (const source of inputs) {
+        if (!Object.hasOwn(values, source.id))
+            throw new Error(`Missing native runtime input ${source.id} for ${material.nodeId}${source.targetPointer}`);
+        const value = values[source.id];
+        if (source.targetPointer === '') {
+            if (inputs.length !== 1 ||
+                Object.keys(parameters).length ||
+                value === null ||
+                typeof value !== 'object' ||
+                Array.isArray(value))
+                throw new Error(`Native runtime input ${material.nodeId} must be an exclusive JSON parameter object`);
+            parameters = cloneJsonValue(value);
+        }
+        else {
+            parameters = assignJsonInputValue({
+                values: parameters,
+                pointer: source.targetPointer,
+                value,
+                source: `Native runtime input ${material.nodeId}`,
+                containerKind(pointer) {
+                    if (!Object.hasOwn(source.containerKinds, pointer))
+                        throw new Error(`Native runtime input ${material.nodeId} has no declared container at ${pointer}`);
+                    return source.containerKinds[pointer];
+                },
+            });
+        }
+    }
+    return parameters;
+}

package/dist/internal-api.d.ts

@@ -0,0 +1,30 @@
+export * from './openapi/common/check-schema-value.js';
+export * from './openapi/common/operation-metadata.js';
+export * from './openapi/common/operation-reference.js';
+export * from './openapi/common/parse-spec-utils.js';
+export * from './openapi/common/unsupported-operation-error.js';
+export * from './openapi/common/validate-spec.js';
+export * from './openapi/inbound/callback/parse-callback-operations.js';
+export * from './openapi/inbound/inbound-path-item-operations.js';
+export * from './openapi/inbound/list-inbound-operations.js';
+export * from './openapi/inbound/webhook/parse-webhook-operations.js';
+export * from './openapi/request/create-operation-catalog.js';
+export * from './openapi/request/operation-mapping.js';
+export * from './openapi/request/map-http-operation-contract.js';
+export * from './openapi/request/parse-operation-responses.js';
+export * from './openapi/request/parse-request-body.js';
+export * from './openapi/request/parse-request-operations.js';
+export * from './openapi/request/parse-request-parameters.js';
+export * from './openapi/request/parse-security.js';
+export * from './openapi/request/request-operation-reference.js';
+export * from './openapi/request/response-contract.js';
+export * from './openapi/request/scalar-response-schema.js';
+export * from './openapi/request/serialize-form-body.js';
+export * from './openapi/request/serialize-parameter.js';
+export * from './schemas/operation-plan-schema.js';
+export type * from './types/catalog.js';
+export type * from './types/inbound.js';
+export type * from './types/legacy-plan.js';
+export type * from './types/openapi.js';
+export type * from './types/request.js';
+export * from './utils/is-object.js';

package/dist/internal-api.js

@@ -0,0 +1,25 @@
+export * from './openapi/common/check-schema-value.js';
+export * from './openapi/common/operation-metadata.js';
+export * from './openapi/common/operation-reference.js';
+export * from './openapi/common/parse-spec-utils.js';
+export * from './openapi/common/unsupported-operation-error.js';
+export * from './openapi/common/validate-spec.js';
+export * from './openapi/inbound/callback/parse-callback-operations.js';
+export * from './openapi/inbound/inbound-path-item-operations.js';
+export * from './openapi/inbound/list-inbound-operations.js';
+export * from './openapi/inbound/webhook/parse-webhook-operations.js';
+export * from './openapi/request/create-operation-catalog.js';
+export * from './openapi/request/operation-mapping.js';
+export * from './openapi/request/map-http-operation-contract.js';
+export * from './openapi/request/parse-operation-responses.js';
+export * from './openapi/request/parse-request-body.js';
+export * from './openapi/request/parse-request-operations.js';
+export * from './openapi/request/parse-request-parameters.js';
+export * from './openapi/request/parse-security.js';
+export * from './openapi/request/request-operation-reference.js';
+export * from './openapi/request/response-contract.js';
+export * from './openapi/request/scalar-response-schema.js';
+export * from './openapi/request/serialize-form-body.js';
+export * from './openapi/request/serialize-parameter.js';
+export * from './schemas/operation-plan-schema.js';
+export * from './utils/is-object.js';

package/dist/openapi/catalog/api-operation-key-equals.d.ts

@@ -0,0 +1,2 @@
+import type { ApiOperationKey } from '../../types/api-catalog.js';
+export declare function apiOperationKeyEquals(left: ApiOperationKey, right: ApiOperationKey): boolean;

package/dist/openapi/catalog/api-operation-key-equals.js

@@ -0,0 +1,5 @@
+export function apiOperationKeyEquals(left, right) {
+    return (left.documentId === right.documentId &&
+        left.snapshotId === right.snapshotId &&
+        left.operationRef === right.operationRef);
+}

package/dist/openapi/catalog/create-api-catalog.d.ts

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

package/dist/openapi/catalog/create-api-catalog.js

@@ -0,0 +1,34 @@
+import { createHash } from 'node:crypto';
+import { validateOpenApi, validateAndResolveOpenApiDocument, } from '../common/validate-spec.js';
+import { operationsFromDocument } from '../request/parse-request-operations.js';
+export async function createApiCatalog(sources) {
+    if (!Array.isArray(sources))
+        throw new Error('sources must be an array');
+    const catalog = { documents: [], operations: [] };
+    for (const [index, source] of sources.entries()) {
+        if (!source || typeof source.id !== 'string' || !source.id.trim())
+            throw new Error(`sources[${index}].id must be non-empty`);
+        if (catalog.documents.some((item) => item.id === source.id))
+            throw new Error(`sources[${index}].id duplicates ${source.id}`);
+        try {
+            const spec = validateOpenApi(source.spec);
+            const snapshotId = createHash('sha256')
+                .update(JSON.stringify(spec))
+                .digest('hex');
+            const parsed = await validateAndResolveOpenApiDocument(spec);
+            catalog.documents.push({ id: source.id, snapshotId, spec });
+            catalog.operations.push(...operationsFromDocument(parsed).map((operation) => ({
+                ...operation,
+                key: {
+                    documentId: source.id,
+                    snapshotId,
+                    operationRef: operation.operationRef,
+                },
+            })));
+        }
+        catch (cause) {
+            throw new Error(`sources[${source.id}].spec is invalid`, { cause });
+        }
+    }
+    return catalog;
+}

package/dist/openapi/catalog/list-api-operations.d.ts

@@ -0,0 +1,2 @@
+import type { ApiCatalog, ApiOperationCandidate } from '../../types/api-catalog.js';
+export declare function listApiOperations(catalog: ApiCatalog): ApiOperationCandidate[];

package/dist/openapi/catalog/list-api-operations.js

@@ -0,0 +1,3 @@
+export function listApiOperations(catalog) {
+    return structuredClone(catalog.operations);
+}

package/dist/openapi/common/check-oas-value.d.ts

@@ -0,0 +1,3 @@
+import type { OasValueSchema } from '../../types/oas-value-validation.js';
+import type { SchemaDialect } from '../../types/schema-dialect.js';
+export declare function checkOasValue(value: unknown, schema: OasValueSchema, dialect: SchemaDialect, source: string): void;

package/dist/openapi/common/check-oas-value.js

@@ -0,0 +1,6 @@
+import { createOasValueValidator } from './create-oas-value-validator.js';
+export function checkOasValue(value, schema, dialect, source) {
+    const result = createOasValueValidator(schema, dialect, source).validate(value);
+    if (!result.valid)
+        throw new Error(`${source} does not match the OAS schema: ${result.errors.map((error) => error.message).join('; ')}`);
+}

package/dist/openapi/common/check-schema-value.d.ts

@@ -0,0 +1,2 @@
+import type { JsonObject } from '../../types/openapi.js';
+export declare function checkSchemaValue(value: unknown, schema: JsonObject | boolean, source: string): void;

package/dist/openapi/common/check-schema-value.js

@@ -0,0 +1,12 @@
+import { validate } from '@scalar/json-schema-validator';
+export function checkSchemaValue(value, schema, source) {
+    if (schema === true)
+        return;
+    if (schema === false)
+        throw new Error(`${source} does not match the OAS schema`);
+    // Wrapping also keeps a literal string such as "null" from being parsed as YAML.
+    const result = validate([value], { type: 'array', items: schema });
+    if (!result.valid) {
+        throw new Error(`${source} does not match the OAS schema: ${result.errors.map((error) => error.message).join('; ')}`);
+    }
+}

package/dist/openapi/common/create-oas-value-validator.d.ts

@@ -0,0 +1,3 @@
+import type { SchemaDialect } from '../../types/schema-dialect.js';
+import type { OasValueSchema, OasValueValidator } from '../../types/oas-value-validation.js';
+export declare function createOasValueValidator(input: OasValueSchema, dialect: SchemaDialect, source: string): OasValueValidator;

package/dist/openapi/common/create-oas-value-validator.js

@@ -0,0 +1,39 @@
+import { createHash } from 'node:crypto';
+import { createValidator } from '@scalar/json-schema-validator';
+import { normalizeOasValueSchema } from './normalize-oas-value-schema.js';
+import { isObject } from '../../utils/is-object.js';
+export function createOasValueValidator(input, dialect, source) {
+    if (typeof input !== 'boolean' && !isObject(input))
+        throw new Error(`${source} must be an OAS schema object or boolean`);
+    if (dialect !== 'openapi-3.0' && dialect !== 'draft-2020-12')
+        throw new Error(`${source} has an unsupported OAS schema dialect: ${dialect}`);
+    const normalized = normalizeOasValueSchema(input, dialect);
+    const assertions = typeof normalized === 'boolean'
+        ? normalized
+            ? {}
+            : { not: {} }
+        : normalized;
+    // Each embedded input is a JSON Schema resource: fragment refs stay local to it.
+    const schema = {
+        $schema: 'https://json-schema.org/draft/2020-12/schema',
+        $id: `urn:openapi-flow:input:${createHash('sha256')
+            .update(source)
+            .update(JSON.stringify(assertions))
+            .digest('hex')}`,
+        ...assertions,
+    };
+    let validate;
+    try {
+        validate = createValidator(schema);
+    }
+    catch (error) {
+        throw new Error(`${source} cannot compile its OAS value schema`, {
+            cause: error,
+        });
+    }
+    return {
+        schema,
+        // Scalar parses string documents as YAML; encode actual string values first.
+        validate: (value) => validate(typeof value === 'string' ? JSON.stringify(value) : value),
+    };
+}

package/dist/openapi/common/normalize-oas-value-schema.d.ts

@@ -0,0 +1,4 @@
+import type { OasValueSchema } from '../../types/oas-value-validation.js';
+import type { SchemaDialect } from '../../types/schema-dialect.js';
+/** Convert only OAS 3.0 assertion syntax, not formats, annotations or data. */
+export declare function normalizeOasValueSchema(input: OasValueSchema, dialect: SchemaDialect): OasValueSchema;