@kubb/core 5.0.0-beta.41 → 5.0.0-beta.43

package/dist/{memoryStorage-DA1bnMte.js → memoryStorage-C0n47hZ2.js}

@@ -1,7 +1,9 @@
 import "./chunk-C0LytTxp.js";
 import { EventEmitter } from "node:events";
 import { styleText } from "node:util";
-import path, { extname, resolve } from "node:path";
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import path, { basename, extname, join, relative, resolve } from "node:path";
 import { collectUsedSchemaNames, createFile, createStreamInput, extractStringsFromNodes, isOperationNode, isSchemaNode, transform } from "@kubb/ast";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region ../../internals/utils/src/errors.ts
@@ -635,7 +637,7 @@ var URLPath = class {
 };
 //#endregion
 //#region package.json
-var version = "5.0.0-beta.41";
+var version = "5.0.0-beta.43";
 //#endregion
 //#region src/constants.ts
 /**
@@ -1204,6 +1206,89 @@ function createStorage(build) {
 	return (options) => build(options ?? {});
 }
 //#endregion
+//#region src/Fingerprint.ts
+/**
+* Computes the cache key for an incremental build. All methods are static, so call them as
+* `Fingerprint.compute(...)` and `Fingerprint.stringify(...)`. The key holds no absolute
+* paths or modification times, so it never depends on where the project lives on disk.
+*/
+var Fingerprint = class Fingerprint {
+	/**
+	* Bumped when the snapshot format or fingerprint inputs change in an incompatible way, so stale
+	* cache entries from older Kubb builds are never reused.
+	*/
+	static version = 1;
+	/**
+	* Deterministically serializes a value to JSON: object keys are sorted recursively and
+	* `undefined` values and functions are dropped. Two structurally equal configs produce the same
+	* string regardless of key order, which keeps the fingerprint stable across machines.
+	*/
+	static stringify(value) {
+		return JSON.stringify(Fingerprint.#normalize(value));
+	}
+	/**
+	* Computes a cache key from everything that affects the generated output: the spec content, the
+	* output-shaping config, each plugin's name and options, the middleware names, the running
+	* `@kubb/core` version, and the cache format version. Returns `null` when the input can't be
+	* fingerprinted (remote URL or no adapter source), which disables caching for that build.
+	*/
+	static async compute({ config, adapterSource, version }) {
+		if (!adapterSource) return null;
+		const spec = await Fingerprint.#readSpec(adapterSource, config.root);
+		if (spec === null) return null;
+		const input = {
+			cacheVersion: Fingerprint.version,
+			version,
+			spec,
+			name: config.name,
+			output: config.output,
+			adapter: config.adapter?.name,
+			parsers: config.parsers.map((parser) => parser.name),
+			plugins: config.plugins.map((plugin) => ({
+				name: plugin.name,
+				options: plugin.options
+			})),
+			middleware: (config.middleware ?? []).map((middleware) => middleware.name)
+		};
+		return createHash("sha256").update(Fingerprint.stringify(input)).digest("hex");
+	}
+	static #normalize(value) {
+		if (value === null || typeof value !== "object") return typeof value === "function" ? void 0 : value;
+		if (Array.isArray(value)) return value.map((item) => Fingerprint.#normalize(item));
+		const source = value;
+		const result = {};
+		for (const key of Object.keys(source).sort()) {
+			const normalized = Fingerprint.#normalize(source[key]);
+			if (normalized !== void 0) result[key] = normalized;
+		}
+		return result;
+	}
+	/**
+	* Reads the spec content that feeds the fingerprint. Returns `null` for a remote URL source
+	* (hashing remote content would mean fetching it on every run) or when a file can't be read, so a
+	* missing or virtual spec disables caching instead of failing the build.
+	*/
+	static async #readSpec(source, root) {
+		if (source.type === "data") return {
+			kind: "data",
+			data: typeof source.data === "string" ? source.data : Fingerprint.stringify(source.data)
+		};
+		const paths = source.type === "paths" ? source.paths : [source.path];
+		if (paths.some((path) => new URLPath(path).isURL)) return null;
+		try {
+			return {
+				kind: "path",
+				contents: await Promise.all(paths.map(async (path) => ({
+					path: relative(root, path),
+					content: await readFile(path, "utf8")
+				})))
+			};
+		} catch {
+			return null;
+		}
+	}
+};
+//#endregion
 //#region src/definePlugin.ts
 /**
 * Wraps a plugin factory and returns a function that accepts user options and
@@ -1975,7 +2060,7 @@ var Transform = class {
 	}
 };
 //#endregion
-//#region \0@oxc-project+runtime@0.133.0/helpers/esm/usingCtx.js
+//#region \0@oxc-project+runtime@0.134.0/helpers/esm/usingCtx.js
 function _usingCtx() {
 	var r = "function" == typeof SuppressedError ? SuppressedError : function(r, e) {
 		var n = Error();
@@ -2098,9 +2183,10 @@ var KubbDriver = class KubbDriver {
 	}
 	async setup() {
 		const normalized = this.config.plugins.map((rawPlugin) => this.#normalizePlugin(rawPlugin));
+		const dependenciesByName = new Map(normalized.map((plugin) => [plugin.name, new Set(plugin.dependencies ?? [])]));
 		normalized.sort((a, b) => {
-			if (b.dependencies?.includes(a.name)) return -1;
-			if (a.dependencies?.includes(b.name)) return 1;
+			if (dependenciesByName.get(b.name)?.has(a.name)) return -1;
+			if (dependenciesByName.get(a.name)?.has(b.name)) return 1;
 			return enforceOrder(a.enforce) - enforceOrder(b.enforce);
 		});
 		for (const plugin of normalized) {
@@ -2325,8 +2411,10 @@ var KubbDriver = class KubbDriver {
 			await hooks.emit("kubb:files:processing:start", { files });
 		});
 		const updateBuffer = [];
+		const snapshotSources = /* @__PURE__ */ new Map();
 		processor.hooks.on("update", (item) => {
 			updateBuffer.push(item);
+			if (item.source !== void 0) snapshotSources.set(item.file.path, item.source);
 		});
 		processor.hooks.on("end", async (files) => {
 			await hooks.emit("kubb:files:processing:update", { files: updateBuffer.map((item) => ({
@@ -2342,6 +2430,19 @@ var KubbDriver = class KubbDriver {
 		this.fileManager.hooks.on("upsert", onFileUpsert);
 		return Diagnostics.scope((diagnostic) => diagnostics.push(diagnostic), async () => {
 			try {
+				const cache = config.cache;
+				const outputRoot = resolve(config.root, config.output.path);
+				const cacheKey = cache ? await Fingerprint.compute({
+					config,
+					adapterSource: this.#adapterSource,
+					version
+				}) : null;
+				if (cache && cacheKey && await this.#restoreSnapshot({
+					cache,
+					cacheKey,
+					outputRoot,
+					storage
+				})) return { diagnostics: Diagnostics.dedupe(diagnostics) };
 				await this.#parseInput();
 				await this.emitSetupHooks();
 				if (this.adapter && this.inputNode) await hooks.emit("kubb:build:start", Object.assign({
@@ -2400,7 +2501,13 @@ var KubbDriver = class KubbDriver {
 				await hooks.emit("kubb:build:end", {
 					files: this.fileManager.files,
 					config,
-					outputDir: resolve(config.root, config.output.path)
+					outputDir: outputRoot
+				});
+				if (cache && cacheKey && !Diagnostics.hasError(diagnostics)) await this.#persistSnapshot({
+					cache,
+					cacheKey,
+					outputRoot,
+					sources: snapshotSources
 				});
 				return { diagnostics: Diagnostics.dedupe(diagnostics) };
 			} catch (caughtError) {
@@ -2411,6 +2518,40 @@ var KubbDriver = class KubbDriver {
 			}
 		});
 	}
+	/**
+	* Writes a restored snapshot straight to storage and emits `kubb:build:end`. Returns `true` on a
+	* hit (the build is done), `false` on a miss so the caller falls through to a full build.
+	*/
+	async #restoreSnapshot({ cache, cacheKey, outputRoot, storage }) {
+		const snapshot = await cache.restore({ key: cacheKey });
+		if (!snapshot) return false;
+		for (const [relativePath, source] of Object.entries(snapshot.files)) {
+			const absolutePath = join(outputRoot, relativePath);
+			this.fileManager.upsert(createFile({
+				path: absolutePath,
+				baseName: basename(relativePath)
+			}));
+			await storage.setItem(absolutePath, source);
+		}
+		await this.hooks.emit("kubb:build:end", {
+			files: this.fileManager.files,
+			config: this.config,
+			outputDir: outputRoot
+		});
+		return true;
+	}
+	/**
+	* Stores this run's rendered output, keyed by the input fingerprint, so the next unchanged build
+	* restores it instead of regenerating. `sources` is keyed by absolute path and relativized here.
+	*/
+	async #persistSnapshot({ cache, cacheKey, outputRoot, sources }) {
+		const files = {};
+		for (const [absolutePath, source] of sources) files[relative(outputRoot, absolutePath)] = source;
+		await cache.persist({
+			key: cacheKey,
+			snapshot: { files }
+		});
+	}
 	#filesPayload() {
 		const driver = this;
 		return {
@@ -2487,10 +2628,8 @@ var KubbDriver = class KubbDriver {
 		const emitsSchemaHook = this.hooks.listenerCount("kubb:generate:schema") > 0;
 		const emitsOperationHook = this.hooks.listenerCount("kubb:generate:operation") > 0;
 		const emitsOperationsHook = this.hooks.listenerCount("kubb:generate:operations") > 0;
-		const schemasBuffer = [];
-		for await (const schema of schemas) schemasBuffer.push(schema);
-		const operationsBuffer = [];
-		for await (const operation of operations) operationsBuffer.push(operation);
+		const schemasBuffer = await Array.fromAsync(schemas);
+		const operationsBuffer = await Array.fromAsync(operations);
 		const pruningStates = states.filter(({ plugin }) => {
 			const { include } = plugin.options;
 			return (include?.some(({ type }) => OPERATION_FILTER_TYPES.has(type)) ?? false) && !(include?.some(({ type }) => type === "schemaName") ?? false);
@@ -2857,4 +2996,4 @@ const memoryStorage = createStorage(() => {
 //#endregion
 export { FileManager as a, createStorage as c, URLPath as d, formatMs as f, BuildError as g, AsyncEventEmitter as h, FileProcessor as i, Diagnostics as l, camelCase as m, KubbDriver as n, defineResolver as o, getElapsedMs as p, _usingCtx as r, definePlugin as s, memoryStorage as t, OTLP_ENDPOINT as u };
 
-//# sourceMappingURL=memoryStorage-DA1bnMte.js.map
+//# sourceMappingURL=memoryStorage-C0n47hZ2.js.map