@openapi-flow/core 0.1.0 → 0.2.0

package/dist/bindings/resources/create-schema-resource-context.d.ts

@@ -0,0 +1,4 @@
+import type { BindingSchema } from '../../types/api-bindings.js';
+import type { SchemaResourceContext } from '../../types/schema-resource.js';
+/** Keep original resources; projected values reference their original locations. */
+export declare function createSchemaResourceContext(schema: BindingSchema): SchemaResourceContext;

package/dist/bindings/resources/create-schema-resource-context.js

@@ -0,0 +1,130 @@
+import { createHash } from 'node:crypto';
+import { Ajv2020 } from 'ajv/dist/2020.js';
+import addFormats from 'ajv-formats';
+import uri from 'fast-uri';
+import { isObject } from '../../utils/is-object.js';
+import { cloneSchemaResource } from './clone-schema-resource.js';
+/** Keep original resources; projected values reference their original locations. */
+export function createSchemaResourceContext(schema) {
+    if (typeof schema === 'boolean')
+        return {
+            root: schema,
+            reference: (value) => value,
+            resolve: (value) => value,
+            bundle: (value) => value,
+        };
+    const document = cloneSchemaResource(schema);
+    if (typeof document === 'boolean')
+        throw new Error('Native schema resource must be an object');
+    // JSON Schema permits an implementation-assigned initial retrieval URI.
+    if (document.$id !== undefined && typeof document.$id !== 'string')
+        throw new Error('Native schema.$id must be a URI-reference string');
+    const retrievalUri = `https://openapi-flow.invalid/schema/${createHash('sha256').update(JSON.stringify(document)).digest('hex')}`;
+    const rootUri = typeof document.$id === 'string'
+        ? uri.resolve(retrievalUri, document.$id)
+        : retrievalUri;
+    const root = { ...document, $id: rootUri };
+    const locations = new WeakMap();
+    function index(current, pointer, baseUri) {
+        if (typeof current === 'boolean')
+            return;
+        const base = typeof current.$id === 'string'
+            ? uri.resolve(baseUri, current.$id)
+            : baseUri;
+        locations.set(current, {
+            reference: uri.resolve(rootUri, '#' + pointer.split('/').map(encodeURIComponent).join('/')),
+            baseUri: base,
+        });
+        function child(value, suffix) {
+            if (typeof value === 'boolean' || isObject(value))
+                index(value, pointer + suffix, base);
+        }
+        // Traverse schema-valued keywords, not const/enum/default/example data.
+        for (const key of [
+            '$defs',
+            'definitions',
+            'properties',
+            'patternProperties',
+            'dependentSchemas',
+            'dependencies',
+        ]) {
+            const children = current[key];
+            if (!isObject(children))
+                continue;
+            for (const [name, value] of Object.entries(children))
+                child(value, '/' + key + '/' + name.replaceAll('~', '~0').replaceAll('/', '~1'));
+        }
+        for (const key of [
+            'items',
+            'contains',
+            'additionalProperties',
+            'unevaluatedProperties',
+            'unevaluatedItems',
+            'propertyNames',
+            'not',
+            'if',
+            'then',
+            'else',
+        ])
+            child(current[key], '/' + key);
+        for (const key of ['allOf', 'anyOf', 'oneOf', 'prefixItems']) {
+            const children = current[key];
+            if (Array.isArray(children))
+                children.forEach((value, position) => child(value, '/' + key + '/' + position));
+        }
+    }
+    index(root, '', rootUri);
+    const ajv = new Ajv2020({ strict: false, discriminator: true });
+    addFormats.default(ajv);
+    ajv.addSchema(root);
+    // Resolve/validate on the host. No remote fetch and no runtime schema compiler.
+    ajv.getSchema(rootUri);
+    function resolveReference(current) {
+        if (typeof current === 'boolean' || typeof current.$ref !== 'string')
+            return current;
+        const location = locations.get(current);
+        // Generated projection references are already absolute; original references use lexical scope.
+        const reference = location
+            ? uri.resolve(location.baseUri, current.$ref)
+            : current.$ref;
+        const target = ajv.getSchema(reference);
+        if (!target)
+            throw new Error(`Unresolved native schema reference ${reference}`);
+        const value = target.schema;
+        if (typeof value !== 'boolean' && !isObject(value))
+            throw new Error(`Native schema reference ${reference} does not identify a schema`);
+        return value;
+    }
+    function declaredType(current, visited = new Set()) {
+        if (typeof current === 'boolean' || visited.has(current))
+            return undefined;
+        if (typeof current.type === 'string')
+            return current.type;
+        if (Array.isArray(current.type) &&
+            current.type.every((type) => typeof type === 'string'))
+            return current.type;
+        visited.add(current);
+        return typeof current.$ref === 'string'
+            ? declaredType(resolveReference(current), visited)
+            : undefined;
+    }
+    return {
+        root,
+        reference: (current) => {
+            if (typeof current === 'boolean')
+                return current;
+            const location = locations.get(current);
+            if (!location)
+                throw new Error('Schema projection requires an original resource location');
+            const type = declaredType(current);
+            return {
+                $ref: location.reference,
+                ...(type === undefined ? {} : { type }),
+            };
+        },
+        resolve: resolveReference,
+        bundle: (projection) => typeof projection === 'boolean'
+            ? { $defs: { resource: root }, allOf: [projection] }
+            : { ...projection, $defs: { resource: root } },
+    };
+}

