@kubb/adapter-oas 5.0.0-beta.106 → 5.0.0-beta.107

package/README.md

@@ -45,29 +45,31 @@ import { defineConfig } from 'kubb'
 import { adapterOas } from '@kubb/adapter-oas'
 
 export default defineConfig({
-  input: {
-    path: './openapi.yaml',
-  },
+  input: './openapi.yaml',
   output: {
     path: './src/gen',
   },
-  adapters: [adapterOas()],
+  adapter: adapterOas(),
 })
 ```
 
+`input` accepts a file path, a URL, an inline JSON or YAML string, or a parsed spec object.
+
 ## API
 
 ### `adapterOas(options?)`
 
-Creates the OAS adapter instance. Pass it in the `adapters` array of `defineConfig`.
+Creates the OAS adapter instance. Pass it as `adapter` in `defineConfig`.
 
-### `mergeDocuments(documents)`
+### `adapterOasName`
 
-Merges multiple OpenAPI documents into a single document before parsing.
+The adapter's name, `'oas'`. Use it to identify this adapter in a Kubb config.
 
 ### Types
 
-All OpenAPI types (`Document`, `Operation`, `SchemaObject`, `HttpMethod`, etc.) are re-exported from this package.
+The package re-exports the OpenAPI types it works with: `ContentType`, `DiscriminatorObject`, `Document`,
+`MediaTypeObject`, `Operation`, `ReferenceObject`, `ResponseObject`, and `SchemaObject`. Its own option types are
+`AdapterOas`, `AdapterOasOptions`, and `AdapterOasResolvedOptions`.
 
 ## Supporting Kubb
 

package/dist/index.cjs

@@ -38,8 +38,8 @@ let _kubb_kit = require("@kubb/kit");
 const DEFAULT_PARSER_OPTIONS = {
 	dateType: "string",
 	integerType: "bigint",
-	unknownType: "any",
-	emptySchemaType: "any",
+	unknownType: "unknown",
+	emptySchemaType: "unknown",
 	enumSuffix: "enum"
 };
 /**
@@ -449,6 +449,24 @@ async function parseFromConfig(source) {
 	return parseDocument(resolved);
 }
 /**
+* Asserts the parsed input is an OpenAPI or Swagger document.
+*
+* {@link validateDocument} keeps spec violations non-fatal so imperfect but usable documents still
+* generate. That leniency also swallowed input that is not a document at all, which then produced
+* an empty build with a success exit code. A missing version field is the one failure that cannot
+* be a usable document, so it is fatal regardless of the `validate` option.
+*/
+function assertDocument(document) {
+	if (document && ("openapi" in document || "swagger" in document)) return;
+	throw new _kubb_core.Diagnostics.Error({
+		code: _kubb_core.Diagnostics.code.invalidDocument,
+		severity: "error",
+		message: "The resolved `input` is not an OpenAPI or Swagger document: it declares no `openapi` or `swagger` version.",
+		help: "Point `input` at a document that declares `openapi` or `swagger`. If you pass an object, pass the spec itself rather than a wrapper such as `{ path }` or `{ data }`.",
+		location: { kind: "config" }
+	});
+}
+/**
 * Validates an OpenAPI document using `@readme/openapi-parser` with colorized error output.
 *
 * @example
@@ -1623,9 +1641,9 @@ function convertObject({ schema, name, nullable, defaultValue, rawOptions, optio
 /**
 * Converts an OAS 3.1 `prefixItems` tuple into a `TupleSchemaNode`.
 */
-function convertTuple({ schema, name, nullable, defaultValue, rawOptions, parse }) {
+function convertTuple({ schema, name, nullable, defaultValue, rawOptions, options, parse }) {
 	const tupleItems = (schema.prefixItems ?? []).map((item) => parse({ schema: item }, rawOptions));
-	const rest = schema.items === false ? void 0 : !schema.items || schema.items === true ? _kubb_ast.ast.factory.createSchema({ type: "any" }) : parse({ schema: schema.items }, rawOptions);
+	const rest = schema.items === false ? void 0 : !schema.items || schema.items === true ? _kubb_ast.ast.factory.createSchema({ type: options.unknownType }) : parse({ schema: schema.items }, rawOptions);
 	return createNode({
 		schema,
 		name,
@@ -2491,13 +2509,16 @@ const adapterOas = (0, _kubb_core.createAdapter)((options) => {
 		},
 		async validate(input, options) {
 			await assertInputExists(input);
-			await validateDocument(await parseDocument(input), options);
+			const document = await parseDocument(input);
+			assertDocument(document);
+			await validateDocument(document, options);
 		},
 		async parse(source) {
 			const cached = inputCache.get(source);
 			if (cached) return cached;
 			const promise = (async () => {
 				const document = await parseFromConfig(source);
+				assertDocument(document);
 				if (validate) await validateDocument(document);
 				parsedDocument = document;
 				const refs = createRefs(document);