@kubb/core 5.11.6 → 5.12.0

package/dist/{Hookable-CvStaYYq.js → Hookable-Cqx0g2T-.js}

@@ -1,11 +1,14 @@
 import "node:module";
 import { satisfies } from "verkit";
 import { AsyncLocalStorage } from "node:async_hooks";
-import { glob, mkdir, readFile, rm, writeFile } from "node:fs/promises";
-import path, { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import process$1 from "node:process";
+import { x } from "tinyexec";
+import { glob, mkdir, mkdtemp, readFile, rm, rm as rm$1, writeFile } from "node:fs/promises";
+import path, { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { existsSync as existsSync$1 } from "node:fs";
 import { stripVTControlCharacters, styleText } from "node:util";
 import { ast, collectImportedRefNames, collectUsedSchemaNames, extractStringsFromNodes } from "@kubb/ast";
+import { tmpdir } from "node:os";
 //#region \0rolldown/runtime.js
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", {
@@ -14,7 +17,7 @@ var __name = (target, value) => __defProp(target, "name", {
 });
 //#endregion
 //#region package.json
-var version = "5.11.6";
+var version = "5.12.0";
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -364,6 +367,12 @@ const diagnosticCatalog = {
 		cause: "A URL set as `input` (or reached through a `$ref`) never answered, so the request failed before a status came back. A refused connection, an unknown host, an expired certificate, and a timeout all land here.",
 		fix: "Check that the host is running and reachable from this machine. For a local server, start it and confirm the port matches the one in `input`."
 	},
+	gitInputFailed: {
+		code: "KUBB_GIT_INPUT_FAILED",
+		title: "Git input failed",
+		cause: "A git `input` (`git+<repo>#<ref>:<path>`) is malformed, or `git` could not fetch it: git is not installed, the repository or ref does not exist, or the credentials were refused.",
+		fix: "Write the input as `git+<repo>#<ref>:<path>`. Run `git fetch --depth 1 <repo> <ref>` yourself to see the git error, and set up a credential helper or SSH key for a private repository."
+	},
 	inputRequired: {
 		code: "KUBB_INPUT_REQUIRED",
 		title: "Input required",
@@ -1234,18 +1243,130 @@ function definePlugin(definition) {
 	});
 }
 //#endregion
+//#region src/gitInput.ts
+/** Matches a git `input`: the `git+` prefix npm uses for git dependencies. */
+const gitInputRegExp = /^git\+/i;
+function gitError(message, cause) {
+	return new Diagnostics.Error({
+		code: Diagnostics.code.gitInputFailed,
+		severity: "error",
+		message,
+		help: "Write a git `input` as `git+<repo>#<ref>:<path>`, for example `git+https://github.com/org/api.git#main:specs/openapi.yaml`. Check that `git` is installed and that `git fetch` can reach the repository with your credentials.",
+		location: { kind: "config" },
+		cause: cause === void 0 ? void 0 : toError(cause)
+	});
+}
+/** The repository URL without a user or password, safe to print. */
+function redact(repo) {
+	if (!URL.canParse(repo)) return repo;
+	const url = new URL(repo);
+	url.username = "";
+	url.password = "";
+	return url.href;
+}
+/**
+* Splits `git+<repo>#<ref>:<path>` into its parts. Git refs cannot contain `:`, so the first one
+* in the fragment ends the ref. Throws `KUBB_GIT_INPUT_FAILED` when the fragment or path is missing.
+*/
+function parseGitInput(input) {
+	const hashIndex = input.indexOf("#");
+	const repo = input.slice(4, hashIndex === -1 ? void 0 : hashIndex);
+	const fragment = hashIndex === -1 ? "" : input.slice(hashIndex + 1);
+	const colonIndex = fragment.indexOf(":");
+	const ref = colonIndex === -1 ? void 0 : fragment.slice(0, colonIndex);
+	const path = colonIndex === -1 ? fragment : fragment.slice(colonIndex + 1);
+	if (!repo || !path || ref === "") throw gitError(`The git \`input\` for ${redact(repo)} has no repository, ref, or spec path after \`#\`.`);
+	return {
+		repo,
+		ref,
+		path
+	};
+}
+/**
+* Fetches one commit of a git repository into a temporary directory with a shallow `git fetch`,
+* so any host and the user's own git credentials work, and relative `$ref` files resolve.
+* Resolves to the spec path on disk and a `dispose` that deletes the checkout.
+*/
+async function checkoutGitInput(input, signal) {
+	const { repo, ref, path } = parseGitInput(input);
+	const dir = await mkdtemp(join(tmpdir(), "kubb-git-"));
+	const dispose = () => rm(dir, {
+		recursive: true,
+		force: true
+	});
+	const specPath = resolve(dir, path);
+	const relativePath = relative(dir, specPath);
+	if (relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath)) {
+		await dispose();
+		throw gitError(`The spec path "${path}" in the git \`input\` points outside the repository.`);
+	}
+	const label = `${redact(repo)}${ref ? ` at ${ref}` : ""}`;
+	const env = {
+		...process$1.env,
+		GIT_TERMINAL_PROMPT: "0"
+	};
+	const steps = [
+		["init", "--quiet"],
+		[
+			"config",
+			"core.symlinks",
+			"false"
+		],
+		[
+			"fetch",
+			"--quiet",
+			"--depth",
+			"1",
+			"--end-of-options",
+			repo,
+			ref ?? "HEAD"
+		],
+		[
+			"checkout",
+			"--quiet",
+			"FETCH_HEAD"
+		]
+	];
+	try {
+		for (const args of steps) {
+			const result = await x("git", args, {
+				nodeOptions: {
+					cwd: dir,
+					env,
+					signal
+				},
+				throwOnError: false
+			});
+			if (result.exitCode !== 0) {
+				const stderr = result.stderr.replaceAll(repo, redact(repo)).trim();
+				throw gitError(`\`git ${args[0]}\` failed for ${label}: ${stderr || `exit code ${result.exitCode}`}`);
+			}
+		}
+	} catch (error) {
+		await dispose();
+		if (Diagnostics.isError(error)) throw error;
+		throw gitError(`Cannot run \`git\` for ${label}: ${getErrorMessage(error)}`, error);
+	}
+	return {
+		path: specPath,
+		dispose
+	};
+}
+//#endregion
 //#region src/input.ts
 /**
 * Classifies an `input` value so callers branch on it once instead of repeating the checks.
 *
 * A non-string is a parsed spec (`object`). A string is `inline` when it holds OpenAPI content,
 * meaning it starts with `{` or `[`, spans multiple lines, or opens with a YAML `openapi:` or
-* `swagger:` key. Otherwise a string is a `url` when it parses as one, or a `file` path.
+* `swagger:` key. Otherwise a string is `git` when it starts with `git+`, a `url` when it parses as
+* one, or a `file` path.
 */
 function getInputKind(input) {
 	if (typeof input !== "string") return "object";
 	const trimmed = input.trimStart();
 	if (trimmed.startsWith("{") || trimmed.startsWith("[") || input.includes("\n") || /^(openapi|swagger)\s*:/i.test(trimmed)) return "inline";
+	if (gitInputRegExp.test(input)) return "git";
 	if (URL.canParse(input)) return "url";
 	return "file";
 }