package/dist/bindings/response-binding-schema.d.ts

@@ -0,0 +1,3 @@
+import type { ApiOperationContract } from '../types/api-operation.js';
+import type { BindingSchema } from '../types/api-bindings.js';
+export declare function responseBindingSchemas(operation: ApiOperationContract, pointer: string): BindingSchema[];

package/dist/bindings/response-binding-schema.js

@@ -0,0 +1,21 @@
+import { isObject } from '../utils/is-object.js';
+import { schemasAtPointer } from './schema-at-pointer.js';
+import { normalizeOasValueSchema } from '../openapi/common/normalize-oas-value-schema.js';
+export function responseBindingSchemas(operation, pointer) {
+    return Object.values(operation.operation.responses ?? {}).flatMap((response) => {
+        if (!isObject(response) || !isObject(response.content))
+            return [];
+        return Object.values(response.content).flatMap((media) => {
+            if (!isObject(media))
+                return [];
+            const schema = media.schema;
+            return typeof schema === 'boolean' || isObject(schema)
+                ? schemasAtPointer(normalizeOasValueSchema(schema, operation.openapiVersion.startsWith('3.0.')
+                    ? 'openapi-3.0'
+                    : 'draft-2020-12'), pointer)
+                : pointer === ''
+                    ? [true]
+                    : [];
+        });
+    });
+}

package/dist/bindings/schema-allows-container.d.ts

@@ -0,0 +1,3 @@
+import type { BindingSchema, RequestContainerKind } from '../types/api-bindings.js';
+/** Necessary type conditions only; full schema satisfiability is a runtime check. */
+export declare function schemaAllowsContainer(schema: BindingSchema, kind: RequestContainerKind): boolean;

package/dist/bindings/schema-allows-container.js

@@ -0,0 +1,20 @@
+import { isObject } from '../utils/is-object.js';
+/** Necessary type conditions only; full schema satisfiability is a runtime check. */
+export function schemaAllowsContainer(schema, kind) {
+    if (typeof schema === 'boolean')
+        return schema;
+    if (schema.type !== undefined) {
+        const types = Array.isArray(schema.type) ? schema.type : [schema.type];
+        if (!types.includes(kind))
+            return false;
+    }
+    for (const key of ['allOf', 'anyOf', 'oneOf']) {
+        if (!Array.isArray(schema[key]))
+            continue;
+        const branches = schema[key].map((child) => (typeof child === 'boolean' || isObject(child)) &&
+            schemaAllowsContainer(child, kind));
+        if (key === 'allOf' ? !branches.every(Boolean) : !branches.some(Boolean))
+            return false;
+    }
+    return true;
+}

