@kubb/core 5.0.0-beta.105 → 5.0.0-beta.107

package/dist/index.cjs

@@ -1,5 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_usingCtx = require("./usingCtx-BYOZEkiy.cjs");
+const require_usingCtx = require("./usingCtx-lve4tKsy.cjs");
 let node_async_hooks = require("node:async_hooks");
 let node_util = require("node:util");
 let node_crypto = require("node:crypto");
@@ -147,11 +147,12 @@ const randomColors = [
 function randomCliColor(text) {
 	if (!text) return "";
 	const index = (0, node_crypto.hash)("sha256", text, "buffer").readUInt32BE(0) % randomColors.length;
-	return (0, node_util.styleText)(randomColors[index] ?? "white", text);
+	const color = randomColors[index] ?? "white";
+	return (0, node_util.styleText)(color, text);
 }
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.105";
+var version = "5.0.0-beta.107";
 //#endregion
 //#region src/constants.ts
 /**
@@ -185,6 +186,16 @@ const diagnosticCode = {
 	*/
 	inputRequired: "KUBB_INPUT_REQUIRED",
 	/**
+	* `input` uses the v4 `{ path }` / `{ data }` wrapper, which v5 reads as a parsed
+	* document instead of a pointer to one.
+	*/
+	legacyInput: "KUBB_LEGACY_INPUT",
+	/**
+	* The parsed `input` carries no `openapi` or `swagger` version, so it is not a
+	* document the adapter can read.
+	*/
+	invalidDocument: "KUBB_INVALID_DOCUMENT",
+	/**
 	* A `$ref` (or equivalent reference) could not be resolved in the source document.
 	*/
 	refNotFound: "KUBB_REF_NOT_FOUND",
@@ -331,6 +342,16 @@ const diagnosticCatalog = {
 		cause: "An adapter is configured but no `input` was provided.",
 		fix: "Set `input` to a file path, a URL, an inline spec (JSON/YAML string), or a parsed object in your Kubb config."
 	},
+	[diagnosticCode.legacyInput]: {
+		title: "Legacy input shape",
+		cause: "`input` is a `{ path }` or `{ data }` wrapper, which v4 used to point at a document and v5 reads as the document itself.",
+		fix: "Unwrap it: `input: { path: \"./petStore.yaml\" }` becomes `input: \"./petStore.yaml\"`, and `input: { data: spec }` becomes `input: spec`."
+	},
+	[diagnosticCode.invalidDocument]: {
+		title: "Invalid document",
+		cause: "The parsed `input` has no `openapi` or `swagger` version field, so it is not an OpenAPI or Swagger document.",
+		fix: "Point `input` at a document that declares `openapi` or `swagger`, and check that a passed object is the spec itself rather than a wrapper around it."
+	},
 	[diagnosticCode.refNotFound]: {
 		title: "Reference not found",
 		cause: "A `$ref` could not be resolved in the source document.",
@@ -729,6 +750,23 @@ function getInputKind(input) {
 	return "file";
 }
 /**
+* The v4 `input` wrapper keys. v4 typed `input` as `{ path }` or `{ data }`; v5 takes the value
+* directly, so the wrapper now matches the "already-parsed document" branch and silently yields
+* an empty build.
+*/
+const legacyInputKeys = ["path", "data"];
+/**
+* Detects the v4 `{ path }` / `{ data }` wrapper so it fails loudly instead of being read as a
+* document. A real spec always carries more than these keys, so an object whose keys are drawn
+* only from them is the old shape rather than a document that happens to have a `path` property.
+*/
+function isLegacyInput(input) {
+	if (Array.isArray(input)) return input.some(isLegacyInput);
+	if (typeof input !== "object" || input === null) return false;
+	const keys = Object.keys(input);
+	return keys.length > 0 && keys.every((key) => legacyInputKeys.includes(key));
+}
+/**
 * Normalizes `config.input` into an `AdapterSource` the adapter can parse.
 *
 * A parsed object and inline content become `{ type: 'data' }`; a URL is kept verbatim and a
@@ -736,6 +774,13 @@ function getInputKind(input) {
 */
 function inputToAdapterSource(config) {
 	const input = config.input;
+	if (input && isLegacyInput(input)) throw new Diagnostics.Error({
+		code: Diagnostics.code.legacyInput,
+		severity: "error",
+		message: "The `input` option uses the v4 `{ path }` / `{ data }` wrapper.",
+		help: "Unwrap it: `input: { path: \"./petStore.yaml\" }` becomes `input: \"./petStore.yaml\"`, and `input: { data: spec }` becomes `input: spec`.",
+		location: { kind: "config" }
+	});
 	if (!input) throw new Diagnostics.Error({
 		code: Diagnostics.code.inputRequired,
 		severity: "error",
@@ -1927,23 +1972,23 @@ var KubbDriver = class {
 *
 *   return {
 *     name: 'memory',
-*     async hasItem(key) {
+*     async existsItem(key) {
 *       return store.has(key)
 *     },
-*     async getItem(key) {
+*     async readItem(key) {
 *       return store.get(key) ?? null
 *     },
-*     async setItem(key, value) {
+*     async writeItem(key, value) {
 *       store.set(key, value)
 *     },
 *     async removeItem(key) {
 *       store.delete(key)
 *     },
-*     async getKeys(base) {
+*     async readKeys(base) {
 *       const keys = [...store.keys()]
 *       return base ? keys.filter((k) => k.startsWith(base)) : keys
 *     },
-*     async clear(base) {
+*     async empty(base) {
 *       if (!base) store.clear()
 *     },
 *   }
@@ -1990,7 +2035,7 @@ function createLimiter(concurrency) {
 * - the write is skipped when the file content is already identical
 * - missing parent directories are created automatically
 * - Bun's native file API is used when running under Bun
-* - concurrent `setItem` calls are capped at {@link WRITE_CONCURRENCY} in flight, so a caller
+* - concurrent `writeItem` calls are capped at {@link WRITE_CONCURRENCY} in flight, so a caller
 *   can fire every file's write without pacing itself
 *
 * @example
@@ -2009,7 +2054,7 @@ const fsStorage = createStorage(() => {
 	const limit = createLimiter(WRITE_CONCURRENCY);
 	return {
 		name: "fs",
-		async hasItem(key) {
+		async existsItem(key) {
 			try {
 				await (0, node_fs_promises.access)((0, node_path.resolve)(key));
 				return true;
@@ -2017,20 +2062,20 @@ const fsStorage = createStorage(() => {
 				return false;
 			}
 		},
-		async getItem(key) {
+		async readItem(key) {
 			try {
 				return await (0, node_fs_promises.readFile)((0, node_path.resolve)(key), "utf8");
 			} catch (_error) {
 				return null;
 			}
 		},
-		async setItem(key, value) {
+		async writeItem(key, value) {
 			await limit(() => require_usingCtx.write((0, node_path.resolve)(key), value, { sanity: false }));
 		},
 		async removeItem(key) {
 			await (0, node_fs_promises.rm)((0, node_path.resolve)(key), { force: true });
 		},
-		async getKeys(base) {
+		async readKeys(base) {
 			const resolvedBase = (0, node_path.resolve)(base ?? process.cwd());
 			const keys = [];
 			try {
@@ -2041,7 +2086,7 @@ const fsStorage = createStorage(() => {
 			} catch (_error) {}
 			return keys;
 		},
-		async clear(base) {
+		async empty(base) {
 			if (!base) return;
 			await require_usingCtx.clean((0, node_path.resolve)(base));
 		}
@@ -2115,7 +2160,7 @@ var Kubb = class {
 				help: "Point `output.path` at a subdirectory such as `./src/gen` so clean only removes generated code.",
 				location: { kind: "config" }
 			});
-			await config.storage.clear(cleanPath);
+			await config.storage.empty(cleanPath);
 		}
 		await driver.setup();
 		this.#driver = driver;
@@ -2461,11 +2506,13 @@ const fileReporter = createReporter({
 		const { diagnostics, config } = result;
 		if (diagnostics.length === 0) return;
 		const report = buildReport(result);
-		const content = (0, node_util.stripVTControlCharacters)([config.name ? `# ${config.name} — ${(/* @__PURE__ */ new Date()).toISOString()}` : `# ${(/* @__PURE__ */ new Date()).toISOString()}`, ...[
+		const header = config.name ? `# ${config.name} — ${(/* @__PURE__ */ new Date()).toISOString()}` : `# ${(/* @__PURE__ */ new Date()).toISOString()}`;
+		const sections = [
 			buildSummarySection(report),
 			buildProblemSection(diagnostics),
 			buildTimingSection(report)
-		].filter((section) => section.length > 0).map((section) => section.join("\n"))].join("\n\n"));
+		].filter((section) => section.length > 0);
+		const content = (0, node_util.stripVTControlCharacters)([header, ...sections.map((section) => section.join("\n"))].join("\n\n"));
 		const baseName = `${[
 			"kubb",
 			config.name,
@@ -2618,23 +2665,23 @@ const memoryStorage = createStorage(() => {
 	const store = /* @__PURE__ */ new Map();
 	return {
 		name: "memory",
-		async hasItem(key) {
+		async existsItem(key) {
 			return store.has(key);
 		},
-		async getItem(key) {
+		async readItem(key) {
 			return store.get(key) ?? null;
 		},
-		async setItem(key, value) {
+		async writeItem(key, value) {
 			store.set(key, value);
 		},
 		async removeItem(key) {
 			store.delete(key);
 		},
-		async getKeys(base) {
+		async readKeys(base) {
 			const keys = [...store.keys()];
 			return base ? keys.filter((k) => k.startsWith(base)) : keys;
 		},
-		async clear(base) {
+		async empty(base) {
 			if (!base) {
 				store.clear();
 				return;