@@ -1269,8 +1390,9 @@ function isLegacyInput(input) {
 /**
 * 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
-* local path is resolved against `config.root`, both as `{ type: 'path' }`.
+* A parsed object and inline content become `{ type: 'data' }`; a URL or git input is kept
+* verbatim and a local path is resolved against `config.root`, all as `{ type: 'path' }`. The
+* driver checks out a git input before the adapter parses it.
 */
 function inputToAdapterSource(config) {
 	const input = config.input;
@@ -1297,7 +1419,7 @@ function inputToAdapterSource(config) {
 		type: "data",
 		data: input
 	};
-	if (kind === "url") return {
+	if (kind === "url" || kind === "git") return {
 		type: "path",
 		path: input
 	};
@@ -2231,13 +2353,20 @@ var KubbDriver = class {
 	async #parseInput() {
 		if (this.inputNode || !this.adapter || !this.#adapterSource) return;
 		this.options.signal?.throwIfAborted();
+		const source = this.#adapterSource;
+		const checkout = source.type === "path" && gitInputRegExp.test(source.path) ? await checkoutGitInput(source.path, this.options.signal) : void 0;
 		try {
-			this.inputNode = await this.adapter.parse(this.#adapterSource, { signal: this.options.signal });
+			this.inputNode = await this.adapter.parse(checkout ? {
+				type: "path",
+				path: checkout.path
+			} : source, { signal: this.options.signal });
 		} catch (caughtError) {
 			throw new Diagnostics.Error(Diagnostics.fromExtension(caughtError, {
 				kind: "adapter",
 				extension: this.adapter
 			}));
+		} finally {
+			await checkout?.dispose();
 		}
 	}
 	/**
@@ -2856,6 +2985,6 @@ var Hookable = class {
 	}
 };
 //#endregion
-export { inParallel as A, __name as B, useOptions as C, Diagnostics as D, resolveMeta as E, rm as F, write as I, writeRaw as L, isPathInside as M, listFiles as N, formatMs as O, read as P, toError as R, useKubb as S, defineExtension as T, setMacros as _, FileManager as a, tryUseKubb as b, Resolver as c, definePlugin as d, addGenerator as f, requirePlugin as g, kubbContext as h, createNodeCache as i, existsSync$1 as j, getElapsedMs as k, getInputKind as l, injectFile as m, KubbDriver as n, _usingCtx as o, addMacro as p, pluginNotFoundError as r, createResolver as s, Hookable as t, assertPluginOption as u, setOptions as v, checkCompatibility as w, useConfig as x, setResolver as y, camelCase as z };
+export { getElapsedMs as A, camelCase as B, useKubb as C, resolveMeta as D, defineExtension as E, read as F, rm$1 as I, write as L, existsSync$1 as M, isPathInside as N, Diagnostics as O, listFiles as P, writeRaw as R, useConfig as S, checkCompatibility as T, __name as V, requirePlugin as _, FileManager as a, setResolver as b, Resolver as c, assertPluginOption as d, definePlugin as f, kubbContext as g, injectFile as h, createNodeCache as i, inParallel as j, formatMs as k, getInputKind as l, addMacro as m, KubbDriver as n, _usingCtx as o, addGenerator as p, pluginNotFoundError as r, createResolver as s, Hookable as t, checkoutGitInput as u, setMacros as v, useOptions as w, tryUseKubb as x, setOptions as y, toError as z };
 
-//# sourceMappingURL=Hookable-CvStaYYq.js.map
+//# sourceMappingURL=Hookable-Cqx0g2T-.js.map