package/dist/bindings/schema-at-pointer.d.ts

@@ -0,0 +1,4 @@
+import type { BindingSchema } from '../types/api-bindings.js';
+import type { SchemaResourceContext } from '../types/schema-resource.js';
+/** Resolve declared object fields, array items and composition alternatives. */
+export declare function schemasAtPointer(schema: BindingSchema, pointer: string, resources?: SchemaResourceContext): BindingSchema[];

package/dist/bindings/schema-at-pointer.js

@@ -0,0 +1,89 @@
+import { pointerTokens } from './json-pointer.js';
+import { isObject } from '../utils/is-object.js';
+import { intersectBindingSchemas, unionBindingSchemas, } from './combine-binding-schemas.js';
+import { schemaAllowsContainer } from './schema-allows-container.js';
+/** Resolve declared object fields, array items and composition alternatives. */
+export function schemasAtPointer(schema, pointer, resources) {
+    const active = new Map();
+    function visit(current, tokens, inheritedKinds = ['object', 'array']) {
+        if (typeof current === 'boolean')
+            return current;
+        if (!tokens.length)
+            return resources ? resources.reference(current) : current;
+        if (resources && typeof current.$ref === 'string') {
+            const key = JSON.stringify([tokens, inheritedKinds]);
+            const pending = active.get(current) ?? new Set();
+            if (pending.has(key))
+                throw new Error(`Native pointer projection has a non-progressing reference cycle at ${pointer}`);
+            pending.add(key);
+            active.set(current, pending);
+            const siblings = { ...current };
+            delete siblings.$ref;
+            try {
+                return intersectBindingSchemas([
+                    visit(resources.resolve(current), tokens, inheritedKinds),
+                    visit(siblings, tokens, inheritedKinds),
+                ]);
+            }
+            finally {
+                pending.delete(key);
+            }
+        }
+        const [token, ...rest] = tokens;
+        const kinds = inheritedKinds.filter((kind) => schemaAllowsContainer(current, kind));
+        const containers = [];
+        if (kinds.includes('object')) {
+            const children = [];
+            if (isObject(current.properties) &&
+                Object.hasOwn(current.properties, token)) {
+                const child = current.properties[token];
+                if (typeof child === 'boolean' || isObject(child))
+                    children.push(visit(child, rest));
+            }
+            if (isObject(current.patternProperties))
+                for (const [pattern, child] of Object.entries(current.patternProperties))
+                    if (new RegExp(pattern).test(token) &&
+                        (typeof child === 'boolean' || isObject(child)))
+                        children.push(visit(child, rest));
+            if (!children.length) {
+                // JSON Schema leaves unspecified additionalProperties open.
+                const child = current.additionalProperties;
+                children.push(child === undefined
+                    ? true
+                    : typeof child === 'boolean' || isObject(child)
+                        ? visit(child, rest)
+                        : false);
+            }
+            containers.push(intersectBindingSchemas(children));
+        }
+        if (kinds.includes('array') && /^(0|[1-9][0-9]*)$/.test(token)) {
+            const index = Number(token);
+            const prefix = Array.isArray(current.prefixItems)
+                ? current.prefixItems
+                : [];
+            const child = index < prefix.length ? prefix[index] : current.items;
+            containers.push(typeof current.maxItems === 'number' && index >= current.maxItems
+                ? false
+                : child === undefined
+                    ? true
+                    : typeof child === 'boolean' || isObject(child)
+                        ? visit(child, rest)
+                        : false);
+        }
+        const constraints = [unionBindingSchemas(containers)];
+        for (const key of ['allOf', 'anyOf', 'oneOf']) {
+            if (!Array.isArray(current[key]))
+                continue;
+            const children = current[key].map((child) => typeof child === 'boolean' || isObject(child)
+                ? visit(child, tokens, kinds)
+                : false);
+            // Parent oneOf branches can share child values once their discriminators disappear.
+            constraints.push(key === 'allOf'
+                ? intersectBindingSchemas(children)
+                : unionBindingSchemas(children));
+        }
+        return intersectBindingSchemas(constraints);
+    }
+    const projected = visit(schema, pointerTokens(pointer));
+    return projected === false ? [] : [projected];
+}

