@skmtc/core 0.29.0 → 0.31.0

package/esm/parse/v3-2/tag/toTagsV3.js

@@ -0,0 +1,78 @@
+import { OasTag } from '../../../oas/tag/Tag.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+export const toTagsV3 = ({ tags, stackTrail, context }) => {
+    if (!tags) {
+        return undefined;
+    }
+    const parents = new Map(tags.map(({ name, parent }) => [name, parent]));
+    return tags.map(tag => {
+        const parentError = toParentError({ name: tag.name, parent: tag.parent, parents });
+        if (!parentError) {
+            return toTagV3({ tag, stackTrail, context });
+        }
+        context.logIssue({
+            key: 'parent',
+            level: 'warning',
+            message: `Tag '${tag.name}' ${parentError}; dropping 'parent'`,
+            parent: tag,
+            stackTrail,
+            type: 'INVALID_TAG_PARENT'
+        });
+        return toTagV3({ tag: { ...tag, parent: undefined }, stackTrail, context });
+    });
+};
+/** Describes why the tag's `parent` is invalid, or returns undefined when it is valid. */
+const toParentError = ({ name, parent, parents }) => {
+    if (parent === undefined) {
+        return undefined;
+    }
+    if (!parents.has(parent)) {
+        return `names parent '${parent}', which is not a tag`;
+    }
+    if (leadsBackTo({ name, current: parent, parents, visited: new Set() })) {
+        return `is in a parent cycle through '${parent}'`;
+    }
+    return undefined;
+};
+/** Follows the parent chain from `current` and reports whether it reaches `name`. */
+const leadsBackTo = ({ name, current, parents, visited }) => {
+    if (current === undefined) {
+        return false;
+    }
+    if (current === name) {
+        return true;
+    }
+    // The chain loops without reaching `name`: the cycle is above this tag, and
+    // the tags in it report it.
+    if (visited.has(current)) {
+        return false;
+    }
+    return leadsBackTo({
+        name,
+        current: parents.get(current),
+        parents,
+        visited: new Set([...visited, current])
+    });
+};
+export const toTagV3 = ({ tag, stackTrail, context }) => {
+    const { name, description, summary, parent, kind, externalDocs, ...skipped } = tag;
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: tag,
+        context,
+        stackTrail,
+        parentType: 'tag'
+    });
+    const fields = {
+        name,
+        description,
+        summary,
+        parent,
+        kind,
+        externalDocs: parsedExternalDocs,
+        extensionFields
+    };
+    return new OasTag(fields);
+};

package/esm/parse/v3-2/union/toUnion.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnion } from '../../../oas/union/Union.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnionArgs = {
+    value: OpenAPIV3.SchemaObject;
+    members: (OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject)[];
+    parentType: 'anyOf' | 'oneOf';
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnion: ({ value, members, parentType, stackTrail, context }: ToUnionArgs) => OasUnion;

package/esm/parse/v3-2/union/toUnion.js

@@ -0,0 +1,68 @@
+import { OasUnion } from '../../../oas/union/Union.js';
+import { toDiscriminatorV3 } from '../discriminator/toDiscriminatorV3.js';
+import { toSchemaV3 } from '../schema/toSchemasV3.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { parseNullable } from '../_helpers/parseNullable.js';
+import { parseExample } from '../_helpers/parseExample.js';
+import { parseDefault } from '../_helpers/parseDefault.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+export const toUnion = ({ value, members, parentType, stackTrail, context }) => {
+    const { nullable, value: valueWithoutNullable } = parseNullable({
+        value,
+        context,
+        stackTrail
+    });
+    const { discriminator, title, description, externalDocs, example: unparsedExample, default: unparsedDefaultValue, ...skipped } = valueWithoutNullable;
+    const example = parseExample({
+        value: unparsedExample,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid example. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const defaultValue = parseDefault({
+        value: unparsedDefaultValue,
+        context,
+        parent: value,
+        nullable,
+        check: isPresent,
+        toMessage: item => `Removed invalid default. Expected a non-null value, got: ${item}`,
+        stackTrail
+    });
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: `schema:${parentType}`
+    });
+    const discriminatorParsed = stackTrail.trace('discriminator', st => toDiscriminatorV3({ discriminator, stackTrail: st, context }));
+    const membersParsed = members.reduce((acc, item, index) => {
+        if (item === undefined || item === null) {
+            return acc;
+        }
+        return [
+            ...acc,
+            stackTrail.trace(`${index}`, st => toSchemaV3({ schema: item, stackTrail: st, context }))
+        ];
+    }, []);
+    return context.withStackTrail(stackTrail, () => new OasUnion({
+        title,
+        description,
+        externalDocs: stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context })),
+        nullable,
+        default: defaultValue,
+        discriminator: discriminatorParsed,
+        members: membersParsed,
+        example,
+        extensionFields
+    }, context));
+};
+// A union (anyOf/oneOf) value may match any of its members, so the most we
+// can validate without resolving members is that a present default/example
+// is not a bare `null` on a non-nullable schema.
+const isPresent = (value) => {
+    return value !== null && value !== undefined;
+};

