@kubb/adapter-oas 5.0.0-beta.105 → 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

@@ -16,7 +16,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -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"
 };
 /**
@@ -96,6 +96,20 @@ const specialCasedFormats = /* @__PURE__ */ new Set([
 	"time"
 ]);
 /**
+* Formats that describe a number, whether they resolve through `formatMap` or through the
+* `convertFormat` special cases. On a `type: 'string'` schema these do not make the value a
+* number: gRPC-gateway and other ProtoJSON producers send 64-bit integers as JSON strings.
+*
+* @see https://protobuf.dev/programming-guides/json/#int64-strings
+*/
+const numericFormats = /* @__PURE__ */ new Set([
+	"int32",
+	"int64",
+	"uint64",
+	"float",
+	"double"
+]);
+/**
 * Static map from OAS `format` strings to Kubb `SchemaType` values.
 *
 * Only formats whose AST type differs from the OAS `type` field appear here.
@@ -435,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
@@ -1363,13 +1395,15 @@ function convertConst({ schema, name, nullable, defaultValue }) {
 * `format` rule's `match` has confirmed the format is handled (see `isHandledFormat`) and, for
 * a date-ish format, that `dateType` is not `false`.
 */
-function convertFormat({ schema, name, nullable, defaultValue, options }) {
+function convertFormat(context) {
+	const { schema, name, nullable, defaultValue, options, type } = context;
 	const ctx = {
 		schema,
 		name,
 		nullable,
 		defaultValue
 	};
+	if (type === "string" && numericFormats.has(schema.format)) return convertString(context);
 	if (schema.format === "int64" || schema.format === "uint64") return createNode(ctx, {
 		type: options.integerType === "bigint" ? "bigint" : "integer",
 		primitive: "integer",
@@ -1607,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,
@@ -2475,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);