package/dist/bindings/validate-api-binding-assignments.d.ts

@@ -0,0 +1,2 @@
+import type { ValidateApiBindingAssignmentsInput } from '../types/api-bindings.js';
+export declare function validateApiBindingAssignments({ calls, materials, nativeOutputs, }: ValidateApiBindingAssignmentsInput): void;

package/dist/bindings/validate-api-binding-assignments.js

@@ -0,0 +1,81 @@
+import { pointerTokens } from './json-pointer.js';
+import { requestBindingSchemas } from './request-binding-schema.js';
+import { responseBindingSchemas } from './response-binding-schema.js';
+import { nativeBindingSchemas } from './native-binding-schema.js';
+import { validateNativeOutputContracts } from './validate-native-output-contracts.js';
+function declaredTypes(schemas) {
+    const types = new Set();
+    for (const schema of schemas) {
+        if (typeof schema === 'boolean' || schema.type === undefined)
+            return new Set();
+        for (const type of Array.isArray(schema.type) ? schema.type : [schema.type])
+            if (typeof type === 'string')
+                types.add(type);
+        if (schema.nullable === true)
+            types.add('null');
+    }
+    return types;
+}
+export function validateApiBindingAssignments({ calls, materials, nativeOutputs = [], }) {
+    const byId = new Map(materials.map((material) => [material.callId, material]));
+    if (!materials.length ||
+        byId.size !== materials.length ||
+        materials.some((item) => !item.callId.trim()))
+        throw new Error('binding materials require unique non-empty callIds');
+    validateNativeOutputContracts(nativeOutputs);
+    const nativeById = new Map(nativeOutputs.map((item) => [item.nodeId, item]));
+    for (const output of nativeOutputs)
+        if (byId.has(output.nodeId))
+            throw new Error(`native output ${output.nodeId} duplicates an API callId`);
+    if (calls.length !== materials.length ||
+        new Set(calls.map((call) => call.callId)).size !== materials.length)
+        throw new Error('binding plan must name every material callId exactly once');
+    const dependencies = new Map();
+    for (const call of calls) {
+        const target = byId.get(call.callId);
+        if (!target)
+            throw new Error(`bindings: unknown target callId ${call.callId}`);
+        const pointers = [];
+        dependencies.set(call.callId, []);
+        for (const binding of call.bindings) {
+            if (binding.kind !== 'node-output')
+                throw new Error('bindings.kind must be node-output');
+            pointerTokens(binding.targetPointer);
+            pointerTokens(binding.sourcePointer);
+            const source = byId.get(binding.sourceNodeId);
+            const native = nativeById.get(binding.sourceNodeId);
+            if (!source && !native)
+                throw new Error(`bindings: unknown sourceNodeId ${binding.sourceNodeId}`);
+            if (binding.sourceNodeId === call.callId)
+                throw new Error(`bindings: self-reference ${call.callId}`);
+            if (pointers.some((pointer) => pointer === binding.targetPointer ||
+                pointer.startsWith(binding.targetPointer + '/') ||
+                binding.targetPointer.startsWith(pointer + '/')))
+                throw new Error(`bindings overlap at ${call.callId}${binding.targetPointer}`);
+            pointers.push(binding.targetPointer);
+            const targets = requestBindingSchemas(target, binding.targetPointer);
+            const sources = native
+                ? nativeBindingSchemas(native, binding.sourcePointer)
+                : responseBindingSchemas(source.operation, binding.sourcePointer);
+            if (!targets.length)
+                throw new Error(`bindings: ${call.callId}${binding.targetPointer} is not declared by the request OAS`);
+            if (!sources.length)
+                throw new Error(`bindings: ${binding.sourceNodeId}${binding.sourcePointer} is not declared by the ${native ? 'native output contract' : 'response OAS'}`);
+            const from = declaredTypes(sources);
+            const to = declaredTypes(targets);
+            if (from.size &&
+                to.size &&
+                ![...from].some((type) => to.has(type) || (type === 'integer' && to.has('number'))))
+                throw new Error(`bindings: incompatible OAS types ${binding.sourceNodeId}${binding.sourcePointer} -> ${call.callId}${binding.targetPointer}`);
+            dependencies.get(call.callId).push(binding.sourceNodeId);
+        }
+    }
+    const pending = new Set(byId.keys());
+    while (pending.size) {
+        const ready = [...pending].filter((id) => dependencies.get(id).every((source) => !pending.has(source)));
+        if (!ready.length)
+            throw new Error('binding dependencies have a cycle');
+        for (const id of ready)
+            pending.delete(id);
+    }
+}