package/esm/parse/v3-2/unknown/toUnknown.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToUnknownArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toUnknown: ({ value, stackTrail, context }: ToUnknownArgs) => OasUnknown;

package/esm/parse/v3-2/unknown/toUnknown.js

@@ -0,0 +1,19 @@
+import { OasUnknown } from '../../../oas/unknown/Unknown.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+export const toUnknown = ({ value, stackTrail, context }) => {
+    const { type: _type, title, description, example, nullable, ...skipped } = value;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:unknown'
+    });
+    return context.withStackTrail(stackTrail, () => new OasUnknown({
+        title,
+        description,
+        nullable,
+        extensionFields,
+        example
+    }, context));
+};

package/esm/parse/v3-2/webhook/toWebhooksV3.d.ts

@@ -0,0 +1,48 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Method } from '../../../types/Method.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import type { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/**
+ * The 3.1 `webhooks` object: a map of webhook NAME → PathItem, identical
+ * in shape to `paths` but keyed by name rather than URL path. Inline
+ * PathItems only — a webhook PathItem `$ref` is a 3.1 edge case not yet
+ * handled (see the arc note §5 Refs).
+ */
+export type WebhooksObject = Record<string, OpenAPIV3.PathItemObject>;
+type WebhookInfo = {
+    method: Method;
+    name: string;
+    pathItem: OasPathItem | undefined;
+};
+export type ToWebhookV3Args = {
+    operation: OpenAPIV3.OperationObject;
+    webhookInfo: WebhookInfo;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export declare const toWebhookV3: ({ operation, webhookInfo, stackTrail, context }: ToWebhookV3Args) => OasWebhook;
+export type ToWebhooksV3Args = {
+    webhooks: WebhooksObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export declare const toWebhooksV3: ({ webhooks, stackTrail, context }: ToWebhooksV3Args) => OasWebhook[];
+export {};

package/esm/parse/v3-2/webhook/toWebhooksV3.js

@@ -0,0 +1,139 @@
+import { toRequestBodyV3 } from '../requestBody/toRequestBodiesV3.js';
+import { toResponsesV3 } from '../response/toResponseV3.js';
+import { toParameterListV3 } from '../parameter/toParameterV3.js';
+import { OasWebhook } from '../../../oas/webhook/Webhook.js';
+import { toPathItemResultV3 } from '../pathItem/toPathItemV3.js';
+import { toPathItemMethod } from '../methods.js';
+import { dropAdditionalOperationsV3 } from '../pathItem/dropAdditionalOperationsV3.js';
+import { warnQuerystringConflictsV3 } from '../parameter/warnQuerystringConflictsV3.js';
+import { toSpecificationExtensionsV3 } from '../specificationExtensions/toSpecificationExtensionsV3.js';
+import { toSecurityRequirementsV3 } from '../securityRequirement/toSecurityRequirement.js';
+import { toExternalDocs } from '../externalDocs/toExternalDocs.js';
+import { toOptionalServersV3 } from '../server/toServerV3.js';
+/**
+ * Parses a single webhook Operation Object into an {@link OasWebhook}.
+ *
+ * Mirrors `toOperationV3` and reuses the same leaf field parsers
+ * (`toParameterListV3` / `toRequestBodyV3` / `toResponsesV3` / …) — the
+ * inner Operation Object is structurally identical. Only the orchestration
+ * is duplicated (the dialect-shaped glue), and the output is an
+ * `OasWebhook` carrying a `name`, not an `OasOperation` carrying a `path`.
+ */
+export const toWebhookV3 = ({ operation, webhookInfo, stackTrail, context }) => {
+    const { method, name, pathItem } = webhookInfo;
+    const { operationId, tags, summary, description, parameters, requestBody, responses, deprecated, security, externalDocs, servers, ...skipped } = operation;
+    const extensionFields = toSpecificationExtensionsV3({
+        skipped,
+        parent: operation,
+        context,
+        stackTrail,
+        parentType: 'operation'
+    });
+    const parsedParameters = stackTrail.trace('parameters', st => toParameterListV3({ parameters, stackTrail: st, context }));
+    warnQuerystringConflictsV3({ parameters: parsedParameters, pathItem, stackTrail, context });
+    const parsedRequestBody = stackTrail.trace('requestBody', st => toRequestBodyV3({ requestBody, stackTrail: st, context }));
+    const parsedResponses = stackTrail.trace('responses', st => toResponsesV3({ responses, stackTrail: st, context }));
+    const parsedSecurity = stackTrail.trace('security', st => toSecurityRequirementsV3({ security, stackTrail: st, context }));
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => toExternalDocs({ externalDocs, stackTrail: st, context }));
+    const parsedServers = stackTrail.trace('servers', st => toOptionalServersV3({ servers, stackTrail: st, context }));
+    return context.withStackTrail(stackTrail, () => new OasWebhook({
+        pathItem,
+        name,
+        method,
+        operationId,
+        summary,
+        tags,
+        description,
+        parameters: parsedParameters,
+        requestBody: parsedRequestBody,
+        responses: parsedResponses,
+        deprecated,
+        security: parsedSecurity,
+        externalDocs: parsedExternalDocs,
+        servers: parsedServers,
+        extensionFields
+    }, context));
+};
+/**
+ * Flattens the 3.1 `webhooks` map into `OasWebhook[]`, mirroring
+ * `toOperationsV3`'s `paths` → `OasOperation[]` flattening. Returns `[]`
+ * when no `webhooks` object is present (the common 3.0 / no-webhook case).
+ * The stack trail nests `webhooks` → `<name>` → `<method>` so
+ * `OasDocument.removeItem` can locate a webhook by name.
+ */
+export const toWebhooksV3 = ({ webhooks, stackTrail, context }) => {
+    if (!webhooks) {
+        return [];
+    }
+    return Object.entries(webhooks).flatMap(([name, pathItem]) => {
+        return stackTrail.trace(name, nameStack => {
+            if (!pathItem) {
+                return [];
+            }
+            const fixedFields = dropAdditionalOperationsV3({ pathItem, stackTrail: nameStack, context });
+            const cleaned = Object.entries(fixedFields).reduce(({ rest, methodObject }, [key, operation]) => {
+                const method = toPathItemMethod(key);
+                if (method) {
+                    const { [method]: _deleted, ...remaining } = rest;
+                    return {
+                        rest: remaining,
+                        methodObject: {
+                            ...methodObject,
+                            [method]: operation
+                        }
+                    };
+                }
+                return { rest, methodObject };
+            }, {
+                rest: fixedFields,
+                methodObject: {}
+            });
+            const pathItemResult = toPathItemResultV3({
+                pathItem: cleaned.rest,
+                stackTrail: nameStack,
+                context
+            });
+            if (!pathItemResult.valid) {
+                return [];
+            }
+            const pathItemObject = pathItemResult.pathItem;
+            return Object.entries(cleaned.methodObject)
+                .map(([method, operation]) => {
+                // Use `nameStack` (the trail with the webhook name already
+                // pushed) so downstream traces record webhooks:<name>:<method>:…
+                // — the trail `OasDocument.removeItem` matches a webhook on.
+                return nameStack.trace(method, st => {
+                    if (!operation) {
+                        return;
+                    }
+                    try {
+                        return toWebhookV3({
+                            operation,
+                            webhookInfo: {
+                                method: method,
+                                name,
+                                pathItem: pathItemObject
+                            },
+                            stackTrail: st,
+                            context
+                        });
+                    }
+                    catch (error) {
+                        const normalized = error instanceof Error ? error : new Error(String(error));
+                        context.logIssue({
+                            key: method,
+                            parent: operation,
+                            level: 'error',
+                            message: normalized.message,
+                            cause: normalized,
+                            stackTrail: st,
+                            type: 'INVALID_OPERATION'
+                        });
+                        return undefined;
+                    }
+                });
+            })
+                .filter((item) => Boolean(item));
+        });
+    });
+};

package/esm/types/Method.d.ts

@@ -5,9 +5,11 @@ import * as v from 'valibot';
  *
  * This constant array includes all HTTP methods that can be used
  * in OpenAPI path operations, as defined by the OpenAPI specification.
- * All methods are in lowercase to match OpenAPI conventions.
+ * All methods are in lowercase to match OpenAPI conventions. `query` is
+ * an OpenAPI 3.2 method; each parser tree reads its own list from
+ * `parse/v3-X/methods.ts`.
  */
-export declare const methodValues: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace"];
+export declare const methodValues: readonly ["get", "put", "post", "delete", "options", "head", "patch", "trace", "query"];
 /**
  * Array of HTTP methods excluding TRACE.
  *
@@ -23,8 +25,9 @@ export declare const method: v.UnionSchema<[
     v.LiteralSchema<'delete', undefined>,
     v.LiteralSchema<'head', undefined>,
     v.LiteralSchema<'options', undefined>,
-    v.LiteralSchema<'trace', undefined>
+    v.LiteralSchema<'trace', undefined>,
+    v.LiteralSchema<'query', undefined>
 ], undefined>;
-export type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace';
+export type Method = 'get' | 'put' | 'post' | 'delete' | 'options' | 'head' | 'patch' | 'trace' | 'query';
 export declare const methods: v.ArraySchema<typeof method, undefined>;
 export declare const isMethod: (arg: unknown) => arg is Method;

package/esm/types/Method.js

@@ -5,7 +5,9 @@ import * as v from 'valibot';
  *
  * This constant array includes all HTTP methods that can be used
  * in OpenAPI path operations, as defined by the OpenAPI specification.
- * All methods are in lowercase to match OpenAPI conventions.
+ * All methods are in lowercase to match OpenAPI conventions. `query` is
+ * an OpenAPI 3.2 method; each parser tree reads its own list from
+ * `parse/v3-X/methods.ts`.
  */
 export const methodValues = [
     'get',
@@ -15,7 +17,8 @@ export const methodValues = [
     'options',
     'head',
     'patch',
-    'trace'
+    'trace',
+    'query'
 ];
 /**
  * Array of HTTP methods excluding TRACE.
@@ -23,7 +26,16 @@ export const methodValues = [
  * This is a filtered version of {@link methodValues} that excludes the TRACE method,
  * which is sometimes excluded from API operations for security reasons.
  */
-export const methodValuesNoTrace = ['get', 'put', 'post', 'delete', 'options', 'head', 'patch'];
+export const methodValuesNoTrace = [
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'query'
+];
 export const method = v.union([
     v.literal('get'),
     v.literal('post'),
@@ -32,7 +44,8 @@ export const method = v.union([
     v.literal('delete'),
     v.literal('head'),
     v.literal('options'),
-    v.literal('trace')
+    v.literal('trace'),
+    v.literal('query')
 ]);
 export const methods = v.array(method);
 export const isMethod = (arg) => {

package/esm/types/Preview.d.ts

@@ -139,7 +139,8 @@ export declare const oasOperationSource: v.ObjectSchema<{
         v.LiteralSchema<'delete', undefined>,
         v.LiteralSchema<'head', undefined>,
         v.LiteralSchema<'options', undefined>,
-        v.LiteralSchema<'trace', undefined>
+        v.LiteralSchema<'trace', undefined>,
+        v.LiteralSchema<'query', undefined>
     ], undefined>;
     readonly variant: v.StringSchema<undefined>;
 }, undefined>;

package/esm/types/SkmtcDocument.d.ts

@@ -59,12 +59,12 @@ export declare const toGqlParsedDocument: (value: GqlDocument) => SkmtcParsedDoc
  * pipeline runs the protocol-appropriate parser before handing the
  * post-parse {@link SkmtcParsedDocument} to the generate phase.
  *
- * - `oas.value` is an `OpenAPIV3.Document`. Schema versions other than
- *   3.0 (Swagger 2, OpenAPI 3.1) are normalized to 3.0 by
- *   `@skmtc/convert` before reaching `toArtifacts`. 3.1 `webhooks` ride
- *   *on* that document as a retained member (the 3.0 base type omits
- *   `webhooks`, so it is widened here) — the parser flattens them into
- *   {@link OasDocument.webhooks}.
+ * - `oas.value` is an `OpenAPIV3.Document` carrying an OpenAPI 3.0, 3.1 or
+ *   3.2 document; each is parsed natively by its own parser tree. Swagger 2
+ *   is converted to 3.0 by `@skmtc/convert` before reaching `toArtifacts`.
+ *   3.1 and 3.2 `webhooks` ride *on* that document as a retained member
+ *   (the 3.0 base type omits `webhooks`, so it is widened here) — the
+ *   parser flattens them into {@link OasDocument.webhooks}.
  * - `gql.value` is either a raw SDL string or a pre-built
  *   `GraphQLSchema`. Strings are run through `buildSchema` inside the
  *   pipeline; pre-built `GraphQLSchema` instances are used as-is.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skmtc/core",
-  "version": "0.29.0",
+  "version": "0.31.0",
   "description": "Skmtc is a declarative code generation framework",
   "keywords": [
     "openapi",

package/script/_dnt.polyfills.d.ts

@@ -4,6 +4,17 @@ declare global {
     }
 }
 export {};
+declare global {
+    interface Object {
+        /**
+         * Determines whether an object has a property with the specified name.
+         * @param o An object.
+         * @param v A property name.
+         */
+        hasOwn(o: object, v: PropertyKey): boolean;
+    }
+}
+export {};
 /**
  * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
  * but instead of using npm to install additional dependencies,

package/script/_dnt.polyfills.js

@@ -1,6 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.import_meta_ponyfill = exports.import_meta_ponyfill_esmodule = exports.import_meta_ponyfill_commonjs = void 0;
+// https://github.com/tc39/proposal-accessible-object-hasownproperty/blob/main/polyfill.js
+if (!Object.hasOwn) {
+    Object.defineProperty(Object, "hasOwn", {
+        value: function (object, property) {
+            if (object == null) {
+                throw new TypeError("Cannot convert undefined or null to object");
+            }
+            return Object.prototype.hasOwnProperty.call(Object(object), property);
+        },
+        configurable: true,
+        enumerable: false,
+        writable: true,
+    });
+}
 /**
  * Based on [import-meta-ponyfill](https://github.com/gaubee/import-meta-ponyfill),
  * but instead of using npm to install additional dependencies,

package/script/context/ParseContext.js

@@ -32,6 +32,7 @@ require("../_dnt.polyfills.js");
 const graphql_1 = require("graphql");
 const toDocumentFieldsV3_js_1 = require("../parse/v3-0/document/toDocumentFieldsV3.js");
 const toDocumentFieldsV3_js_2 = require("../parse/v3-1/document/toDocumentFieldsV3.js");
+const toDocumentFieldsV3_js_3 = require("../parse/v3-2/document/toDocumentFieldsV3.js");
 const toOasDialect_js_1 = require("../parse/toOasDialect.js");
 const Document_js_1 = require("../oas/document/Document.js");
 const GqlRegistry_js_1 = require("../gql/registry/GqlRegistry.js");
@@ -187,7 +188,7 @@ class ParseContext {
                 const oasState = this.protocol;
                 // The ONE place the OpenAPI version is examined: pick the dialect's
                 // parser tree. Everything downstream is version-specific code living
-                // in its own tree (v3-0 / v3-1) and never re-checks the version.
+                // in its own tree (v3-0 / v3-1 / v3-2) and never re-checks the version.
                 const dialect = (0, toOasDialect_js_1.toOasDialect)(oasState.documentObject.openapi);
                 switch (dialect) {
                     case '3.0':
@@ -204,6 +205,13 @@ class ParseContext {
                             context: this
                         });
                         break;
+                    case '3.2':
+                        oasState.oasDocument.fields = (0, toDocumentFieldsV3_js_3.toDocumentFieldsV3)({
+                            documentObject: oasState.documentObject,
+                            stackTrail,
+                            context: this
+                        });
+                        break;
                     default: {
                         const _exhaustive = dialect;
                         throw new Error(`Unhandled OAS dialect: ${JSON.stringify(_exhaustive)}`);

package/script/context/generateTypes.d.ts

@@ -154,8 +154,20 @@ export type AnyOasDocument = OpenAPIV2.Document | OpenAPIV3.Document | OpenAPIV3
  * The TS type and the valibot schema below stay in sync via the
  * `v.GenericSchema<OasIssueType>` annotation — adding a variant in one
  * place without the other fails to type-check.
+ *
+ * Media type issues, at most one per response or request body, from the
+ * choice `toJsonContent` makes on its parsed `content`:
+ *
+ * - `WILDCARD_MEDIA_TYPE` (`warning`) — the body has no JSON media type
+ *   (see `isJsonMediaType`) and is read from `*\/*` as JSON, since its schema
+ *   there is an object, array, union or `$ref`. The document does not say the
+ *   format; springdoc writes `*\/*` for every response.
+ * - `NO_JSON_MEDIA_TYPE` (`debug`) — no lookup without a media type reads the
+ *   body, and its keys include a range: `application/*`, or `*\/*` with a
+ *   scalar schema (a text body or a file). A body with only specific
+ *   non-JSON types (`multipart/form-data`, `text/plain`) logs nothing.
  */
-export type OasIssueType = 'UNEXPECTED_PROPERTY' | 'MISSING_OBJECT_TYPE' | 'MISSING_STRING_TYPE' | 'MISSING_ARRAY_TYPE' | 'MISSING_BOOLEAN_TYPE' | 'INVALID_EXAMPLE' | 'INVALID_ENUM' | 'INVALID_DEFAULT' | 'INVALID_NULLABLE' | 'UNEXPECTED_FORMAT' | 'INVALID_RESPONSE' | 'INVALID_FORMAT' | 'INVALID_OPERATION' | 'INVALID_SCHEMA' | 'INVALID_PARAMETER' | 'INVALID_SECURITY_SCHEME' | 'INVALID_DEPENDENCY_REF' | 'EXAMPLE_AND_EXAMPLES_DEFINED';
+export type OasIssueType = 'UNEXPECTED_PROPERTY' | 'MISSING_OBJECT_TYPE' | 'MISSING_STRING_TYPE' | 'MISSING_ARRAY_TYPE' | 'MISSING_BOOLEAN_TYPE' | 'INVALID_EXAMPLE' | 'INVALID_ENUM' | 'INVALID_DEFAULT' | 'INVALID_NULLABLE' | 'UNEXPECTED_FORMAT' | 'INVALID_RESPONSE' | 'INVALID_FORMAT' | 'INVALID_OPERATION' | 'INVALID_SCHEMA' | 'INVALID_PARAMETER' | 'INVALID_SECURITY_SCHEME' | 'INVALID_DEPENDENCY_REF' | 'EXAMPLE_AND_EXAMPLES_DEFINED' | 'INVALID_TAG_PARENT' | 'UNSUPPORTED_OPERATION_METHOD' | 'WILDCARD_MEDIA_TYPE' | 'NO_JSON_MEDIA_TYPE';
 /**
  * Valibot schema for {@link OasIssueType}. Annotation deliberately omitted
  * so the precise literal-union output type flows through to consumers
@@ -163,7 +175,7 @@ export type OasIssueType = 'UNEXPECTED_PROPERTY' | 'MISSING_OBJECT_TYPE' | 'MISS
  * this list and {@link OasIssueType} is caught by `assertSchemaMatchesType`
  * below.
  */
-export declare const oasIssueType: v.UnionSchema<[v.LiteralSchema<"UNEXPECTED_PROPERTY", undefined>, v.LiteralSchema<"MISSING_OBJECT_TYPE", undefined>, v.LiteralSchema<"MISSING_STRING_TYPE", undefined>, v.LiteralSchema<"MISSING_ARRAY_TYPE", undefined>, v.LiteralSchema<"MISSING_BOOLEAN_TYPE", undefined>, v.LiteralSchema<"INVALID_EXAMPLE", undefined>, v.LiteralSchema<"INVALID_ENUM", undefined>, v.LiteralSchema<"INVALID_DEFAULT", undefined>, v.LiteralSchema<"INVALID_NULLABLE", undefined>, v.LiteralSchema<"UNEXPECTED_FORMAT", undefined>, v.LiteralSchema<"INVALID_RESPONSE", undefined>, v.LiteralSchema<"INVALID_FORMAT", undefined>, v.LiteralSchema<"INVALID_OPERATION", undefined>, v.LiteralSchema<"INVALID_SCHEMA", undefined>, v.LiteralSchema<"INVALID_PARAMETER", undefined>, v.LiteralSchema<"INVALID_SECURITY_SCHEME", undefined>, v.LiteralSchema<"INVALID_DEPENDENCY_REF", undefined>, v.LiteralSchema<"EXAMPLE_AND_EXAMPLES_DEFINED", undefined>], undefined>;
+export declare const oasIssueType: v.UnionSchema<[v.LiteralSchema<"UNEXPECTED_PROPERTY", undefined>, v.LiteralSchema<"MISSING_OBJECT_TYPE", undefined>, v.LiteralSchema<"MISSING_STRING_TYPE", undefined>, v.LiteralSchema<"MISSING_ARRAY_TYPE", undefined>, v.LiteralSchema<"MISSING_BOOLEAN_TYPE", undefined>, v.LiteralSchema<"INVALID_EXAMPLE", undefined>, v.LiteralSchema<"INVALID_ENUM", undefined>, v.LiteralSchema<"INVALID_DEFAULT", undefined>, v.LiteralSchema<"INVALID_NULLABLE", undefined>, v.LiteralSchema<"UNEXPECTED_FORMAT", undefined>, v.LiteralSchema<"INVALID_RESPONSE", undefined>, v.LiteralSchema<"INVALID_FORMAT", undefined>, v.LiteralSchema<"INVALID_OPERATION", undefined>, v.LiteralSchema<"INVALID_SCHEMA", undefined>, v.LiteralSchema<"INVALID_PARAMETER", undefined>, v.LiteralSchema<"INVALID_SECURITY_SCHEME", undefined>, v.LiteralSchema<"INVALID_DEPENDENCY_REF", undefined>, v.LiteralSchema<"EXAMPLE_AND_EXAMPLES_DEFINED", undefined>, v.LiteralSchema<"INVALID_TAG_PARENT", undefined>, v.LiteralSchema<"UNSUPPORTED_OPERATION_METHOD", undefined>, v.LiteralSchema<"WILDCARD_MEDIA_TYPE", undefined>, v.LiteralSchema<"NO_JSON_MEDIA_TYPE", undefined>], undefined>;
 export type GenerateResult = {
     files: Map<string, FileBase>;
     previews: Record<string, Preview>;

package/script/context/generateTypes.js

@@ -60,7 +60,11 @@ exports.oasIssueType = v.union([
     v.literal('INVALID_PARAMETER'),
     v.literal('INVALID_SECURITY_SCHEME'),
     v.literal('INVALID_DEPENDENCY_REF'),
-    v.literal('EXAMPLE_AND_EXAMPLES_DEFINED')
+    v.literal('EXAMPLE_AND_EXAMPLES_DEFINED'),
+    v.literal('INVALID_TAG_PARENT'),
+    v.literal('UNSUPPORTED_OPERATION_METHOD'),
+    v.literal('WILDCARD_MEDIA_TYPE'),
+    v.literal('NO_JSON_MEDIA_TYPE')
 ]);
 // Compile-time drift detector: this binding fails to type-check if
 // `OasIssueType` and the literal list above disagree in either

package/script/dsl/GeneratorKeys.d.ts

@@ -466,8 +466,8 @@ export declare const isGeneratorKey: (arg: unknown) => arg is GeneratorKey;
  * Type guard to check if a value is a valid OasOperationGeneratorKey.
  *
  * Validates that the argument is a string with the correct format:
- * `generatorId|path|method` where each part is non-empty and method
- * is a valid HTTP method.
+ * `generatorId|path|method|variant` where each part is non-empty, path
+ * starts with `/` and method is a valid HTTP method.
  *
  * @param arg - Value to check
  * @returns True if the value is a valid OasOperationGeneratorKey

package/script/dsl/GeneratorKeys.js

@@ -263,8 +263,8 @@ exports.isGeneratorKey = isGeneratorKey;
  * Type guard to check if a value is a valid OasOperationGeneratorKey.
  *
  * Validates that the argument is a string with the correct format:
- * `generatorId|path|method` where each part is non-empty and method
- * is a valid HTTP method.
+ * `generatorId|path|method|variant` where each part is non-empty, path
+ * starts with `/` and method is a valid HTTP method.
  *
  * @param arg - Value to check
  * @returns True if the value is a valid OasOperationGeneratorKey
@@ -295,7 +295,10 @@ const isOasOperationGeneratorKey = (arg) => {
     if (typeof generatorId !== 'string' || !generatorId.length) {
         return false;
     }
-    if (typeof path !== 'string' || !path.length) {
+    // An OpenAPI path starts with `/`. Checking it keeps a GraphQL key whose
+    // field name is also an HTTP method (`gen|mutation|query|main`) from
+    // parsing as an operation.
+    if (typeof path !== 'string' || !path.startsWith('/')) {
         return false;
     }
     if (!(0, Method_js_1.isMethod)(method)) {