package/dist/bindings/validate-api-binding-gaps.d.ts

@@ -0,0 +1,2 @@
+import type { ValidateApiBindingPlanInput } from '../types/api-bindings.js';
+export declare function validateApiBindingGaps({ plan, materials, }: ValidateApiBindingPlanInput): void;

package/dist/bindings/validate-api-binding-gaps.js

@@ -0,0 +1,10 @@
+import { requestBindingSchemas } from './request-binding-schema.js';
+export function validateApiBindingGaps({ plan, materials, }) {
+    for (const gap of plan.gaps) {
+        const material = materials.find((item) => item.callId === gap.callId);
+        if (!material || !gap.description.trim())
+            throw new Error('binding gap requires a declared callId and description');
+        if (!requestBindingSchemas(material, gap.targetPointer).length)
+            throw new Error(`binding gap ${gap.callId}${gap.targetPointer} is not declared by the request OAS`);
+    }
+}

package/dist/bindings/validate-api-binding-plan.d.ts

@@ -0,0 +1,3 @@
+import type { ValidateApiBindingPlanInput } from '../types/api-bindings.js';
+/** Check identities/contracts without guessing edges or substituting values. */
+export declare function validateApiBindingPlan({ plan, materials, nativeOutputs, }: ValidateApiBindingPlanInput): void;

package/dist/bindings/validate-api-binding-plan.js

@@ -0,0 +1,11 @@
+import { validateApiBindingAssignments } from './validate-api-binding-assignments.js';
+/** Check identities/contracts without guessing edges or substituting values. */
+export function validateApiBindingPlan({ plan, materials, nativeOutputs, }) {
+    if (plan.gaps.length)
+        throw new Error(`API bindings need review: ${JSON.stringify(plan.gaps)}`);
+    validateApiBindingAssignments({
+        calls: plan.calls,
+        materials,
+        nativeOutputs,
+    });
+}

package/dist/bindings/validate-native-output-contracts.d.ts

@@ -0,0 +1,3 @@
+import type { NativeOutputContract } from '../types/node-output.js';
+/** Validate the declaration boundary; the adapter compiles the JSON Schemas. */
+export declare function validateNativeOutputContracts(outputs: NativeOutputContract[]): void;

package/dist/bindings/validate-native-output-contracts.js

@@ -0,0 +1,16 @@
+import { isObject } from '../utils/is-object.js';
+/** Validate the declaration boundary; the adapter compiles the JSON Schemas. */
+export function validateNativeOutputContracts(outputs) {
+    if (!Array.isArray(outputs))
+        throw new Error('nativeOutputs must be an array');
+    const ids = new Set();
+    for (const output of outputs) {
+        if (!output || typeof output.nodeId !== 'string' || !output.nodeId.trim())
+            throw new Error('nativeOutputs.nodeId must be a non-empty string');
+        if (ids.has(output.nodeId))
+            throw new Error('native outputs require unique node IDs');
+        ids.add(output.nodeId);
+        if (typeof output.schema !== 'boolean' && !isObject(output.schema))
+            throw new Error(`nativeOutputs[${output.nodeId}].schema must be a JSON Schema object or boolean`);
+    }
+}

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/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) || sources.length === 0)
+        throw new Error('sources must contain at least one OpenAPI document');
+    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;